assemblerjs 0.0.97 → 0.0.99

package/README.md

@@ -1,5 +1,13 @@
 # assembler.js
 
+---
+
+[![npm version](https://badge.fury.io/js/assemblerjs.svg)](https://badge.fury.io/js/assemblerjs)
+
+![Statements](https://img.shields.io/badge/statements-84.3%25-yellow.svg?style=flat) ![Branches](https://img.shields.io/badge/branches-74.58%25-red.svg?style=flat) ![Functions](https://img.shields.io/badge/functions-81.48%25-yellow.svg?style=flat) ![Lines](https://img.shields.io/badge/lines-83.9%25-yellow.svg?style=flat)
+
+<br />
+
 `assembler.js` name is a tribute to Gilles Deleuze and Felix Guattari concept of [_Agencement_](<https://fr.wikipedia.org/wiki/Agencement_(philosophie)>) (in french) that can be translated into [Assemblage](<https://en.wikipedia.org/wiki/Assemblage_(philosophy)>).
 
 ## Install

package/dist/index.d.ts

@@ -5,18 +5,43 @@ declare interface Abstract<T> extends Function {
     prototype: T;
 }
 
+/**
+ * Base abstract class to implement an assemblage.
+ */
 export declare abstract class AbstractAssemblage {
     [key: string]: any;
-    abstract onInit?(): void | Promise<void>;
-    abstract onDispose?(): void;
+    /**
+     * Called on concrete class registration by assembler.
+     *
+     * @param { AssemblerContext } context The assembler's context.
+     */
+    static onRegister(context: AssemblerContext): void;
+    /**
+     * Called when class is instantiated.
+     *
+     * @param { AssemblerContext } context The assembler's context.
+     */
+    abstract onInit?(context: AssemblerContext): void | Promise<void>;
+    /**
+     * Called when instance of class is disposed.
+     *
+     * @param { AssemblerContext } context The assembler's context.
+     */
+    abstract onDispose?(context: AssemblerContext): void;
+    /**
+     * Dispose the assemblage instance.
+     */
+    abstract dispose?(): void;
 }
 
 export declare abstract class AbstractAssembler {
     abstract context: AssemblerContext;
-    abstract register<T>(injection: Injection<T>): void;
+    abstract size: number;
+    abstract register<T>(injection: Injection<T>): Injectable<T>;
     abstract has<T>(identifier: Identifier<T>): boolean;
     abstract require<T>(identifier: Identifier<T>): T;
     abstract tagged(...tags: string[]): any[];
+    abstract dispose(): void;
 }
 
 /**
@@ -46,6 +71,7 @@ export declare class Assembler implements AbstractAssembler {
     readonly context: AssemblerContext;
     static build(entry: Concrete<any>): Assembler;
     private constructor();
+    dispose(): void;
     /**
      * Recursively register an `Injection` tuple and its inner injected dependencies.
      *
@@ -74,33 +100,17 @@ export declare class Assembler implements AbstractAssembler {
      * identifier is not marked as 'singleton', will resolve in a new instance.
      */
     tagged(...tags: string[]): unknown[];
-}
-
-export declare class AssemblerContext {
     /**
-     * User-defined data. Can be used to add properties to context after creation.
+     * Size of the assembler: number of registered dependencies.
      */
-    readonly userData: Record<string, any>;
+    get size(): number;
+}
+
+export declare interface AssemblerContext {
     register: AbstractAssembler['register'];
     has: AbstractAssembler['has'];
     require: AbstractAssembler['require'];
     tagged: AbstractAssembler['tagged'];
-    constructor(assembler: AbstractAssembler);
-    /**
-     * Add a value to user-defined data.
-     *
-     * @param { string } key The key to add.
-     * @param { any } value The value to add.
-     * @returns { this } This context.
-     */
-    set(key: string, value: any): this;
-    /**
-     * Get a value in user-defined data for given key.
-     *
-     * @param { string } key The key to get from user-defined data.
-     * @returns { any } The result.
-     */
-    get(key: string): any;
 }
 
 /**
@@ -143,54 +153,60 @@ Record<string, any>
 
 export declare const Context: () => ParameterDecorator;
 
+export declare const Definition: () => ParameterDecorator;
+
 /**
  * An identifier can be an abstract or a concrete class.
  */
 declare type Identifier<T> = Concrete<T> | Abstract<T>;
 
 declare class Injectable<T> {
-    private context;
+    readonly context: AssemblerContext;
     readonly identifier: Identifier<T>;
     readonly concrete: Concrete<T>;
     readonly configuration: Record<string, any>;
-    singleton: T | undefined;
+    private dependenciesIds;
+    private singletonInstance;
     static of<TNew>(injection: Injection<TNew>, context: AssemblerContext): Injectable<TNew>;
     private constructor();
+    /**
+     * Dispose the injectable by deleting its singleton if exists.
+     */
+    dispose(): void;
     /**
      * Instantiate the assemblage or get its singleton instance.
      *
-     * @param { ...any[] } args The arguments to be passed to asssemblage's constructor.
      * @returns { T } The assemblage instance.
      */
     build(): T;
     /**
-     * Resolve dependencies passed as parameters in constructor.
-     *
-     * @returns { (Identifier<unknown> | any)[] } An array of parameters.
+     * Injectable assemblage's dependencies passed as 'constructor' parameters.
      */
-    private resolveDependencies;
+    get dependencies(): (Identifier<unknown> | any)[];
+    /**
+     * Metadatas passed in assemblage's definition or in its parent definition.
+     */
+    get definition(): AssemblageDefinition;
     /**
      * `true` if assemblage is a singleton.
-     *
-     * @todo Change assembler to avoid checking instance.
      */
     get isSingleton(): boolean;
     /**
-     * Injectable assemblage's own injections defined in its decorator's definition.
+     * The singleton instance if this `Injectable` wraps a singleton assemblage.
      */
-    get injections(): Injection<unknown>[];
+    get singleton(): T | undefined;
     /**
-     * Injectable assemblage's dependencies passed as 'constructor' parameters.
+     * Injectable assemblage's own injections defined in its decorator's definition.
      */
-    get dependencies(): (Identifier<unknown> | any)[];
+    get injections(): Injection<unknown>[];
     /**
-     * Tags passed in assemblage's definition or in its parent definition.
+     * Tags passed in assemblage's definition.
      */
     get tags(): string[];
     /**
-     * Metadatas passed in assemblage's definition or in its parent definition.
+     * Event channels passed in assemblage's definition.
      */
-    get metadata(): Record<string, any>;
+    get events(): string[];
 }
 
 /**
@@ -198,8 +214,6 @@ declare class Injectable<T> {
  */
 declare type Injection<T> = BaseInjection<T> | ConfiguredInjection<T> | ConcreteInjection<T> | ConcreteConfiguredInjection<T>;
 
-export declare const Metadata: () => ParameterDecorator;
-
 /**
  * An array of fixed length typed values.
  *

package/dist/index.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e="__",t="__",i="is_singleton",r="context_param_index",n="config_param_index",s="metadata_param_index",o=(i,r,n)=>{Reflect.defineMetadata(`${e}${i}${t}`,r,n)},a=(i,r)=>Reflect.getMetadata(`${e}${i}${t}`,r),c=(i,r)=>Reflect.getOwnMetadata(`${e}${i}${t}`,r);const h=e=>e&&"function"==typeof e&&void 0!==e.constructor,u=e=>t=>e.if(t)?e.then(t):e.else?e.else(t):void 0,l=e=>{const t=()=>h(e[0])&&(e=>"object"==typeof e&&!Array.isArray(e)&&!h(e))(e[1]);return((...e)=>t=>e.reduce(((e,t)=>t(e)),t))(u({if:()=>h(e[0])&&h(e[1]),then:()=>({identifier:e[0],concrete:e[1],configuration:{}})}),u({if:()=>t(),then:()=>({identifier:e[0],concrete:e[0],configuration:e[1]}),else:e=>e}))()},d=e=>((e,t)=>(i,...r)=>e[i]?e[i](...r):t?t(i,...r):void 0)({1:()=>(e=>({identifier:e[0],concrete:e[0],configuration:{}}))(e),2:()=>l(e),3:()=>(e=>({identifier:e[0],concrete:e[1],configuration:e[2]}))(e)},(()=>{throw new Error("Injection tuple must be of length 1, 2 or 3.")}))(e.length);function f(e,t,i){return t in e?Object.defineProperty(e,t,{value:i,enumerable:!0,configurable:!0,writable:!0}):e[t]=i,e}class g{static of(e,t){return new g(e,t)}build(){if(this.singleton)return this.singleton;const e=this.resolveDependencies(),t=new this.concrete(...e);return this.isSingleton&&(this.singleton=t),t}resolveDependencies(){const e=[],t=c(r,this.concrete)||[],i=c(n,this.concrete)||[],o=a(s,this.concrete)||[];let h=0;for(const r of this.dependencies)t.includes(h)?(e.push(this.context),h++):i.includes(h)?(e.push(this.configuration),h++):o.includes(h)?(e.push(this.metadata),h++):(e.push(this.context.require(r)),h++);return e}get isSingleton(){return c(i,this.concrete)||!1}get injections(){return c("inject",this.concrete)||[]}get dependencies(){return Reflect.getMetadata("design:paramtypes",this.concrete)||[]}get tags(){return a("tags",this.concrete)||[]}get metadata(){return a("metadata",this.concrete)||{}}constructor(e,t){f(this,"context",void 0),f(this,"identifier",void 0),f(this,"concrete",void 0),f(this,"configuration",void 0),f(this,"singleton",void 0),this.context=t;const i=d(e);this.identifier=i.identifier,this.concrete=i.concrete,this.configuration=i.configuration;for(const r of this.injections)this.context.register(r)}}function b(e,t,i){return t in e?Object.defineProperty(e,t,{value:i,enumerable:!0,configurable:!0,writable:!0}):e[t]=i,e}class p{set(e,t){if(this.userData[e])throw new Error(`Key '${e}' is already defined in context's user data.`);return this.userData[e]=t,this}get(e){return this.userData[e]}constructor(e){b(this,"userData",{}),b(this,"register",void 0),b(this,"has",void 0),b(this,"require",void 0),b(this,"tagged",void 0),this.register=e.register.bind(e),this.has=e.has.bind(e),this.require=e.require.bind(e),this.tagged=e.tagged.bind(e)}}function m(e,t,i){return t in e?Object.defineProperty(e,t,{value:i,enumerable:!0,configurable:!0,writable:!0}):e[t]=i,e}class w{static build(e){return new w(e)}register(e){const t=g.of(e,this.context);if(this.has(t.identifier))throw new Error(`An assemblage is already registered with identifier '${t.identifier.name}'.`);return this.injectables.set(t.identifier,t),t}has(e){return this.injectables.has(e)}require(e){if(!this.injectables.has(e))throw new Error(`Assemblage with identifier '${e.name}' has not been registered.`);return this.injectables.get(e).build()}tagged(...e){const t=[];for(const i of e)for(const[e,r]of this.injectables)r.tags.includes(i)&&t.push(r.build());return t}constructor(e){m(this,"injectables",new Map),m(this,"context",void 0),this.context=new p(this),o(i,!0,e);return this.register([e]).build()}}const y=e=>()=>(t,i,r)=>{const n=c(e,t)||[];n.push(r),o(e,n,t)},x=y(r),j=y(n),A=y(s);exports.AbstractAssemblage=class{},exports.AbstractAssembler=class{},exports.Assemblage=e=>{const t=e||{};return e=>{o("is_assemblage",!0,e),o(i,!0,e);for(const r in t)if(t.hasOwnProperty(r))switch(r){case"singleton":!1===t.singleton&&o(i,!1,e);break;case"controller":if(!0===t.controller){if("string"!=typeof t.path)throw new Error(`Controller assemblage '${e.name}' must define a path.`);o("is_controller",!0,e)}break;case"tags":if(void 0!==t.tags)if("string"==typeof t.tags)o("tags",[t.tags],e);else{if(!Array.isArray(t.tags))throw new Error("Assemblage's 'tags' must be o type 'string' or 'Array'.");o("tags",t.tags,e)}break;case"inject":if(!Array.isArray(t.inject))throw new Error("Assemblage's definition 'inject' property must be an array of 'Injection' tuples.");for(const e of t.inject)if(!Array.isArray(e))throw new Error("'Injection' must be an 'Array'.");default:o(r,t[r],e)}return e}},exports.Assembler=w,exports.AssemblerContext=p,exports.Configuration=j,exports.Context=x,exports.Metadata=A;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e="assemblage_definition",t="context_param_index",n="config_param_index",r="definition_param_index",s=(e,t,n)=>{Reflect.defineMetadata(`__${e}__`,t,n)},i=(e,t)=>Reflect.getOwnMetadata(`__${e}__`,t),o=e=>Reflect.getMetadata("design:paramtypes",e)||[],c={singleton:{test:e=>"boolean"==typeof e||void 0===e,throw:()=>{throw new Error("'singleton' property must be of type 'boolean' or 'undefined'.")},transform:e=>void 0===e},events:{test:e=>void 0===e||Array.isArray(e)&&e.every((e=>"string"==typeof e)),throw:()=>{throw new Error("'events' property must be an array of strings or 'undefined'.")},transform:e=>e},inject:{test:e=>void 0===e||Array.isArray(e)&&e.every((e=>Array.isArray(e)&&e.length>=1&&e.length<=3)),throw:()=>{throw new Error("'inject' property must be an array of tuples of length 1, 2 or 3.")},transform:e=>e},tags:{test:e=>void 0===e||"string"==typeof e||Array.isArray(e)&&e.every((e=>"string"==typeof e)),throw:()=>{throw new Error("'tags' property must be a string or an array of strings.")},transform:e=>"string"==typeof e?[e]:e},controller:{test:e=>"boolean"==typeof e||void 0===e,throw:()=>{throw new Error("'controller' property must be of type 'boolean' or 'undefined'.")},transform:e=>e},path:{test:e=>"string"==typeof e||void 0===e,throw:()=>{throw new Error("'path' property must be of type 'string' or 'undefined'.")},transform:e=>{if(e){let t=e.replace(/\/+/g,"/").replace(/\s/g,"");if(t.startsWith("/")||(t=`/${t}`),t.endsWith("/")){const e=t.length-1;t=t.split("").splice(0,e).join("")}return t}return e}},metadata:{test:e=>("object"==typeof e||void 0===e)&&!Array.isArray(e),throw:()=>{throw new Error("'metadata' property must be of type 'object' or 'undefined'.")},transform:e=>e}},a=e=>{const t={...e};for(const n in t){if(!Object.keys(c).includes(n))throw new Error(`Property '${n}' is not a valid assemblage definition property.`);const e=c[n].test,r=c[n].throw,s=c[n].transform;if(e(t[n])||r(),"controller"===n&&!Object.keys(t).includes("path"))throw new Error("Assemblage marked as 'controller' must define a 'path'.");if("path"===n&&!Object.keys(t).includes("controller"))throw new Error("Assemblage that defines a 'path' must be marked as 'controller'.");t[n]=s(t[n])}return t},l=t=>i(e,t),h=(e,t)=>l(t)[e],u=e=>()=>(t,n,r)=>{const o=i(e,t)||[];o.push(r),s(e,o,t)},f=u(t),d=u(n),g=u(r),p=e=>{const s=(e=>i(t,e)||[])(e),o=(e=>i(r,e)||[])(e),c=(e=>i(n,e)||[])(e);return{context:s,definition:o,configuration:c}};const b=(...e)=>{},y=(...e)=>t=>{if(e.includes(typeof t))return typeof t},m=e=>!(e=>void 0===e)(e)&&!(e=>null===e)(e),w=e=>e&&"function"==typeof e&&void 0!==e.constructor,v=e=>"function"==typeof e&&"AsyncFunction"===e.constructor.name,j=(e,...t)=>{t.map(((e,n)=>{const r=/\S/.test(e);return r&&(t[n]=t[n].trim()),r?-1:n})).filter((e=>e>=0)).every((e=>{t[e]=" ",((e,t,n)=>{const r=e[t];e.splice(t,1),e.splice(n,0,r)})(t,e,t.length-1)})),t=(e=>Array.from(new Set(e)))(t);const n=new RegExp(`[^A-Za-zÀ-ÖØ-öø-ÿ0-9${t.join("")}]`,"gi");return e.replace(n,"")},O=(...e)=>t=>e.reduce(((e,t)=>t(e)),t),x=e=>t=>e.if(t)?e.then(t):e.else?e.else(t):void 0,A=e=>t=>{const n=Array.isArray(e)?e=>parseInt(e):b;for(const[r,s]of Object.entries(e))t(s,n(r))},E=(e,t)=>{const n=new Proxy(e,{get:function(n,r){return r===Symbol.iterator?n[Symbol.iterator].bind(n):((e,t)=>[...Object.getOwnPropertyNames(t.prototype),...Object.getOwnPropertyNames(Object.getPrototypeOf(e)),...Object.getOwnPropertyNames(e)])(e,t).includes(r)?n[r]:n.collection[r]},set:function(e,t,n){return Reflect.set(e,t,n)}});return n},P=(e,t)=>{const n=e;for(const r of((e,t)=>[...Object.getOwnPropertyNames(t.prototype),...Object.getOwnPropertyNames(Object.getPrototypeOf(e)),...Object.getOwnPropertyNames(e)])(e,t))delete n[r]},C=(e,t,n)=>new Promise((r=>{const s=e[t];if(s){if(v(s))return void s.bind(e)(n).then((()=>{r()}));r(s.bind(e)(n))}}));let _=Symbol.iterator;class I{dispose(){P(this,I)}add(...e){const t=e=>this.collection[e.channel].push(e.listener),n=x({if:()=>2===e.length,then:()=>({channel:e[0],listener:e[1]}),else:()=>{const t=e[0];return{channel:t[0],listener:t[1]}}}),r=x({if:e=>!m(this.collection[e.channel]),then:e=>{this.collection[e.channel]=[],t(e)},else:e=>{t(e)}});return O(n,r)(),this}remove(e,t){const n=t=>this.collection[e].splice(t,1),r=x({if:()=>this.collection[e]&&0===this.collection[e].length,then:()=>delete this.collection[e]}),s=x({if:()=>m(t),then:()=>n(this.collection[e].indexOf(t)),else:()=>delete this.collection[e]}),i=x({if:e=>this.has(e),then:e=>this.collection[e]});return O(i,s,r)(),this}has(...e){return y("string")(e[0])?Object.keys(this.collection).includes(e[0]):!!y("function")(e[0])&&Object.values(this.collection).flat().includes(e[0])}get(...e){return y("string")(e[0])?this.collection[e[0]]:y("function")(e[0])?Object.values(this.collection).flat().filter((t=>t===e[0])):[]}clear(){const e=(e=>t=>{const n=Array.isArray(e)?e=>parseInt(e):e=>e;for(const r in e)t(n(r))})(this.collection),t=e=>A(this.collection[e])((t=>this.remove(e,t)));return e((e=>t(e))),this}get listeners(){return Object.values(this.collection).flat()}get channels(){return Object.keys(this.collection)}get length(){return Object.values(this.collection).flat().length}[_](){let e=-1;const t=this.collection?Object.keys(this.collection):[];return{next:()=>({value:t[++e],done:!(e in t)})}}constructor(){!function(e,t,n){t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n}(this,"collection",{});return E(this,I)}}function S(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}class ${dispose(){this.listeners.dispose(),this.channels.clear(),P(this,$)}addChannels(...e){return A(e)((e=>{const t=this.cleanChannel(e);if(this.channels.has(t))throw new Error(`Channel '${t}' already exists.`);this.channels.add(t)})),this}removeChannels(...e){return A(e)((e=>{const t=this.cleanChannel(e);"*"!==t&&this.channels.has(t)&&(this.channels.delete(t),this.listeners.remove(t),this.onceListeners.remove(t))})),this}on(e,t){const n=this.cleanChannel(e);if(!this.channels.has(n))throw new Error(`Channel '${n}' was not registered.`);return this.listeners.add(n,t),this}once(e,t){const n=this.cleanChannel(e);if(!this.channels.has(n))throw new Error(`Channel '${n}' was not registered.`);return this.onceListeners.add(n,t),this}off(e,t){const n=this.cleanChannel(e);return this.listeners.remove(n,t),this}emit(e,...t){const n=this.cleanChannel(e);if(this.channels.has(n)){const e=this.onceListeners.get("*")||[],r=this.listeners.get("*")||[],s=this.onceListeners.get(n)||[],i=this.listeners.get(n)||[],o=A(e),c=A(r),a=A(s),l=A(i);o((e=>{this.run(e,...t),this.onceListeners.remove("*",e)})),c((e=>{this.run(e,...t)})),a((e=>{this.run(e,...t),this.onceListeners.remove(n,e)})),l((e=>{this.run(e,...t)}))}return this}run(e,...t){if(v(e)){return e(...t).then((()=>Promise.resolve()))}e(...t)}cleanChannel(e){return j(e,"*")}constructor(...e){S(this,"listeners",new I),S(this,"onceListeners",new I),S(this,"channels",new Set(["*"])),this.addChannels(...e)}}const k=e=>{const t=()=>w(e[0])&&(e=>"object"==typeof e&&!Array.isArray(e)&&!w(e))(e[1]);return O(x({if:()=>w(e[0])&&w(e[1]),then:()=>({identifier:e[0],concrete:e[1],configuration:{}})}),x({if:()=>t(),then:()=>({identifier:e[0],concrete:e[0],configuration:e[1]}),else:e=>e}))()},L=e=>((e,t)=>(n,...r)=>e[n]?e[n](...r):t?t(n,...r):void 0)({1:()=>(e=>({identifier:e[0],concrete:e[0],configuration:{}}))(e),2:()=>k(e),3:()=>(e=>({identifier:e[0],concrete:e[1],configuration:e[2]}))(e)},(()=>{throw new Error("Injection tuple must be of length 1, 2 or 3.")}))(e.length);function R(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}class N{static of(e,t){return new N(e,t)}dispose(){this.singletonInstance&&C(this.singletonInstance,"onDispose",this.context),P(this,N)}build(){if(this.singletonInstance)return this.singletonInstance;const e=(e=>{const t=[],n=o(e.concrete),r=p(e.concrete);let s=0;for(const i of n)r.context.includes(s)?(t.push(e.context),s++):r.configuration.includes(s)?(t.push(e.configuration),s++):r.definition.includes(s)?(t.push(e.definition),s++):(t.push(e.context.require(i)),s++);return t})(this),t=new this.concrete(...e);return this.concrete.prototype instanceof $&&t.addChannels(...this.events),C(t,"onInit",this.context),this.isSingleton&&(this.singletonInstance=t),t}get dependencies(){return this.dependenciesIds}get definition(){return l(this.concrete)||{}}get isSingleton(){return h("singleton",this.concrete)||!0}get singleton(){return this.singletonInstance}get injections(){return h("inject",this.concrete)||[]}get tags(){return h("tags",this.concrete)||[]}get events(){return h("events",this.concrete)||[]}constructor(e,t){R(this,"context",void 0),R(this,"identifier",void 0),R(this,"concrete",void 0),R(this,"configuration",void 0),R(this,"dependenciesIds",void 0),R(this,"singletonInstance",void 0),this.context=t,this.dependenciesIds=[];const n=L(e);this.identifier=n.identifier,this.concrete=n.concrete,this.configuration=n.configuration;A(this.injections)((e=>this.context.register(e))),this.dependenciesIds=(e=>{const t=[],n=o(e),r=p(e);let s=0;for(const i of n)r.context.includes(s)||r.configuration.includes(s)||r.definition.includes(s)||t.push(i),s++;return t})(this.concrete),this.isSingleton&&this.build()}}function q(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}class M{static build(e){return new M(e)}dispose(){for(const[e,t]of this.injectables)t.dispose();P(this,M)}register(e){const t=N.of(e,this.context);if(this.has(t.identifier))throw new Error(`An assemblage is already registered with identifier '${t.identifier.name}'.`);return this.injectables.set(t.identifier,t),C(t.concrete,"onRegister",this.context),t}has(e){return this.injectables.has(e)}require(e){if(!this.injectables.has(e))throw new Error(`Assemblage with identifier '${e.name}' has not been registered.`);return this.injectables.get(e).build()}tagged(...e){const t=[];for(const n of e)for(const[e,r]of this.injectables)r.tags.includes(n)&&t.push(r.build());return t}get size(){return this.injectables.size}constructor(e){q(this,"injectables",new Map),q(this,"context",void 0),this.context={register:this.register.bind(this),has:this.has.bind(this),require:this.require.bind(this),tagged:this.tagged.bind(this)},((e,t,n)=>{const r=l(n);r[e]=t,a(r)})("singleton",!0,e);const t=this.register([e]);return this.require(t.identifier)}}exports.AbstractAssemblage=class{static onRegister(e){}},exports.AbstractAssembler=class{},exports.Assemblage=t=>{const n=t?a(t):{};return t=>(s("is_assemblage",!0,t),s(e,n,t),t)},exports.Assembler=M,exports.Configuration=d,exports.Context=f,exports.Definition=g;

package/dist/index.mjs

@@ -1,101 +1,498 @@
 class AbstractAssemblage {
+    static onRegister(s) {}
 }
 
-const ReflectCustomPrefix = '__';
-const ReflectCustomSuffix = '__';
 const ReflectParamTypes = 'design:paramtypes';
+const ReflectPrefix = '__';
+const ReflectSuffix = '__';
 const ReflectIsAssemblageFlag = `is_assemblage`;
-const ReflectIsSingletonFlag = `is_singleton`;
-const ReflectIsControllerFlag = `is_controller`;
+const ReflectDefinition = 'assemblage_definition';
 const ReflectContextParamIndex = `context_param_index`;
 const ReflectConfigurationParamIndex = `config_param_index`;
-const ReflectMetadataParamIndex = `metadata_param_index`;
+const ReflectDefinitionParamIndex = `definition_param_index`;
+const defineCustomMetadata = (e, t, a)=>{
+    Reflect.defineMetadata(`${ReflectPrefix}${e}${ReflectSuffix}`, t, a);
+};
+const getOwnCustomMetadata = (e, t)=>{
+    return Reflect.getOwnMetadata(`${ReflectPrefix}${e}${ReflectSuffix}`, t);
+};
+const getParamTypes = (e)=>{
+    return Reflect.getMetadata(ReflectParamTypes, e) || [];
+};
 
-const defineCustomMetadata = (a, o, n)=>{
-    Reflect.defineMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o, n);
+const r = {
+    singleton: {
+        test: (t)=>typeof t === 'boolean' || typeof t === 'undefined',
+        throw: ()=>{
+            throw new Error(`'singleton' property must be of type 'boolean' or 'undefined'.`);
+        },
+        transform: (t)=>typeof t === 'undefined' ? true : false
+    },
+    events: {
+        test: (t)=>typeof t === 'undefined' || Array.isArray(t) && t.every((t)=>typeof t === 'string'),
+        throw: ()=>{
+            throw new Error(`'events' property must be an array of strings or 'undefined'.`);
+        },
+        transform: (t)=>t
+    },
+    inject: {
+        test: (t)=>typeof t === 'undefined' || Array.isArray(t) && t.every((t)=>Array.isArray(t) && t.length >= 1 && t.length <= 3),
+        throw: ()=>{
+            throw new Error(`'inject' property must be an array of tuples of length 1, 2 or 3.`);
+        },
+        transform: (t)=>t
+    },
+    tags: {
+        test: (t)=>typeof t === 'undefined' || typeof t === 'string' || Array.isArray(t) && t.every((t)=>typeof t === 'string'),
+        throw: ()=>{
+            throw new Error(`'tags' property must be a string or an array of strings.`);
+        },
+        transform: (t)=>typeof t === 'string' ? [
+                t
+            ] : t
+    },
+    controller: {
+        test: (t)=>typeof t === 'boolean' || typeof t === 'undefined',
+        throw: ()=>{
+            throw new Error(`'controller' property must be of type 'boolean' or 'undefined'.`);
+        },
+        transform: (t)=>t
+    },
+    path: {
+        test: (t)=>typeof t === 'string' || typeof t === 'undefined',
+        throw: ()=>{
+            throw new Error(`'path' property must be of type 'string' or 'undefined'.`);
+        },
+        transform: (t)=>{
+            if (t) {
+                let e = t.replace(/\/+/g, '/').replace(/\s/g, '');
+                if (!e.startsWith('/')) {
+                    e = `/${e}`;
+                }
+                if (e.endsWith('/')) {
+                    const t = e.length - 1;
+                    e = e.split('').splice(0, t).join('');
+                }
+                return e;
+            }
+            return t;
+        }
+    },
+    metadata: {
+        test: (t)=>(typeof t === 'object' || typeof t === 'undefined') && !Array.isArray(t),
+        throw: ()=>{
+            throw new Error(`'metadata' property must be of type 'object' or 'undefined'.`);
+        },
+        transform: (t)=>t
+    }
 };
-const getCustomMetadata = (a, o)=>{
-    return Reflect.getMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o);
+const validateDefinition = (t)=>{
+    const e = {
+        ...t
+    };
+    for(const t in e){
+        if (!Object.keys(r).includes(t)) {
+            throw new Error(`Property '${t}' is not a valid assemblage definition property.`);
+        }
+        const o = r[t].test;
+        const n = r[t].throw;
+        const s = r[t].transform;
+        if (!o(e[t])) {
+            n();
+        }
+        if (t === 'controller' && !Object.keys(e).includes('path')) {
+            throw new Error(`Assemblage marked as 'controller' must define a 'path'.`);
+        }
+        if (t === 'path' && !Object.keys(e).includes('controller')) {
+            throw new Error(`Assemblage that defines a 'path' must be marked as 'controller'.`);
+        }
+        e[t] = s(e[t]);
+    }
+    return e;
 };
-const getOwnCustomMetadata = (a, o)=>{
-    return Reflect.getOwnMetadata(`${ReflectCustomPrefix}${a}${ReflectCustomSuffix}`, o);
+const getDefinition = (r)=>{
+    return getOwnCustomMetadata(ReflectDefinition, r);
+};
+const getDefinitionValue = (t, e)=>{
+    const r = getDefinition(e);
+    return r[t];
+};
+const setDefinitionValue = (t, e, r)=>{
+    const o = getDefinition(r);
+    o[t] = e;
+    const n = validateDefinition(o);
+    return n;
 };
 
 const Assemblage = (o)=>{
-    const n = o || {};
+    const s = o ? validateDefinition(o) : {};
     return (o)=>{
         defineCustomMetadata(ReflectIsAssemblageFlag, true, o);
-        defineCustomMetadata(ReflectIsSingletonFlag, true, o);
-        for(const r in n){
-            if (n.hasOwnProperty(r)) {
-                switch(r){
-                    case 'singleton':
-                        {
-                            if (n.singleton === false) {
-                                defineCustomMetadata(ReflectIsSingletonFlag, false, o);
-                            }
-                            break;
-                        }
-                    case 'controller':
-                        {
-                            if (n.controller === true) {
-                                if (typeof n.path !== 'string') {
-                                    throw new Error(`Controller assemblage '${o.name}' must define a path.`);
-                                }
-                                defineCustomMetadata(ReflectIsControllerFlag, true, o);
-                            }
-                            break;
-                        }
-                    case 'tags':
-                        {
-                            if (typeof n.tags !== 'undefined') {
-                                if (typeof n.tags === 'string') {
-                                    defineCustomMetadata('tags', [
-                                        n.tags
-                                    ], o);
-                                } else if (Array.isArray(n.tags)) {
-                                    defineCustomMetadata('tags', n.tags, o);
-                                } else {
-                                    throw new Error(`Assemblage's 'tags' must be o type 'string' or 'Array'.`);
-                                }
-                            }
-                            break;
-                        }
-                    case 'inject':
-                        {
-                            if (!Array.isArray(n.inject)) {
-                                throw new Error(`Assemblage's definition 'inject' property must be an array of 'Injection' tuples.`);
-                            }
-                            for (const r of n.inject){
-                                if (!Array.isArray(r)) {
-                                    throw new Error(`'Injection' must be an 'Array'.`);
-                                }
-                            }
-                        }
-                    default:
-                        {
-                            defineCustomMetadata(r, n[r], o);
-                        }
-                }
-            }
-        }
+        defineCustomMetadata(ReflectDefinition, s, o);
         return o;
     };
 };
 
+const i$1 = (t)=>()=>{
+        return (n, e, i)=>{
+            const s = getOwnCustomMetadata(t, n) || [];
+            s.push(i);
+            defineCustomMetadata(t, s, n);
+        };
+    };
+const s = i$1(ReflectContextParamIndex);
+const x = i$1(ReflectConfigurationParamIndex);
+const c$1 = i$1(ReflectDefinitionParamIndex);
+const getContextIndex = (t)=>{
+    return getOwnCustomMetadata(ReflectContextParamIndex, t) || [];
+};
+const getConfigurationIndex = (n)=>{
+    return getOwnCustomMetadata(ReflectConfigurationParamIndex, n) || [];
+};
+const getDefinitionIndex = (t)=>{
+    return getOwnCustomMetadata(ReflectDefinitionParamIndex, t) || [];
+};
+const getDecoratedParametersIndexes = (t)=>{
+    const n = getContextIndex(t);
+    const e = getDefinitionIndex(t);
+    const o = getConfigurationIndex(t);
+    return {
+        context: n,
+        definition: e,
+        configuration: o
+    };
+};
+
 class AbstractAssembler {
 }
 
 const NoOp = (...e)=>{};
+const isOfType = (...e)=>(t)=>{
+        if (!e.includes(typeof t)) return undefined;
+        return typeof t;
+    };
+const isUndefined = (e)=>typeof e === 'undefined';
+const isNull = (e)=>e === null;
+const isDefined = (e)=>!isUndefined(e) && !isNull(e);
 const isClass = (e)=>{
     return e && typeof e === 'function' && typeof e.constructor !== 'undefined';
 };
 const isObject = (e)=>typeof e === 'object' && !Array.isArray(e) && !isClass(e);
-const switchCase = (e, t)=>(o, ...s)=>e[o] ? e[o](...s) : t ? t(o, ...s) : NoOp();
+const isAsync = (e)=>typeof e === 'function' && e.constructor.name === 'AsyncFunction';
+const moveArrayItem = (e, t, r)=>{
+    const o = e[t];
+    e.splice(t, 1);
+    e.splice(r, 0, o);
+    return e;
+};
+const dedupeArray = (e)=>Array.from(new Set(e));
+const onlyAlphanumeric = (e, ...t)=>{
+    t.map((e, r)=>{
+        const o = /\S/.test(e);
+        if (o) t[r] = t[r].trim();
+        return !o ? r : -1;
+    }).filter((e)=>e >= 0).every((e)=>{
+        t[e] = ' ';
+        moveArrayItem(t, e, t.length - 1);
+    });
+    t = dedupeArray(t);
+    const r = new RegExp(`[^A-Za-zÀ-ÖØ-öø-ÿ0-9${t.join('')}]`, 'gi');
+    return e.replace(r, '');
+};
+const switchCase = (e, t)=>(r, ...o)=>e[r] ? e[r](...o) : t ? t(r, ...o) : NoOp();
 const pipe = (...e)=>(t)=>e.reduce((e, t)=>t(e), t);
 const conditionally = (e)=>(t)=>{
         return e.if(t) ? e.then(t) : e.else ? e.else(t) : undefined;
     };
+const forOf = (e)=>(t)=>{
+        const r = Array.isArray(e) ? (e)=>parseInt(e) : NoOp;
+        for (const [o, n] of Object.entries(e)){
+            t(n, r(o));
+        }
+    };
+const forIn = (e)=>(t)=>{
+        const r = Array.isArray(e) ? (e)=>parseInt(e) : (e)=>e;
+        for(const o in e){
+            t(r(o));
+        }
+    };
+const e$4 = (e, t)=>{
+    return [
+        ...Object.getOwnPropertyNames(t.prototype),
+        ...Object.getOwnPropertyNames(Object.getPrototypeOf(e)),
+        ...Object.getOwnPropertyNames(e)
+    ];
+};
+const proxifyIterable = (t, r)=>{
+    const o = new Proxy(t, {
+        get: function(o, n) {
+            if (n === Symbol.iterator) {
+                return o[Symbol.iterator].bind(o);
+            } else if (!e$4(t, r).includes(n)) {
+                return o.collection[n];
+            }
+            return o[n];
+        },
+        set: function(e, t, r) {
+            return Reflect.set(e, t, r);
+        }
+    });
+    return o;
+};
+const clearInstance = (e, t)=>{
+    const r = (e, t)=>{
+        return [
+            ...Object.getOwnPropertyNames(t.prototype),
+            ...Object.getOwnPropertyNames(Object.getPrototypeOf(e)),
+            ...Object.getOwnPropertyNames(e)
+        ];
+    };
+    const o = e;
+    for (const n of r(e, t)){
+        delete o[n];
+    }
+};
+
+const callHook = (n, r, t)=>{
+    return new Promise((i)=>{
+        const e = n[r];
+        if (e) {
+            if (isAsync(e)) {
+                e.bind(n)(t).then(()=>{
+                    i();
+                });
+                return;
+            }
+            i(e.bind(n)(t));
+        }
+    });
+};
+
+function e$3(e, t, n) {
+    if (t in e) {
+        Object.defineProperty(e, t, {
+            value: n,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        e[t] = n;
+    }
+    return e;
+}
+let h = Symbol.iterator;
+class ListenerCollection {
+    dispose() {
+        clearInstance(this, ListenerCollection);
+    }
+    add(...e) {
+        const n = (e)=>this.collection[e.channel].push(e.listener);
+        const c = conditionally({
+            if: ()=>e.length === 2,
+            then: ()=>{
+                return {
+                    channel: e[0],
+                    listener: e[1]
+                };
+            },
+            else: ()=>{
+                const t = e[0];
+                return {
+                    channel: t[0],
+                    listener: t[1]
+                };
+            }
+        });
+        const o = conditionally({
+            if: (e)=>!isDefined(this.collection[e.channel]),
+            then: (e)=>{
+                this.collection[e.channel] = [];
+                n(e);
+            },
+            else: (e)=>{
+                n(e);
+            }
+        });
+        pipe(c, o)();
+        return this;
+    }
+    remove(e, n) {
+        const c = (t)=>this.collection[e].splice(t, 1);
+        const o = conditionally({
+            if: ()=>this.collection[e] && this.collection[e].length === 0,
+            then: ()=>delete this.collection[e]
+        });
+        const s = conditionally({
+            if: ()=>isDefined(n),
+            then: ()=>c(this.collection[e].indexOf(n)),
+            else: ()=>delete this.collection[e]
+        });
+        const r = conditionally({
+            if: (e)=>this.has(e),
+            then: (e)=>this.collection[e]
+        });
+        pipe(r, s, o)();
+        return this;
+    }
+    has(...e) {
+        if (isOfType('string')(e[0])) {
+            return Object.keys(this.collection).includes(e[0]);
+        } else if (isOfType('function')(e[0])) {
+            return Object.values(this.collection).flat().includes(e[0]);
+        }
+        return false;
+    }
+    get(...e) {
+        if (isOfType('string')(e[0])) {
+            return this.collection[e[0]];
+        } else if (isOfType('function')(e[0])) {
+            return Object.values(this.collection).flat().filter((t)=>t === e[0]);
+        }
+        return [];
+    }
+    clear() {
+        const e = forIn(this.collection);
+        const t = (e)=>forOf(this.collection[e])((t)=>this.remove(e, t));
+        e((e)=>t(e));
+        return this;
+    }
+    get listeners() {
+        return Object.values(this.collection).flat();
+    }
+    get channels() {
+        return Object.keys(this.collection);
+    }
+    get length() {
+        return Object.values(this.collection).flat().length;
+    }
+    [h]() {
+        let e = -1;
+        const t = this.collection ? Object.keys(this.collection) : [];
+        return {
+            next: ()=>({
+                    value: t[++e],
+                    done: !(e in t)
+                })
+        };
+    }
+    constructor(){
+        e$3(this, "collection", {});
+        const t = proxifyIterable(this, ListenerCollection);
+        return t;
+    }
+}
+
+function e$2(e, n, s) {
+    if (n in e) {
+        Object.defineProperty(e, n, {
+            value: s,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        e[n] = s;
+    }
+    return e;
+}
+class EventManager {
+    dispose() {
+        this.listeners.dispose();
+        this.channels.clear();
+        clearInstance(this, EventManager);
+    }
+    addChannels(...e) {
+        const n = forOf(e);
+        n((e)=>{
+            const n = this.cleanChannel(e);
+            if (this.channels.has(n)) {
+                throw new Error(`Channel '${n}' already exists.`);
+            }
+            this.channels.add(n);
+        });
+        return this;
+    }
+    removeChannels(...e) {
+        const n = forOf(e);
+        n((e)=>{
+            const n = this.cleanChannel(e);
+            if (n !== '*' && this.channels.has(n)) {
+                this.channels.delete(n);
+                this.listeners.remove(n);
+                this.onceListeners.remove(n);
+            }
+        });
+        return this;
+    }
+    on(e, n) {
+        const s = this.cleanChannel(e);
+        if (!this.channels.has(s)) {
+            throw new Error(`Channel '${s}' was not registered.`);
+        }
+        this.listeners.add(s, n);
+        return this;
+    }
+    once(e, n) {
+        const s = this.cleanChannel(e);
+        if (!this.channels.has(s)) {
+            throw new Error(`Channel '${s}' was not registered.`);
+        }
+        this.onceListeners.add(s, n);
+        return this;
+    }
+    off(e, n) {
+        const s = this.cleanChannel(e);
+        this.listeners.remove(s, n);
+        return this;
+    }
+    emit(e, ...n) {
+        const t = this.cleanChannel(e);
+        if (this.channels.has(t)) {
+            const e = this.onceListeners.get('*') || [];
+            const r = this.listeners.get('*') || [];
+            const i = this.onceListeners.get(t) || [];
+            const h = this.listeners.get(t) || [];
+            const o = forOf(e);
+            const a = forOf(r);
+            const c = forOf(i);
+            const l = forOf(h);
+            o((e)=>{
+                this.run(e, ...n);
+                this.onceListeners.remove('*', e);
+            });
+            a((e)=>{
+                this.run(e, ...n);
+            });
+            c((e)=>{
+                this.run(e, ...n);
+                this.onceListeners.remove(t, e);
+            });
+            l((e)=>{
+                this.run(e, ...n);
+            });
+        }
+        return this;
+    }
+    run(e, ...n) {
+        if (isAsync(e)) {
+            const s = e;
+            return s(...n).then(()=>Promise.resolve());
+        }
+        e(...n);
+    }
+    cleanChannel(e) {
+        return onlyAlphanumeric(e, '*');
+    }
+    constructor(...n){
+        e$2(this, "listeners", new ListenerCollection());
+        e$2(this, "onceListeners", new ListenerCollection());
+        e$2(this, "channels", new Set([
+            '*'
+        ]));
+        this.addChannels(...n);
+    }
+}
 
 const i = (n)=>{
     return {
@@ -144,129 +541,129 @@ const resolveInjectionTuple = (n)=>switchCase({
         throw new Error(`Injection tuple must be of length 1, 2 or 3.`);
     })(n.length);
 
-function t(t, e, n) {
-    if (e in t) {
-        Object.defineProperty(t, e, {
+const resolveParameters = (o)=>{
+    const t = [];
+    const c = getParamTypes(o.concrete);
+    const i = getDecoratedParametersIndexes(o.concrete);
+    let s = 0;
+    for (const n of c){
+        if (i.context.includes(s)) {
+            t.push(o.context);
+            s++;
+            continue;
+        }
+        if (i.configuration.includes(s)) {
+            t.push(o.configuration);
+            s++;
+            continue;
+        }
+        if (i.definition.includes(s)) {
+            t.push(o.definition);
+            s++;
+            continue;
+        }
+        t.push(o.context.require(n));
+        s++;
+    }
+    return t;
+};
+const resolveDependencies = (o)=>{
+    const t = [];
+    const c = getParamTypes(o);
+    const i = getDecoratedParametersIndexes(o);
+    let s = 0;
+    for (const n of c){
+        if (i.context.includes(s) || i.configuration.includes(s) || i.definition.includes(s)) {
+            s++;
+            continue;
+        }
+        t.push(n);
+        s++;
+    }
+    return t;
+};
+
+function e$1(e, t, n) {
+    if (t in e) {
+        Object.defineProperty(e, t, {
             value: n,
             enumerable: true,
             configurable: true,
             writable: true
         });
     } else {
-        t[e] = n;
+        e[t] = n;
     }
-    return t;
+    return e;
 }
 class Injectable {
-    static of(t, e) {
-        return new Injectable(t, e);
+    static of(e, t) {
+        return new Injectable(e, t);
     }
-    build() {
-        if (this.singleton) return this.singleton;
-        const t = this.resolveDependencies();
-        const e = new this.concrete(...t);
-        if (this.isSingleton) {
-            this.singleton = e;
+    dispose() {
+        if (this.singletonInstance) {
+            callHook(this.singletonInstance, 'onDispose', this.context);
         }
-        return e;
+        clearInstance(this, Injectable);
     }
-    resolveDependencies() {
-        const t = [];
-        const i = getOwnCustomMetadata(ReflectContextParamIndex, this.concrete) || [];
-        const s = getOwnCustomMetadata(ReflectConfigurationParamIndex, this.concrete) || [];
-        const h = getCustomMetadata(ReflectMetadataParamIndex, this.concrete) || [];
-        let u = 0;
-        for (const e of this.dependencies){
-            if (i.includes(u)) {
-                t.push(this.context);
-                u++;
-                continue;
-            }
-            if (s.includes(u)) {
-                t.push(this.configuration);
-                u++;
-                continue;
-            }
-            if (h.includes(u)) {
-                t.push(this.metadata);
-                u++;
-                continue;
-            }
-            t.push(this.context.require(e));
-            u++;
+    build() {
+        if (this.singletonInstance) return this.singletonInstance;
+        const e = resolveParameters(this);
+        const t = new this.concrete(...e);
+        const n = this.concrete.prototype instanceof EventManager;
+        if (n) {
+            t.addChannels(...this.events);
+        }
+        callHook(t, 'onInit', this.context);
+        if (this.isSingleton) {
+            this.singletonInstance = t;
         }
         return t;
     }
+    get dependencies() {
+        return this.dependenciesIds;
+    }
+    get definition() {
+        return getDefinition(this.concrete) || {};
+    }
     get isSingleton() {
-        return getOwnCustomMetadata(ReflectIsSingletonFlag, this.concrete) || false;
+        return getDefinitionValue('singleton', this.concrete) || true;
     }
-    get injections() {
-        return getOwnCustomMetadata('inject', this.concrete) || [];
+    get singleton() {
+        return this.singletonInstance;
     }
-    get dependencies() {
-        return Reflect.getMetadata(ReflectParamTypes, this.concrete) || [];
+    get injections() {
+        return getDefinitionValue('inject', this.concrete) || [];
     }
     get tags() {
-        return getCustomMetadata('tags', this.concrete) || [];
-    }
-    get metadata() {
-        return getCustomMetadata('metadata', this.concrete) || {};
-    }
-    constructor(e, n){
-        t(this, "context", undefined);
-        t(this, "identifier", undefined);
-        t(this, "concrete", undefined);
-        t(this, "configuration", undefined);
-        t(this, "singleton", undefined);
-        this.context = n;
-        const i = resolveInjectionTuple(e);
-        this.identifier = i.identifier;
-        this.concrete = i.concrete;
-        this.configuration = i.configuration;
-        for (const t of this.injections){
-            this.context.register(t);
-        }
+        return getDefinitionValue('tags', this.concrete) || [];
     }
-}
-
-function e$2(e, t, r) {
-    if (t in e) {
-        Object.defineProperty(e, t, {
-            value: r,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        e[t] = r;
+    get events() {
+        return getDefinitionValue('events', this.concrete) || [];
     }
-    return e;
-}
-class AssemblerContext {
-    set(e, t) {
-        if (this.userData[e]) {
-            throw new Error(`Key '${e}' is already defined in context's user data.`);
+    constructor(t, i){
+        e$1(this, "context", undefined);
+        e$1(this, "identifier", undefined);
+        e$1(this, "concrete", undefined);
+        e$1(this, "configuration", undefined);
+        e$1(this, "dependenciesIds", undefined);
+        e$1(this, "singletonInstance", undefined);
+        this.context = i;
+        this.dependenciesIds = [];
+        const s = resolveInjectionTuple(t);
+        this.identifier = s.identifier;
+        this.concrete = s.concrete;
+        this.configuration = s.configuration;
+        const o = forOf(this.injections);
+        o((e)=>this.context.register(e));
+        this.dependenciesIds = resolveDependencies(this.concrete);
+        if (this.isSingleton) {
+            this.build();
         }
-        this.userData[e] = t;
-        return this;
-    }
-    get(e) {
-        return this.userData[e];
-    }
-    constructor(t){
-        e$2(this, "userData", {});
-        e$2(this, "register", undefined);
-        e$2(this, "has", undefined);
-        e$2(this, "require", undefined);
-        e$2(this, "tagged", undefined);
-        this.register = t.register.bind(t);
-        this.has = t.has.bind(t);
-        this.require = t.require.bind(t);
-        this.tagged = t.tagged.bind(t);
     }
 }
 
-function e$1(e, t, i) {
+function e(e, t, i) {
     if (t in e) {
         Object.defineProperty(e, t, {
             value: i,
@@ -283,12 +680,19 @@ class Assembler {
     static build(e) {
         return new Assembler(e);
     }
+    dispose() {
+        for (const [e, t] of this.injectables){
+            t.dispose();
+        }
+        clearInstance(this, Assembler);
+    }
     register(e) {
         const t = Injectable.of(e, this.context);
         if (this.has(t.identifier)) {
             throw new Error(`An assemblage is already registered with identifier '${t.identifier.name}'.`);
         }
         this.injectables.set(t.identifier, t);
+        callHook(t.concrete, 'onRegister', this.context);
         return t;
     }
     has(e) {
@@ -304,33 +708,30 @@ class Assembler {
     tagged(...e) {
         const t = [];
         for (const i of e){
-            for (const [e, r] of this.injectables){
-                if (r.tags.includes(i)) t.push(r.build());
+            for (const [e, s] of this.injectables){
+                if (s.tags.includes(i)) t.push(s.build());
             }
         }
         return t;
     }
-    constructor(r){
-        e$1(this, "injectables", new Map());
-        e$1(this, "context", undefined);
-        this.context = new AssemblerContext(this);
-        defineCustomMetadata(ReflectIsSingletonFlag, true, r);
-        const s = this.register([
-            r
+    get size() {
+        return this.injectables.size;
+    }
+    constructor(t){
+        e(this, "injectables", new Map());
+        e(this, "context", undefined);
+        this.context = {
+            register: this.register.bind(this),
+            has: this.has.bind(this),
+            require: this.require.bind(this),
+            tagged: this.tagged.bind(this)
+        };
+        setDefinitionValue('singleton', true, t);
+        const i = this.register([
+            t
         ]);
-        return s.build();
+        return this.require(i.identifier);
     }
 }
 
-const m = (o)=>()=>{
-        return (t, n, m)=>{
-            const s = getOwnCustomMetadata(o, t) || [];
-            s.push(m);
-            defineCustomMetadata(o, s, t);
-        };
-    };
-const s = m(ReflectContextParamIndex);
-const e = m(ReflectConfigurationParamIndex);
-const a = m(ReflectMetadataParamIndex);
-
-export { AbstractAssemblage, AbstractAssembler, Assemblage, Assembler, AssemblerContext, e as Configuration, s as Context, a as Metadata };
+export { AbstractAssemblage, AbstractAssembler, Assemblage, Assembler, x as Configuration, s as Context, c$1 as Definition };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "assemblerjs",
   "description": "A simple and zero-dependency DI package written in typescript.",
-  "version": "0.0.97",
+  "version": "0.0.99",
   "author": "Benoît LAHOZ <info@benoitlahoz.io>",
   "bugs": "https://github.com/benoitlahoz/assemblerjs/issues",
   "devDependencies": {