Solid Goggles




1. Install
1. Import
1. Basic Usage
1. Decorators
1. Methods
1. Properties
1. Clone Injector
1. Factory
1. Events
1. Symbols
1. Injection Hooks
1. Overwrite
1. Other Models
1. Change Dependencies

Install

``bash
$ npm i solid-goggles
`

Import

$3

`html


`

$3

`javascript
const Sg = require('solid-goggles');
`

$3

`javascript
import * as Sg from 'solid-goggles';
`

Basic Usage

`javascript
import { Injector } from 'solid-goggles';

class Implementation {
method() {}
}
const injector = Injector.of(Implementation);

class Interface {
method() {}
}

const instance = injector.get(Interface);
`

Decorators

$3

`javascript
import { connect } from 'solid-goggles';

class OtherImplementation {}

class Implementation {

@connect(OtherImplementation) property;

constructor(
@connect(OtherImplementation) parameter
) {}

method(@connect(OtherImplementation) parameter) {}
}
`

`typescript
// TYPESCRIPT

import 'reflect-metadata';
import { connect } from 'solid-goggles';

class OtherImplementation {}

class Implementation {

@connect() property: OtherImplementation;

constructor(
@connect() parameter: OtherImplementation
) {}

method(@connect() parameter: OtherImplementation) {}

}
`

$3

`javascript
import { Injector, register } from 'solid-goggles';

class Implementation {}

@register(Implementation)
class Interface {}

const injector = new Injector;
injector.get(Interface);
`

$3

`javascript
import { Injector, implement } from 'solid-goggles';

class Interface {}

@implement(Interface)
class Implementation {}

const injector = new Injector;
injector.get(Interface);
`

Methods

`javascript
import { Injector } from 'solid-goggles';

class Interface {}
class Implementation {}

const injector = new Injector;

injector.setImplementation(Implementation);
injector.tryGet(Implementation);

/* breaks without implementation /
const instance = injector.get(Interface);

injector.set(Interface, instance);
injector.delete(Interface);

/* breaks on wrong implementation /
injector.link(Interface, Implementation);

injector.tryLink(Interface, Implementation);

injector.factory(Implementation, (implementation, args, injector) => new implementation(...args));

injector.onEvery(Implementation, (instance, next) => next(instance));
injector.onGet(Implementation, (instance, next) => next(instance));
injector.onSet(Implementation, (instance, next) => next(instance));
injector.onDelete(Implementation, (instance, next) => next(instance));
injector.onInstantiate(Implementation, (instance, next) => next(instance));

/* instantiate + set + properties /
injector.generate(Implementation);

/* factory + parameters /
injector.instantiate(Implementation);

injector.parameters(Implementation);

injector.properties(instance);
injector.methods(instance);

/* delete all instances /
injector.clear();

injector.findInterface(Interface || Implementation || instance);
injector.findImplementation(Interface || Implementation || instance);
injector.findInstance(Interface || Implementation || instance);

injector.canImplement(Interface, Implementation);

injector.getFactory(Implementation);
injector.getCanImplement(Interface, Implementation);
`

Properties

`javascript
import { Injector } from 'solid-goggles';
import { Container } from 'solid-goggles';
import { InjectorEmitter } from 'solid-goggles';

const injector = new Injector({
container: new Container,
emitter: new InjectorEmitter,
factories: new Map
});
`

Clone Injector

`javascript
const injector = new Injector;
const clone = new Injector(injector);
`

Factory

`javascript
import { Injector } from 'solid-goggles';

class Implementation {}

const injector = new Injector;

/ generic factory /
injector.factory((implementation, args, injector) => new implementation(...args));

/ specific implementation /
injector.factory(Implementation, (implementation, args, injector) => new implementation(...args));
`

Events

`javascript
import { Injector } from 'solid-goggles';

class Implementation {}

const injector = new Injector;

injector.onEvery((instance, next) => {
/ all events /
return next(instance);
});

injector.onGet((instance, next) => {
/* generic /
return next(instance);
});

injector.onGet(Implementation, (instance, next) => {
/* implementation /
return next(instance);
});
`

Symbols

`javascript
import { canImplement, findImplementation, factory, parameters, properties, methods } from 'solid-goggles';
`

Injection Hooks

$3

`javascript
import { parameters } from 'solid-goggles';

class OtherImplementation {}

class Implementation {

/* Warn: Unhandled Circular Dependency /
static [parameters]() { return [ OtherImplementation ]; }

constructor(otherInstance) {
this.otherInstance = otherInstance;
}
}
`

$3

`javascript
import { properties } from 'solid-goggles';

class Implementation {

properties {

/* Allow circular dependencies /

return {
instance: Implementation
};
}
}
`

$3

`javascript
import { methods } from 'solid-goggles';

class Implementation {

methods {

/* Allow circular dependencies /

return { method: [ Implementation ] };
}

method(instance) {}
}
`

$3

`javascript
import { findImplementation, Injector } from 'solid-goggles';

class Implementation {}

class Interface {

/ Must be static property /
static get [findImplementation]() { return Implementation; }
}

const injector = new Injector;
injector.get(Inteface);
`

Overwrite

`javascript
import { Injector, canImplement, factory } from 'solid-goggles';

Injector.baseCanImplement = (interface, implementation, injector) => true;
Injector.baseFactory = (implementation, args, injector) => new implementation(...args);

const injector = new Injector;

injector.baseCanImplement = (interface, implementation, injector) => true;
injector.baseFactory = (implementation, args, injector) => new implementation(...args);

class Interface {
static canImplement {
return true;
}
}
class Implementation {
static canImplement {
return true;
}

static factory {
return new constructor(...args);
}
}
`

Other Models

$3

`javascript
import { Container } from 'solid-goggles';

class Interface {}
class Implementation {}
const instance = new Implementation;

const container = new Container([
[Interface, Implementation, instance]
]);

container.parent = new Container;

container.getInterface(Interface || Implementation || instance);
container.getImplementation(Interface || Implementation || instance);
container.getInstance(Interface || Implementation || instance);

container.setInterface(Implementation, Interface);
container.setImplementation(Implementation);
container.setInstance(Implementation, instance);

container.deleteInterface(Interface || Implementation || instance);
container.deleteImplementation(Interface || Implementation || instance);
container.deleteInstance(Interface || Implementation || instance);

container.clearInterfaces();
container.clearImplementations();
container.clearInstances();
`

$3

`javascript
import { InjectorEmitter } from 'solid-goggles';

const emitter = new InjectorEmitter;

class Implementation {}
const instance = new Implementation;

const everyListener = emitter.onEvery(Implementation, (instance, next) => next(instance));
const getListener = emitter.onGet(Implementation, (instance, next) => next(instance));
const setListener = emitter.onSet(Implementation, (instance, next) => next(instance));
const deleteListener = emitter.onDelete(Implementation, (instance, next) => next(instance));
const instantiateListener = emitter.onInstantiate(Implementation, (instance, next) => next(instance));

emitter.emitEvery(Implementation, instance);
emitter.emtiGet(Implementation, instance);
emitter.emitSet(Implementation, instance);
emitter.emitDelete(Implementation, instance);
emitter.emitInstantiate(Implementation, instance);

emitter.removeEvery(Implementation, everyListener);
emitter.removeGet(Implementation, getListener);
emitter.removeSet(Implementation, setListener);
emitter.removeDelete(Implementation, deleteListener);
emitter.removeInstantiate(Implementation, instantiateListener);
`

$3

`javascript
import { InjectorError } from 'solid-goggles';

class Interface {}
class Implementation {}

const injectorError = new InjectorError(Interface, Implementation, 'message');
`

Change Dependencies

`javascript
import { Injector, Container, InjectorEmitter } from 'solid-goggles';

class OtherContainer implements Container {}
class OtherInjectorEmitter implements InjectorEmitter {}

const injector = new Injector(undefined, OtherContainer, OtherInjectorEmitter);
``