https://github.com/ziflex/namespaces
Angular-flavored dependency container
https://github.com/ziflex/namespaces
Last synced: 3 months ago
JSON representation
Angular-flavored dependency container
- Host: GitHub
- URL: https://github.com/ziflex/namespaces
- Owner: ziflex
- License: mit
- Created: 2015-10-09T20:37:11.000Z (over 9 years ago)
- Default Branch: master
- Last Pushed: 2016-12-17T22:43:23.000Z (over 8 years ago)
- Last Synced: 2025-03-08T03:03:40.496Z (3 months ago)
- Language: JavaScript
- Homepage: http://ziflex.github.io/namespaces/
- Size: 2.16 MB
- Stars: 0
- Watchers: 2
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
# namespaces
> Universal registry
Angular-flavored DI container.
[](https://www.npmjs.com/package/namespaces-js)
[](http://travis-ci.org/ziflex/namespaces)
[](https://coveralls.io/github/ziflex/namespaces)
## API
You can find API [here](http://ziflex.github.io/namespaces)
## Install
```sh
$ npm install --save namespaces-js
```
## Motivation
We all love testable and modular code. In most cases it means that every piece of you system
depends on other pieces and these dependencies should be injected if we want to make our system testable and flexible. But wiring everything up might be a very tedious task with creating multiple instances, passing them into others and then, once requirements or designed changed, finding, replacing, updating and etc...
So, that's why ``namespaces`` package was created - to solve this issue. It allows you organize your system parts and easily define their dependencies by creating an application container with namespaces.
Its design is inspired by Angular v1 DI, therefore most of the concepts might be familiar for those of you who are familiar with Angular v1, but some are new.
## Usage
### Just as a container
#### Stores values
```javascript
var Container = require('namespaces-js');
var container = new Container();
container.const('foo', 'bar');
const foo = container.resolve('foo');
console.log(foo); // -> 'bar'
```
#### Creates singletons
```javascript
var Container = require('namespaces-js');
var container = new Container();
container.factory('foo', () => {
return { do: => 'bar' };
});
const foo1 = container.resolve('foo');
const foo2 = container.resolve('foo');
console.log(foo1 === foo2); // -> true
```
### As a container with dependencies
#### Resolves dependencies by module name
```javascript
var Container = require('namespaces-js');
var container = new Container();
container.factory('foo', () => 'bar');
container.factory('qaz', ['foo'], (foo) => `${foo}-fighter`);
const qaz = container.resolve('qaz');
console.log(qaz); // 'bar-fighter';
```
#### Resolves dependencies by custom resolver
```javascript
var Container = require('namespaces-js');
var container = new Container();
container.factory('foo', () => 'bar');
container.factory('qaz', [
'foo',
function customResolver() {
return 'wsx';
}
], (foo, something) => {
return `${foo}-${something}`;
});
const qaz = container.resolve('qaz');
console.log(qaz); // 'bar-wsx';
```
### Creates nested containers with namespaces
```javascript
var Container = require('namespaces-js');
var container = new Container();
container.value('foo', 'bar');;
container.namespace('my-namespace').value('foo', 'qaz');
container.namespace('my-namespace/sub-namespace-1').value('foo', 'qaz');
const foo = container.resolve('foo');
const foo2 = container.resolve('my-namespace/foo');
const foo3 = container.resolve('my-namespace/sub-namespace/foo');
console.log(foo === foo2); // false
container.namespace('my-namespace').namespace('sub-namespace-2').factory('foobar', [
'foo',
'my-namespace-1/foo'
], (foo, foo2) => {
return `${foo} !== ${foo2}`;
});
const foobar = container.resolve('my-namespace/sub-namespace-2/foobar');
console.log(foobar); // 'bar !== qaz';
```
### Namespace Helper
It comes with a handy utility function that converts a given namespace tree into function tree.
Each function-node of the tree recieves a module name and returns a full path of it.
````javascript
var namespaces = Container.map({
a: 'b',
c: ['d', 'e', { f: ['g', 'h'] }]
});
var container = new Container();
container.namespace(namespaces.a()).value('foo', 'bar');
container.namespace(namespaces.b()).factory('foo', () => 'bar');
container.namespace(namespaces.c()).factory('foo', () => 'bar');
container.namespace(namespaces.c.f.g()).value('foo', 'bar');
container.resolve(namespaces.a('foo'));
container.resolve(namespaces.c.f.g('foo'));
````