Come creare un pacchetto Smart Meteor

Question

Come si può costruire uno Meteor smart package che dovrebbe essere visualizzato in meteor list?

Edificio Atmosphere pacchetti è ragionevolmente bene documented, ma la costruzione di pacchetti Meteor non lo è.

Answer 1

Meteor supporta ora un comando create --package.

Vedere the meteor docs.

Esempio (sostituire il proprio meteor developer account per "Cunneen"):

meteor create --package cunneen:foo 

uscita:

cunneen:foo: created in your app

Risultati:

pacchetti/Cunneen: foo/package.js

Package.describe({ 
    name: 'cunneen:foo', 
    version: '0.0.1', 
    // Brief, one-line summary of the package. 
    summary: '', 
    // URL to the Git repository containing the source code for this package. 
    git: '', 
    // By default, Meteor will default to using README.md for documentation. 
    // To avoid submitting documentation, set this field to null. 
    documentation: 'README.md' 
}); 

Package.onUse(function(api) { 
    api.versionsFrom('1.0.3.1'); 
    api.addFiles('cunneen:foo.js'); 
}); 

Package.onTest(function(api) { 
    api.use('tinytest'); 
    api.use('cunneen:foo'); 
    api.addFiles('cunneen:foo-tests.js'); 
}); 

pacchetti/Cunneen: Esempio/foo.js (file vuoto)

// Write your package code here! 

pacchetti/Cunneen: Esempio/foo-tests.js

// Write your tests here! 
// Here is an example. 
Tinytest.add('example', function (test) { 
    test.equal(true, true); 
}); 

pacchetti/cunneen: foo/README.md (file vuoto)

# cunneen:foo package 

Per un buon esempio (MOLTO completo), dare un'occhiata a iron-router.

Answer 2

NOTA: lo sviluppo del pacchetto non è correntemente documentato e l'API cambierà. Sei stato avvisato!

Detto questo, in realtà è abbastanza facile iniziare:

In primo luogo, git clone una copia del pronti contro termine meteora. Crea una nuova directory in/packages. Metti un file package.js nella directory (vedi gli altri pacchetti per gli esempi). Ora hai un pacco!

Successivamente, esegui lo script di meteorologia dalla cassa (non quello installato dall'installatore). Quando viene eseguito dal checkout, lo script utilizzerà la directory dei pacchetti locali nel checkout. Si ricarica anche a caldo quando si modifica il codice nel pacchetto.

Dai un'occhiata agli altri pacchetti per esempi e per avere un'idea di cosa fa l'API.

EDIT: molti progressi sono stati compiuti in termini di pacchetti di terze parti. Scopri http://oortcloud.github.com/meteorite/ e https://atmosphere.meteor.com/

Answer 3

Questa era datato 12 giugno 2013. E 'stata la risposta giusta al momento, ed è ancora una soluzione alternativa:

Come n1mmy detto. Non è documentato e dovresti usare meteorite.

Se insisti a creare un pacchetto con la meteora, ho trovato una buona guida non ufficiale, ma davvero non dovresti farlo. Meteor uscirà con un modo per creare pacchetti in una prossima versione.

Bulding un pacchetto Meteor: https://coderwall.com/p/ork35q

Il modo in cui lo farei è con Meteorite

Ovviamente avete nodo, e presumo di avere pacchetti nodo del gestore (NPM), così il vostro migliore il modo di fare un pacchetto di meteore fino ad oggi, è di creare un pacchetto meteorite intelligente.

npm install meteorite 

Meteorite pacchetti intelligenti contengono 2 file di chiave essenziali per la creazione del pacchetto - package.js - smart.json

file Meteorite sono memorizzati sotto il vostro sistema di login dell'account utente: ~/.meteorite/
ma sono collegamenti simbolici al vostro attuale in cui è stato creato un app di meteoriti: progetto/.meteor/meteorite/

package.js campione:

Package.describe({ 
    summary: "User analytics suite for meteor" 
}); 

Package.on_use(function (api) { 
    api.add_files('user_analytics.js', 'client'); 
}); 

Esempio intelligente.JSON

{ 
    "name": "User analytics", 
    "description": "User Analytics", 
    "homepage": "http://yourHomepage.com", 
    "author": "Eric Leroy", 
    "version": "0.1", 
    "git": "https://github.com/yipyo", 
    "packages" : {} 
} 

Se avete bisogno di più informazioni, è necessario installare un pacchetto di MRT dalla lista:

mrt list 

poi analizzare i file sotto la tua app/.meteor/meteorite/directory.

Spero che questo aiuti e continui a sviluppare la migliore lingua del futuro.

Ecco alcuni link utili:

• http://www.eventedmind.com/ - tutorial eccezionali che spiegano concetti fondamentali del Meteor
• publishing Atmosphere packages
• Unofficial meteor FAQ
• making a chatroom app with Meteor

Answer 4

C'è una buona screencast su questo argomento su EventedMind.

Answer 5

Sede di cobberboy answer below

seguito è riportato informazioni obsolete:

Altre informazioni sul sistema nuovo packaging meteora: https://meteorhacks.com/meteor-weekly-meteor-09-rc-meteor-new-logo-underscore-in-templates.html

** più anziano informazioni **

Ci è informazioni aggiornate su writing your own package e circa repackaging existing 3rd party libraries. L'API non sarà stabile fino alla versione 1.0, quindi preparatevi a fare molte modifiche.

Ho incluso il piatto della caldaia per aiutare a rendere sia un nodo che una libreria utilizzabile da una sola volta. Questo mi ha richiesto un po 'di tempo per capire, aperto a suggerimenti. pacchetto

: /lib/my.js pacchetto

if (typeof Meteor === 'undefined) { 
    // Not Running In Meteor (nodejs code) 
    // example NPM/Node Dependencies that we'll use 
    var async = require('async'); 
    var debug = require('debug')('my:package'); 
    var mongodb = require('mongodb'); 

    var http = require('http'); 
} else { 
    // Running as Meteor Package 
    var async = Npm.require('async'); 
    var debug = Npm.require('debug')('my:package'); 
    var mongodb = Npm.require('mongodb'); 

    // node core module 'http' 
    // use Npm.require to require node core modules 
    // but doesnt need Npm.depends in the package.js file 
    var http = Npm.require('http'); 
} 

var constructor = function(property1) { 
    this.property1 = property1; // or whatever in your constructor. 
}; 

if (typeof Meteor === 'undefined') { 
    // Export it node style 
    My = exports = module.exports = constructor; // Limit scope to this nodejs file 
} else { 
    // Export it meteor style 
    My = constructor; // Make it a global 
} 

// Proceed defining methods/properties as usual. 
My.prototype.doStuff = function() { console.log('hello world'); } 

: /package.js

Package.describe({ 
    summary: "My Meteor Package" 
}); 

/** 
* Ex: Some NPM Dependencies 
*/ 
Npm.depends({ 
    'async': '0.2.9', 
    'debug': '0.7.2', 
    'mongodb': '1.3.18' 
}); 

/** 
* On use we'll add files and export our tool 
*/ 
Package.on_use(function (api) { 
    /** 
    * Add all the files, in the order of their dependence (eg, if A.js depends on B.js, B.js must be before A.js) 
    */ 
    api.add_files([ 
    'lib/my.js' // <-- include all the necessary files in the package 
    ], 
    'server'); // Can be 'server', 'client' , ['client','server'] 

    /** 
    * Only expose the My constructor, only export if meteor > 0.6.5 
    */ 
    api.export && api.export(['My'], 'server'); // 1st arg can be array of exported constructors/objects, 2nd can be 'server', 'client', ['client', 'server'] 
}); 

meteora app: qualche file nel giusto contesto client/server (come definito in package.js)

var my = new My('a property'); 
my.doStuff(); // console logs 'hello world' on the server 

meteora app: smart.json, aggiungere il file all'elenco dei pacchetti

{ 
    packages:{ 
     "node-my": { 
      "git": "git@github.com:myAccount/node-my.git" 
     } 
    } 
} 

Infine corsa mrt install sulla riga di comando per farlo installare il pacchetto .. Accidenti!