kits

This is a kits pattern. Main idea of this to have registry and lightweight injections.

Idea is:

	let kit = Kit({
	    name: () => 'slava',
	    user: ({name}) => `My name is ${name}`
	});
	// console.log(kit.user) // My name is slava
	
	assert(kit.user === 'My name is slava');

Async kits here now: https://www.npmjs.com/package/kits-async.

Spec

const assert = require('assert');
const Kit = require('kits');

describe('Kit', () => {
    it('example', () => {
        let kit = Kit({
            name: () => 'slava',
            user: ({name}) => `My name is ${name}`
        });
        // console.log(kit.user) // My name is slava

        assert(kit.user === 'My name is slava');
    });

    it('construct and get', () => {

        let kit = Kit({
            Component: () => 'component-value'
        });

        assert.equal(kit.Component, 'component-value');
        assert.equal(kit.get('Component'), 'component-value');

        assert.equal(kit.NoComponent, undefined);
        assert.equal(kit.get('NoComponent'), undefined);
    })

    it('get - array of arguments', () => {

        let kit = Kit({
            Component1: () => 'component1',
            Component2: () => 'component2'
        });

        assert.deepEqual(kit.get(['Component1', 'Component2']), ['component1', 'component2']);
    })

    it('add - adds creator', () => {

        let kit = Kit();

        kit.add('Component', () => 'component')

        assert.equal(kit.Component, 'component');
        assert.equal(kit.get('Component'), 'component');

        assert.equal(kit.NoComponent, undefined);
        assert.equal(kit.get('NoComponent'), undefined);
    });

    it('create - should return new instance', () => {

        let kit = Kit();

        class TestComponent {
        }

        kit.add('Component', () => new TestComponent());

        assert.equal(kit.Component, kit.Component);
        assert.equal(kit.Component, kit.get('Component'));

        assert.notEqual(kit.Component, kit.create('Component'));
        assert(kit.get('Component') instanceof TestComponent);

        assert.notEqual(kit.create('Component'), kit.create('Component'));
    });

    it('creator - should be function', () => {

        return Promise.resolve()
            .then(() => {
                let kit = Kit();
                kit.add('Component', 'component');
            })
            .catch((err) => {
                assert.equal(err.message, "'Component' : creator is not a function");
            });
    });


    it('remove - should remove previous version', () => {

        let kit = Kit();

        class TestComponent {
        }

        kit.add('Component', () => new TestComponent());

        let Component = kit.Component;
        assert.equal(Component, kit.Component);

        kit.remove('Component');
        assert.equal(kit.Component, undefined);
    });

    it('get - should provide options in creator', () => {
        let kit = Kit();

        class TestComponent {
            constructor(options) {
                this.options = options;
            }
        }

        kit.add('Component', ({Options}) => new TestComponent(Options));

        kit.add('Options', () => {
            return {
                name: 'test',
                version: 1
            };
        });

        assert.deepEqual(kit.Component.options, {
            name: 'test',
            version: 1
        });

        assert.deepEqual(kit.Options, {
            name: 'test',
            version: 1
        });

        let {Options} = kit;
        assert.deepEqual(Options, {
            name: 'test',
            version: 1
        });
    });

    it('add - should remove previous value', () => {

        let kit = Kit();

        class TestComponent {
        }

        kit.add('Component', () => new TestComponent());
        assert(kit.Component instanceof TestComponent);

        kit.add('Component', () => 'value');

        assert.equal(kit.Component, 'value');
    });

    it('set - is alias for add', () => {

        let kit = Kit();

        class TestComponent {
        }

        kit.set('Component', () => new TestComponent());
        assert(kit.Component instanceof TestComponent);

        kit.set('Component', () => 'value');
        assert.equal(kit.Component, 'value');
    });

    it('defineDecorator - wrapper', () => {
        let kit = Kit({
            Component: () => 'component'
        });

        kit.defineDecorator((value, name) => `${value} -> ${name}`);

        assert.equal(kit.Component, 'component -> Component');
    });

    it('clone', () => {

        class TestComponent {
        }

        let kit = Kit({
            Component: () => new TestComponent()
        });

        let kit2 = Kit(kit);

        assert(kit.Component instanceof TestComponent);
        assert(kit2.Component instanceof TestComponent);

        assert.notEqual(kit.Component, kit2.Component);
    })

    it('es6 nested access', () => {
        let kit = Kit({
            user: () => {
                return {
                    name: 'slava'
                };
            },
            name: ({user: {name}}) => name
        });

        assert.equal(kit.name, 'slava');
    })

});

ES5

const Kit = require('kits/es5');