Package Exports

type-factory

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (type-factory) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

Type factory

Type factory is a convenient generator of javascript prototype based constructor functions with simple and easy to use syntax. Types can be easily extended and used as basis for modules of any purpose. It weighs less than 2KB.

Visit documentation site.

Type factory is a small helper function by which a constructor function can be defined without the usual verbosity. Each generated type can be easily extended with no need for manual setup of prototype chain. Parameters passed to constructor can be merged with defaults, type checked and validated. Type factory can be used with bundlers or browser globals.

Examples

Without Type factory you could define a type with code similar to one bellow.

// first we define a constructor function
var Person = function(name) {
    this.name = name;
};

// then we add methods to function prototype (instance methods)
Person.prototype.sayHi = function() {
    console.log('Hello, my name is ' + this.name);
};

// now lets make a new person...
var john = new Person('John');

// ...and make them do something
john.sayHi(); // outputs 'Hello, my name is John'

Same functionality with typeFactory would be achieved like so:

var Person = typeFactory({
    initialize: function(name) {
        this.name = name;
    },
    sayHi: function() {
        console.log('Hello, my name is ' + this.name);
    }
});

var george = new Person('George');
george.sayHi(); // outputs 'Hello, my name is George'

Extending type

Every type produced with Type factory receives convenient extend method for all your extending needs. Consider next example:

var Musician = Person.extend({
    play: function() {
        console.log(this.name + ' is playing!');
    }
});

var peter = new Musician('Peter');

peter.sayHi(); // outputs 'Hello, my name is Peter'
peter.play(); // outputs 'Peter is playing!'

Setting defaults

Default options can be set when defining type. Defaults will be merged with options provided to constructor. Sometimes it is convienent to list all parameters your type depends on:

var Musician = Person.extend({
    assignOptions: true,
    defaults: {
        instrument: 'guitar'
        age: undefined
        mentor: undefined
    }
});

var peter = new Musician({age: 18});

// outputs {instrument: 'guitar', age: 18}
console.log(peter.options)

Parameters type checking and validation

Options provided by type defaults and and constructor parameters can be type checked.

var Musician = Person.extend({
    assignOptions: true,
    optionRules: {
        instrument: {type: 'string'},
        age: {type: 'number', default: 18}
    }
});

// will throw error -> age should be a number
new Person({age: 'adult'});

Option rules can be configured to do following

set expectations for parameter typeof check via "type" key.
define default value via "default" property
require parameter to pass instanceof check via "instanceOf" key
defined custom validation logic via callback under "rule" key

var Musician = Person.extend({
    assignOptions: true,
    optionRules: {
        instrument: {type: 'string'},
        age: {type: 'number', default: 18, rule: function(age) {
            return age >= 18;
        }},
        mentor: {instanceOf: Person}
    }
});

Installation

Type factory is packaged as UMD library so you can use it both on client and server (CommonJS and AMD environment) or with browser globals.

// install via npm
npm install type-factory --save

// if you use bundler
var typeFactory = require('type-factory');

// or use browser globals
var typeFactory = window.typeFactory;
```