assemblerjs 0.9.7 → 1.0.0

package/dist/index36.js

@@ -0,0 +1,117 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@assemblerjs/core');
+const constants = require('./index29.js');
+const reflection = require('./index30.js');
+const injectableBuilder = require('./index38.js');
+const dependencies = require('./index39.js');
+const helpers = require('./index28.js');
+const hookManager = require('./index25.js');
+const schema = require('./index31.js');
+const helpers$1 = require('./index3.js');
+
+class Injectable {
+    static of(e, t, i) {
+        return new Injectable(e, t, i);
+    }
+    dispose() {
+        if (this.singletonInstance) {
+            helpers.unregisterEvents(this, this.singletonInstance);
+            hookManager.HookManager.callHook(this.singletonInstance, 'onDispose', this.publicContext, this.mergedConfiguration || this.configuration);
+            core.clearInstance(this.singletonInstance, this.concrete);
+        }
+        core.clearInstance(this, Injectable);
+    }
+    build(e) {
+        return this.builder.build(e);
+    }
+    setSingletonInstance(e, t) {
+        this.singletonInstance = e;
+        if (t) {
+            this.mergedConfiguration = t;
+        }
+    }
+    get definition() {
+        if (!this.cachedDefinition) {
+            this.cachedDefinition = schema.getDefinition(this.concrete) || {};
+        }
+        return this.cachedDefinition;
+    }
+    get isSingleton() {
+        return this.definition.singleton ?? false;
+    }
+    get dependencies() {
+        return this.dependenciesIds;
+    }
+    get singleton() {
+        return this.singletonInstance;
+    }
+    get injections() {
+        if (this.cachedInjections === undefined) {
+            this.cachedInjections = this.definition.inject || [];
+        }
+        return this.cachedInjections;
+    }
+    get objects() {
+        if (this.cachedObjects === undefined) {
+            this.cachedObjects = this.definition.use || [];
+        }
+        return this.cachedObjects;
+    }
+    get tags() {
+        if (this.cachedTags === undefined) {
+            this.cachedTags = this.definition.tags || [];
+        }
+        return Array.isArray(this.cachedTags) ? this.cachedTags : [
+            this.cachedTags
+        ];
+    }
+    get globals() {
+        if (this.cachedGlobals === undefined) {
+            this.cachedGlobals = this.definition.global;
+        }
+        return this.cachedGlobals;
+    }
+    get events() {
+        if (this.cachedEvents === undefined) {
+            this.cachedEvents = this.definition.events || [];
+        }
+        return this.cachedEvents;
+    }
+    constructor(e, n, o){
+        this.privateContext = n;
+        this.publicContext = o;
+        this.dependenciesIds = [];
+        this.identifier = e.identifier;
+        this.concrete = e.concrete;
+        this.configuration = e.configuration;
+        if (process.env.NODE_ENV !== 'production' && !helpers$1.isAssemblage(this.concrete)) {
+            throw new Error(`Class '${this.concrete.name}' is not an Assemblage.`);
+        }
+        this.builder = new injectableBuilder.InjectableBuilder(this);
+        reflection.defineCustomMetadata(constants.ReflectValue.AssemblageContext, this.publicContext, this.concrete);
+        for (const e of this.injections){
+            this.privateContext.register(e);
+        }
+        for (const e of this.objects){
+            if (typeof e[0] === 'string' || typeof e[0] === 'symbol') {
+                this.privateContext.use(e[0], e[1]);
+            } else {
+                this.privateContext.register(e, true);
+            }
+        }
+        this.dependenciesIds = dependencies.resolveDependencies(this.concrete);
+        if (this.globals) {
+            for(const e in this.globals){
+                this.privateContext.addGlobal(e, this.globals[e]);
+            }
+        }
+        if (e.instance) {
+            this.singletonInstance = e.instance;
+        }
+    }
+}
+
+exports.Injectable = Injectable;

package/dist/index36.mjs

@@ -0,0 +1,113 @@
+import { clearInstance } from '@assemblerjs/core';
+import { ReflectValue } from './index29.mjs';
+import { defineCustomMetadata } from './index30.mjs';
+import { InjectableBuilder } from './index38.mjs';
+import { resolveDependencies } from './index39.mjs';
+import { unregisterEvents } from './index28.mjs';
+import { HookManager } from './index25.mjs';
+import { getDefinition } from './index31.mjs';
+import { isAssemblage } from './index3.mjs';
+
+class Injectable {
+    static of(e, t, i) {
+        return new Injectable(e, t, i);
+    }
+    dispose() {
+        if (this.singletonInstance) {
+            unregisterEvents(this, this.singletonInstance);
+            HookManager.callHook(this.singletonInstance, 'onDispose', this.publicContext, this.mergedConfiguration || this.configuration);
+            clearInstance(this.singletonInstance, this.concrete);
+        }
+        clearInstance(this, Injectable);
+    }
+    build(e) {
+        return this.builder.build(e);
+    }
+    setSingletonInstance(e, t) {
+        this.singletonInstance = e;
+        if (t) {
+            this.mergedConfiguration = t;
+        }
+    }
+    get definition() {
+        if (!this.cachedDefinition) {
+            this.cachedDefinition = getDefinition(this.concrete) || {};
+        }
+        return this.cachedDefinition;
+    }
+    get isSingleton() {
+        return this.definition.singleton ?? false;
+    }
+    get dependencies() {
+        return this.dependenciesIds;
+    }
+    get singleton() {
+        return this.singletonInstance;
+    }
+    get injections() {
+        if (this.cachedInjections === undefined) {
+            this.cachedInjections = this.definition.inject || [];
+        }
+        return this.cachedInjections;
+    }
+    get objects() {
+        if (this.cachedObjects === undefined) {
+            this.cachedObjects = this.definition.use || [];
+        }
+        return this.cachedObjects;
+    }
+    get tags() {
+        if (this.cachedTags === undefined) {
+            this.cachedTags = this.definition.tags || [];
+        }
+        return Array.isArray(this.cachedTags) ? this.cachedTags : [
+            this.cachedTags
+        ];
+    }
+    get globals() {
+        if (this.cachedGlobals === undefined) {
+            this.cachedGlobals = this.definition.global;
+        }
+        return this.cachedGlobals;
+    }
+    get events() {
+        if (this.cachedEvents === undefined) {
+            this.cachedEvents = this.definition.events || [];
+        }
+        return this.cachedEvents;
+    }
+    constructor(e, n, o){
+        this.privateContext = n;
+        this.publicContext = o;
+        this.dependenciesIds = [];
+        this.identifier = e.identifier;
+        this.concrete = e.concrete;
+        this.configuration = e.configuration;
+        if (process.env.NODE_ENV !== 'production' && !isAssemblage(this.concrete)) {
+            throw new Error(`Class '${this.concrete.name}' is not an Assemblage.`);
+        }
+        this.builder = new InjectableBuilder(this);
+        defineCustomMetadata(ReflectValue.AssemblageContext, this.publicContext, this.concrete);
+        for (const e of this.injections){
+            this.privateContext.register(e);
+        }
+        for (const e of this.objects){
+            if (typeof e[0] === 'string' || typeof e[0] === 'symbol') {
+                this.privateContext.use(e[0], e[1]);
+            } else {
+                this.privateContext.register(e, true);
+            }
+        }
+        this.dependenciesIds = resolveDependencies(this.concrete);
+        if (this.globals) {
+            for(const e in this.globals){
+                this.privateContext.addGlobal(e, this.globals[e]);
+            }
+        }
+        if (e.instance) {
+            this.singletonInstance = e.instance;
+        }
+    }
+}
+
+export { Injectable };

package/dist/index37.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const resolverStore = require('./index32.js');
+
+class ParameterResolverFactory {
+    static getResolver(r) {
+        return resolverStore.ResolverStore.getResolver(r);
+    }
+    static registerResolver(r, s) {
+        resolverStore.ResolverStore.register(r, s);
+    }
+    static hasResolver(r) {
+        return resolverStore.ResolverStore.hasResolver(r);
+    }
+}
+
+exports.ParameterResolverFactory = ParameterResolverFactory;

package/dist/index37.mjs

@@ -0,0 +1,15 @@
+import { ResolverStore } from './index32.mjs';
+
+class ParameterResolverFactory {
+    static getResolver(r) {
+        return ResolverStore.getResolver(r);
+    }
+    static registerResolver(r, s) {
+        ResolverStore.register(r, s);
+    }
+    static hasResolver(r) {
+        return ResolverStore.hasResolver(r);
+    }
+}
+
+export { ParameterResolverFactory };

package/dist/index38.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const dependencies = require('./index39.js');
+const helpers = require('./index28.js');
+
+class InjectableBuilder {
+    build(n) {
+        const i = this.mergeConfiguration(n);
+        const r = dependencies.resolveInjectableParameters(this.injectable, i);
+        const o = new this.injectable.concrete(...r);
+        helpers.registerEvents(this.injectable, o);
+        return o;
+    }
+    mergeConfiguration(e) {
+        const t = this.injectable.configuration || {};
+        if (e) {
+            return {
+                ...t,
+                ...e
+            };
+        }
+        return t;
+    }
+    constructor(e){
+        this.injectable = e;
+    }
+}
+
+exports.InjectableBuilder = InjectableBuilder;

package/dist/index38.mjs

@@ -0,0 +1,27 @@
+import { resolveInjectableParameters } from './index39.mjs';
+import { registerEvents } from './index28.mjs';
+
+class InjectableBuilder {
+    build(n) {
+        const i = this.mergeConfiguration(n);
+        const r = resolveInjectableParameters(this.injectable, i);
+        const o = new this.injectable.concrete(...r);
+        registerEvents(this.injectable, o);
+        return o;
+    }
+    mergeConfiguration(e) {
+        const t = this.injectable.configuration || {};
+        if (e) {
+            return {
+                ...t,
+                ...e
+            };
+        }
+        return t;
+    }
+    constructor(e){
+        this.injectable = e;
+    }
+}
+
+export { InjectableBuilder };

package/dist/index39.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const reflection = require('./index30.js');
+const helpers = require('./index21.js');
+const parameterResolver_factory = require('./index37.js');
+
+const r = new WeakMap();
+const s = (e, o)=>{
+    for (const [t, r] of Object.entries(e)){
+        if (r.includes(o)) {
+            return t;
+        }
+    }
+    return null;
+};
+const resolveInjectableParameters = (r, n)=>{
+    const c = [];
+    const l = reflection.getParamTypes(r.concrete);
+    const i = helpers.getDecoratedParametersIndexes(r.concrete);
+    for(let e = 0; e < l.length; e++){
+        const o = s(i, e);
+        if (o) {
+            const s = parameterResolver_factory.ParameterResolverFactory.getResolver(o);
+            c.push(s.resolve(e, r, r.concrete, n));
+        } else {
+            c.push(r.privateContext.require(l[e]));
+        }
+    }
+    return c;
+};
+const resolveDependencies = (t)=>{
+    if (r.has(t)) {
+        return r.get(t);
+    }
+    const s = [];
+    const n = reflection.getParamTypes(t);
+    const c = helpers.getDecoratedParametersIndexes(t);
+    let l = 0;
+    for (const e of n){
+        const o = Object.values(c).some((e)=>e.includes(l));
+        if (o) {
+            l++;
+            continue;
+        }
+        s.push(e);
+        l++;
+    }
+    r.set(t, s);
+    return s;
+};
+
+exports.resolveDependencies = resolveDependencies;
+exports.resolveInjectableParameters = resolveInjectableParameters;

package/dist/index39.mjs

@@ -0,0 +1,50 @@
+import { getParamTypes } from './index30.mjs';
+import { getDecoratedParametersIndexes } from './index21.mjs';
+import { ParameterResolverFactory } from './index37.mjs';
+
+const r = new WeakMap();
+const s = (e, o)=>{
+    for (const [t, r] of Object.entries(e)){
+        if (r.includes(o)) {
+            return t;
+        }
+    }
+    return null;
+};
+const resolveInjectableParameters = (r, n)=>{
+    const c = [];
+    const l = getParamTypes(r.concrete);
+    const i = getDecoratedParametersIndexes(r.concrete);
+    for(let e = 0; e < l.length; e++){
+        const o = s(i, e);
+        if (o) {
+            const s = ParameterResolverFactory.getResolver(o);
+            c.push(s.resolve(e, r, r.concrete, n));
+        } else {
+            c.push(r.privateContext.require(l[e]));
+        }
+    }
+    return c;
+};
+const resolveDependencies = (t)=>{
+    if (r.has(t)) {
+        return r.get(t);
+    }
+    const s = [];
+    const n = getParamTypes(t);
+    const c = getDecoratedParametersIndexes(t);
+    let l = 0;
+    for (const e of n){
+        const o = Object.values(c).some((e)=>e.includes(l));
+        if (o) {
+            l++;
+            continue;
+        }
+        s.push(e);
+        l++;
+    }
+    r.set(t, s);
+    return s;
+};
+
+export { resolveDependencies, resolveInjectableParameters };

package/dist/index4.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@assemblerjs/core');
+const injectableManager = require('./index23.js');
+const objectManager = require('./index24.js');
+const hookManager = require('./index25.js');
+const assemblerBuilder = require('./index26.js');
+const contextProvider = require('./index27.js');
+const eventManager = require('./index6.js');
+
+class Assembler extends eventManager.EventManager {
+    static build(e, t) {
+        const r = new Assembler();
+        const a = new assemblerBuilder.AssemblerBuilder(r);
+        return a.build(e, t);
+    }
+    get hookManager() {
+        return this._hookManager;
+    }
+    dispose() {
+        this.injectableManager.dispose();
+        core.clearInstance(this, Assembler);
+    }
+    register(e, t = false) {
+        return this.injectableManager.register(e, t);
+    }
+    use(e, t) {
+        return this.objectManager.use(e, t);
+    }
+    prepareInitHook(e, t) {
+        return this.hookManager.prepareInitHook(e, t);
+    }
+    has(e) {
+        if (typeof e === 'string' || typeof e === 'symbol') {
+            return this.objectManager.has(e);
+        }
+        return this.injectableManager.has(e);
+    }
+    require(e, t) {
+        switch(typeof e){
+            case 'string':
+            case 'symbol':
+                {
+                    return this.objectManager.require(e);
+                }
+            default:
+                {
+                    return this.injectableManager.require(e, t);
+                }
+        }
+    }
+    concrete(e) {
+        return this.injectableManager.concrete(e);
+    }
+    tagged(...e) {
+        return this.injectableManager.tagged(...e);
+    }
+    addGlobal(e, t) {
+        this.objectManager.addGlobal(e, t);
+    }
+    global(e) {
+        return this.objectManager.global(e);
+    }
+    get size() {
+        return this.injectableManager.size;
+    }
+    constructor(){
+        super();
+        this.injectableManager = new injectableManager.InjectableManager();
+        this.objectManager = new objectManager.ObjectManager();
+        this._hookManager = new hookManager.HookManager();
+        const e = new contextProvider.ContextProvider(this);
+        this.publicContext = e.createPublicContext();
+        this.privateContext = e.createPrivateContext(this.publicContext);
+        this.injectableManager.setContexts(this.privateContext, this.publicContext);
+    }
+}
+
+exports.Assembler = Assembler;

package/dist/index4.mjs

@@ -0,0 +1,77 @@
+import { clearInstance } from '@assemblerjs/core';
+import { InjectableManager } from './index23.mjs';
+import { ObjectManager } from './index24.mjs';
+import { HookManager } from './index25.mjs';
+import { AssemblerBuilder } from './index26.mjs';
+import { ContextProvider } from './index27.mjs';
+import { EventManager } from './index6.mjs';
+
+class Assembler extends EventManager {
+    static build(e, t) {
+        const r = new Assembler();
+        const a = new AssemblerBuilder(r);
+        return a.build(e, t);
+    }
+    get hookManager() {
+        return this._hookManager;
+    }
+    dispose() {
+        this.injectableManager.dispose();
+        clearInstance(this, Assembler);
+    }
+    register(e, t = false) {
+        return this.injectableManager.register(e, t);
+    }
+    use(e, t) {
+        return this.objectManager.use(e, t);
+    }
+    prepareInitHook(e, t) {
+        return this.hookManager.prepareInitHook(e, t);
+    }
+    has(e) {
+        if (typeof e === 'string' || typeof e === 'symbol') {
+            return this.objectManager.has(e);
+        }
+        return this.injectableManager.has(e);
+    }
+    require(e, t) {
+        switch(typeof e){
+            case 'string':
+            case 'symbol':
+                {
+                    return this.objectManager.require(e);
+                }
+            default:
+                {
+                    return this.injectableManager.require(e, t);
+                }
+        }
+    }
+    concrete(e) {
+        return this.injectableManager.concrete(e);
+    }
+    tagged(...e) {
+        return this.injectableManager.tagged(...e);
+    }
+    addGlobal(e, t) {
+        this.objectManager.addGlobal(e, t);
+    }
+    global(e) {
+        return this.objectManager.global(e);
+    }
+    get size() {
+        return this.injectableManager.size;
+    }
+    constructor(){
+        super();
+        this.injectableManager = new InjectableManager();
+        this.objectManager = new ObjectManager();
+        this._hookManager = new HookManager();
+        const e = new ContextProvider(this);
+        this.publicContext = e.createPublicContext();
+        this.privateContext = e.createPrivateContext(this.publicContext);
+        this.injectableManager.setContexts(this.privateContext, this.publicContext);
+    }
+}
+
+export { Assembler };

package/dist/index5.js

@@ -0,0 +1,94 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@assemblerjs/core');
+
+class ListenerCollection {
+    dispose() {
+        core.clearInstance(this, ListenerCollection);
+    }
+    add(...t) {
+        let e;
+        let l;
+        if (t.length === 2) {
+            e = t[0];
+            l = t[1];
+        } else {
+            const i = t[0];
+            e = i[0];
+            l = i[1];
+        }
+        if (!this.collection[e]) {
+            this.collection[e] = [];
+        }
+        this.collection[e].push(l);
+        return this;
+    }
+    remove(t, l) {
+        const i = (e)=>this.collection[t].splice(e, 1);
+        const n = core.conditionally({
+            if: ()=>this.collection[t] && this.collection[t].length === 0,
+            then: ()=>delete this.collection[t]
+        });
+        const s = core.conditionally({
+            if: ()=>core.isDefined(l),
+            then: ()=>i(this.collection[t].indexOf(l)),
+            else: ()=>delete this.collection[t]
+        });
+        const r = core.conditionally({
+            if: (t)=>this.has(t),
+            then: (t)=>this.collection[t]
+        });
+        core.pipe(r, s, n)();
+        return this;
+    }
+    has(...t) {
+        if (core.isOfType('string')(t[0])) {
+            return Object.keys(this.collection).includes(t[0]);
+        } else if (core.isOfType('function')(t[0])) {
+            return Object.values(this.collection).flat().includes(t[0]);
+        }
+        return false;
+    }
+    get(...t) {
+        if (core.isOfType('string')(t[0])) {
+            return this.collection[t[0]];
+        } else if (core.isOfType('function')(t[0])) {
+            return Object.values(this.collection).flat().filter((e)=>e === t[0]);
+        }
+        return [];
+    }
+    clear() {
+        const t = core.forIn(this.collection);
+        const e = (t)=>core.forOf(this.collection[t])((e)=>this.remove(t, e));
+        t((t)=>e(t));
+        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;
+    }
+    [Symbol.iterator]() {
+        let t = -1;
+        const e = this.collection ? Object.keys(this.collection) : [];
+        return {
+            next: ()=>({
+                    value: e[++t],
+                    done: !(t in e)
+                })
+        };
+    }
+    constructor(){
+        this.collection = {};
+        const t = core.proxifyIterable(this, ListenerCollection);
+        return t;
+    }
+}
+
+exports.ListenerCollection = ListenerCollection;