lego-father

A package parser that can resolve self and dependencies, supporting lego / component.

---

Install

$ npm install lego-father -g

Usage

// using LegoPackage
var Package = require('lego-father').LegoPackage;
var pkg = new Package('path/to/package')
console.log(pkg.name);
console.log(pkg.version);
console.log(pkg.main);
console.log(pkg.dependencies); // return a object contains dependencies
console.log(pkg.get('each')); // return a package named each

// using ComponentPackage
var Package = require('lego-father').ComponentPackage;

Properties

The properties of Package instance

pkg.id

Unique id for each package

= {pkg.name}@{pkg.version}

pkg.name require

Package's name

pkg.version require

Package's version

pkg.main

Entry point of the package, default is index.js

pkg.dependencies

Package's dependencies, each one will return a Package instance

pkg.files

All used files will exist in pkg.files, it will be parsed from pkg.main. Each file contains dependent files (no deep dependencies).

Example below

{
  files: {
    'index.js': {
      dependencies: ['each', './feature']
    }
  }
}

pkg.dest

The base directory of the package

pkg.origin

The origin package info

pkg.output

Export files when build

Method

pkg.getPackage(pkg.id)

Get a package by id

pkg.setPackage(pkg)

Set a package

pkg.getPackages()

Get all dependent packages

pkg.getFile(fullpath)

Get file object by given path

pkg.getFiles()

Get all file objects

Options

The options when instantiation

new Package('path/to/package', options);

entry

Generally, files will be parsed from pkg.main, no dependent file will not be included. entry will be another entry point.

Files

// a.js <- pkg.main
console.log('no require');

// b.js
require('./c');

// c.js
console.log('no require');

Code

new Package('path/to/package', {
  entry: ['b.js']
});

Return

// without entry
{
  ...
  files: {
    'a.js': []
  }
}

// with entry
{
  ...
  files: {
    'a.js': [],
    'b.js': ['./c'],
    'c.js': []
  }
}

skip

// a.js
require('b')

If you want to skip file or package, you can specify skip. And it won't parse b and won't exist in dependencies.

new Package('path/to/package', {
  skip: ['b']
});

yield

define('a', [], function(require) {
  require('b')
});

ignore

Almost same as skip, however it will exist in dependency.

moduleDir

Where is your modules

File object

what you get in pkg.files is file objects that is extending vinyl.

var fileObj = pkg.files['a.js'];
fileObj.pkg
fileObj.relative
fileObj.extension
fileObj.path // = fileObj.pkg.dest + fileObj.relative

lookup

lookup all dependencies and can be filtered or transformed in callback

fileObj.lookup(function(fileInfo) {
  // fileInfo.path: filepath of fileinfo
  // fileInfo.relative: filepath based on packagge
  // fileInfo.pkg: package info
  // fileInfo.isRelative: required by file in the same package
  // fileInfo.dependent: dependent package
  // fileInfo.extension: exntesion of the file
  return fileInfo.filepath;

  return false; // ignore
});

hasExt

Determine whether it has the matched extension in all dependencies.

fileObj.hasExt('css'); // return false

Custom

If you want to use it for your package, you can extend Package and override readPackage.

var Package = require('lego-father').Package;
var Custom = Package.extend({
  readPackage: function() {
    // 1. read config file, E.g. component.json
    // 2. return a package contains id, name, version, dependencies, main, dest, files, origin
    // 3. dependencies should contain id, name, version, dest
  };
})

Example for returned object by readPackage

{
  id: 'a',
  name: 'a'  
  version: '1.0.0',
  main: 'index.js',
  dest: '/home/user/a',
  dependencies: {
    b: {
      id: 'b@1.1.0',
      name: 'b',
      version: '1.1.0',
      dest: '/home/user/a/components/b'
    }
  }
}

LISENCE

Copyright (c) 2014 herbertliu. Licensed under the MIT license.