Comment construire un package intelligent Meteor

Comment peut-on construire un package intelligent Meteor qui apparaîtrait dans la meteor list ?

Construire des paquets d’ atmosphère est raisonnablement bien documenté , mais la construction de paquets Meteor n’en est pas une.

Meteor prend désormais en charge une commande create --package .

Voir les documents de meteors .

Exemple (remplacez votre propre compte de développeur de meteor par “cunneen”):

 meteor create --package cunneen:foo 

Sortie:

cunneen:foo: created in your app

Résultats:

packages / 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'); }); 

packages / cunneen: foo / foo.js (fichier vide)

 // Write your package code here! 

packages / cunneen: foo / foo-tests.js

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

packages / cunneen: foo / README.md (fichier vide)

 # cunneen:foo package 

Pour un bon exemple (très complet), jetez un coup d’œil à iron-router .

Voir la réponse de cobberboy ci-dessous

Les informations ci-dessous sont obsolètes:

Voir les informations sur le nouveau système d’emballage de meteor: https://meteorhacks.com/meteor-weekly-meteor-09-rc-meteor-new-logo-underscore-in-templates.html

** informations plus anciennes **

Il existe des informations mises à jour sur l’ écriture de votre propre package et sur le reconditionnement des bibliothèques tierces existantes . L’API ne sera pas stable jusqu’à la 1.0, alors soyez prêt à faire beaucoup de changements.

J’ai inclus la plaque de la chaudière pour aider à faire à la fois un nœud et une bibliothèque utilisable par meteors. Cela m’a pris pas mal de temps pour comprendre, ouvert aux suggestions.

paquet: /lib/my.js

 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'); } 

paquet: /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'] }); 

meteor app: un fichier dans le bon contexte client / serveur (tel que défini dans package.js)

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

meteor app: smart.json, ajoutez votre fichier à la liste des paquets

 { packages:{ "node-my": { "git": "[email protected]:myAccount/node-my.git" } } } 

Enfin, lancez mrt install sur la ligne de commande pour le faire installer le paquet .. Whew!

REMARQUE: Le développement de package n’est actuellement pas documenté et l’API changera. Tu as été prévenu!

Cela dit, il est en fait assez facile de commencer:

D’abord, git clone une copie du repo meteor. Faites-vous un nouveau répertoire dans / packages. Placez un fichier package.js dans le répertoire (voir les autres packages pour des exemples). Maintenant vous avez un paquet!

Ensuite, exécutez le script meteor de votre commande (pas celui installé par le programme d’installation). Lorsqu’il est exécuté à partir de l’extraction, le script utilisera le répertoire des packages locaux lors de l’extraction. Il sera même rechargé à chaud lorsque vous modifiez le code dans votre paquet.

Jetez un coup d’œil aux autres paquets pour trouver des exemples et avoir une idée de ce que fait l’API.

EDIT: beaucoup de progrès ont été réalisés en termes de packages tiers. Découvrez http://oortcloud.github.com/meteorite/ et https://atmosphere.meteor.com/

Il y a un bon screencast sur ce sujet sur EventedMind .

C’était en date du 12 juin 2013. C’était la bonne réponse à l’époque et c’est toujours une solution alternative:

Comme l’a dit N1mmy. Ce n’est pas documenté, et vous devriez utiliser la météorite.

Si vous insistez pour créer un paquet avec meteor, j’ai trouvé un bon How-to non officiel, mais vous ne devriez vraiment pas le faire. Meteor va sortir un moyen de créer des paquets dans une prochaine version.

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

La façon dont je le ferais serait avec Meteorite

De toute évidence, vous avez un nœud, et je suppose que vous avez un gestionnaire de paquets de nœuds (npm), donc votre meilleur moyen de créer un paquet de météorites est de créer un paquet intelligent de météorite.

 npm install meteorite 

Les paquets intelligents de météorites contiennent 2 fichiers de clé essentiels à la création de paquets – package.js – smart.json

Les fichiers Meteorite sont stockés sous votre compte utilisateur connecté au système: ~ / .meteorite /
mais sont liés à votre actuel où vous avez créé une application meteor: project / .meteor / meteorite /

Exemple de package.js:

 Package.describe({ summary: "User analytics suite for meteor" }); Package.on_use(function (api) { api.add_files('user_analytics.js', 'client'); }); 

Échantillon smart.json

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

Si vous avez besoin de plus d’informations, vous devez installer un paquetage mrt dans la liste:

 mrt list 

puis parsingz les fichiers sous votre répertoire app / .meteor / meteorite /.

J’espère que cela vous aidera et que vous continuerez à développer la meilleure langue du futur.

Voici quelques liens utiles:

  • http://www.eventedmind.com/ – Tutoriels exceptionnels expliquant les concepts de base de Meteor
  • la publication des packages Atmosphère
  • FAQ sur les meteors non officiels
  • faire une application de chatroom avec Meteor