assemblerjs 1.1.15 → 1.1.17

package/dist/index46.js

@@ -2,6 +2,6 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+var _Reflect = {};
 
-exports.commonjsGlobal = commonjsGlobal;
+exports.__exports = _Reflect;

package/dist/index46.mjs

@@ -1,3 +1,3 @@
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+var _Reflect = {};
 
-export { commonjsGlobal };
+export { _Reflect as __exports };

package/dist/index47.js

@@ -2,6 +2,33 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-var _Reflect = {};
+class SingletonStrategy {
+    resolve(t, e) {
+        const n = t.identifier;
+        if (this.cache.has(n)) {
+            return this.cache.get(n);
+        }
+        const o = t.build(e);
+        const r = e ? {
+            ...t.configuration,
+            ...e
+        } : t.configuration;
+        t.setSingletonInstance(o, r);
+        this.cache.set(n, o);
+        t.privateContext.prepareInitHook(o, t.configuration);
+        return o;
+    }
+    constructor(){
+        this.cache = new Map();
+    }
+}
+class TransientStrategy {
+    resolve(t, e) {
+        const n = t.build(e);
+        t.privateContext.prepareInitHook(n, t.configuration);
+        return n;
+    }
+}
 
-exports.__exports = _Reflect;
+exports.SingletonStrategy = SingletonStrategy;
+exports.TransientStrategy = TransientStrategy;

package/dist/index47.mjs

@@ -1,3 +1,29 @@
-var _Reflect = {};
+class SingletonStrategy {
+    resolve(t, e) {
+        const n = t.identifier;
+        if (this.cache.has(n)) {
+            return this.cache.get(n);
+        }
+        const o = t.build(e);
+        const r = e ? {
+            ...t.configuration,
+            ...e
+        } : t.configuration;
+        t.setSingletonInstance(o, r);
+        this.cache.set(n, o);
+        t.privateContext.prepareInitHook(o, t.configuration);
+        return o;
+    }
+    constructor(){
+        this.cache = new Map();
+    }
+}
+class TransientStrategy {
+    resolve(t, e) {
+        const n = t.build(e);
+        t.privateContext.prepareInitHook(n, t.configuration);
+        return n;
+    }
+}
 
-export { _Reflect as __exports };
+export { SingletonStrategy, TransientStrategy };

package/dist/index48.js

@@ -2,18 +2,198 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const resolverStore = require('./index31.js');
+const core = require('@assemblerjs/core');
+const constants = require('./index28.js');
+const reflection = require('./index29.js');
+const injectableBuilder = require('./index50.js');
+const dependencies = require('./index51.js');
+const helpers = require('./index31.js');
+const hookManager = require('./index37.js');
+const helpers$1 = require('./index3.js');
+const use = require('./index43.js');
+const schema = require('./index30.js');
+const decorators = require('./index11.js');
+const transversalManager = require('./index13.js');
 
-class ParameterResolverFactory {
-    static getResolver(r) {
-        return resolverStore.ResolverStore.getResolver(r);
+class Injectable {
+    static of(t, e, s) {
+        return new Injectable(t, e, s);
     }
-    static registerResolver(r, s) {
-        resolverStore.ResolverStore.register(r, s);
+    resolveTransversalToInjection(t) {
+        if (t.length === 1) {
+            return [
+                t[0]
+            ];
+        } else if (t.length === 2) {
+            const s = t[1];
+            if (core.isClass(s)) {
+                return [
+                    t[0],
+                    t[1]
+                ];
+            } else {
+                return [
+                    t[0],
+                    t[1]
+                ];
+            }
+        } else {
+            return [
+                t[0],
+                t[1],
+                t[2]
+            ];
+        }
     }
-    static hasResolver(r) {
-        return resolverStore.ResolverStore.hasResolver(r);
+    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(t) {
+        return this.builder.build(t);
+    }
+    setSingletonInstance(t, e) {
+        this.singletonInstance = t;
+        if (e) {
+            this.mergedConfiguration = e;
+        }
+    }
+    get definition() {
+        if (!this.cachedDefinition) {
+            if (!this.concrete) {
+                this.cachedDefinition = {};
+            } else {
+                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 transversals() {
+        if (this.cachedTransversals === undefined) {
+            this.cachedTransversals = this.definition.engage || [];
+        }
+        return this.cachedTransversals;
+    }
+    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(t, e, o){
+        this.privateContext = e;
+        this.publicContext = o;
+        this.dependenciesIds = [];
+        this.identifier = t.identifier;
+        this.concrete = t.concrete;
+        this.factory = t.factory;
+        this.configuration = t.configuration;
+        if (process.env.NODE_ENV !== 'production' && this.concrete && !helpers$1.isAssemblage(this.concrete)) {
+            throw new Error(`Class '${this.concrete.name}' is not an Assemblage.`);
+        }
+        this.builder = new injectableBuilder.InjectableBuilder(this);
+        if (this.concrete) {
+            reflection.defineCustomMetadata(constants.ReflectValue.AssemblageContext, this.publicContext, this.concrete);
+            for (const t of this.transversals){
+                const e = this.resolveTransversalToInjection(t);
+                this.privateContext.register(e);
+            }
+            for (const t of this.injections){
+                const [e] = t;
+                if (decorators.isTransversal(e)) {
+                    this.privateContext.register(t);
+                }
+            }
+            for (const t of this.injections){
+                const [e] = t;
+                if (!decorators.isTransversal(e)) {
+                    this.privateContext.register(t);
+                }
+            }
+            for (const t of this.objects){
+                const [e, s] = t;
+                const i = use.isFactory(s);
+                if (typeof e === 'string' || typeof e === 'symbol') {
+                    const t = i ? s() : s;
+                    this.privateContext.use(e, t);
+                    continue;
+                }
+                if (this.isSingleton && i) {
+                    const t = s();
+                    this.privateContext.register([
+                        e,
+                        t
+                    ], true);
+                } else {
+                    this.privateContext.register(t, true);
+                }
+            }
+            const t = transversalManager.TransversalManager.getInstance(this.publicContext);
+            for (const e of this.transversals){
+                t.registerTransversal(e, this.privateContext);
+            }
+            for (const e of this.injections){
+                const [s] = e;
+                if (decorators.isTransversal(s)) {
+                    const i = e.length > 1 ? e : [
+                        s
+                    ];
+                    t.registerTransversal(i, this.privateContext);
+                }
+            }
+            this.dependenciesIds = this.concrete ? dependencies.resolveDependencies(this.concrete) : [];
+            if (this.globals) {
+                for(const t in this.globals){
+                    this.privateContext.addGlobal(t, this.globals[t]);
+                }
+            }
+        }
+        if (t.instance) {
+            this.singletonInstance = t.instance;
+        } else if (t.factory) {
+            const e = t.factory();
+            this.singletonInstance = e;
+        }
     }
 }
 
-exports.ParameterResolverFactory = ParameterResolverFactory;
+exports.Injectable = Injectable;

package/dist/index48.mjs

@@ -1,15 +1,195 @@
-import { ResolverStore } from './index31.mjs';
+import { isClass, clearInstance } from '@assemblerjs/core';
+import { ReflectValue } from './index28.mjs';
+import { defineCustomMetadata } from './index29.mjs';
+import { InjectableBuilder } from './index50.mjs';
+import { resolveDependencies } from './index51.mjs';
+import { unregisterEvents } from './index31.mjs';
+import { HookManager } from './index37.mjs';
+import { isAssemblage } from './index3.mjs';
+import { isFactory } from './index43.mjs';
+import { getDefinition } from './index30.mjs';
+import { isTransversal } from './index11.mjs';
+import { TransversalManager } from './index13.mjs';
 
-class ParameterResolverFactory {
-    static getResolver(r) {
-        return ResolverStore.getResolver(r);
+class Injectable {
+    static of(t, e, s) {
+        return new Injectable(t, e, s);
     }
-    static registerResolver(r, s) {
-        ResolverStore.register(r, s);
+    resolveTransversalToInjection(t) {
+        if (t.length === 1) {
+            return [
+                t[0]
+            ];
+        } else if (t.length === 2) {
+            const s = t[1];
+            if (isClass(s)) {
+                return [
+                    t[0],
+                    t[1]
+                ];
+            } else {
+                return [
+                    t[0],
+                    t[1]
+                ];
+            }
+        } else {
+            return [
+                t[0],
+                t[1],
+                t[2]
+            ];
+        }
     }
-    static hasResolver(r) {
-        return ResolverStore.hasResolver(r);
+    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(t) {
+        return this.builder.build(t);
+    }
+    setSingletonInstance(t, e) {
+        this.singletonInstance = t;
+        if (e) {
+            this.mergedConfiguration = e;
+        }
+    }
+    get definition() {
+        if (!this.cachedDefinition) {
+            if (!this.concrete) {
+                this.cachedDefinition = {};
+            } else {
+                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 transversals() {
+        if (this.cachedTransversals === undefined) {
+            this.cachedTransversals = this.definition.engage || [];
+        }
+        return this.cachedTransversals;
+    }
+    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(t, e, o){
+        this.privateContext = e;
+        this.publicContext = o;
+        this.dependenciesIds = [];
+        this.identifier = t.identifier;
+        this.concrete = t.concrete;
+        this.factory = t.factory;
+        this.configuration = t.configuration;
+        if (process.env.NODE_ENV !== 'production' && this.concrete && !isAssemblage(this.concrete)) {
+            throw new Error(`Class '${this.concrete.name}' is not an Assemblage.`);
+        }
+        this.builder = new InjectableBuilder(this);
+        if (this.concrete) {
+            defineCustomMetadata(ReflectValue.AssemblageContext, this.publicContext, this.concrete);
+            for (const t of this.transversals){
+                const e = this.resolveTransversalToInjection(t);
+                this.privateContext.register(e);
+            }
+            for (const t of this.injections){
+                const [e] = t;
+                if (isTransversal(e)) {
+                    this.privateContext.register(t);
+                }
+            }
+            for (const t of this.injections){
+                const [e] = t;
+                if (!isTransversal(e)) {
+                    this.privateContext.register(t);
+                }
+            }
+            for (const t of this.objects){
+                const [e, s] = t;
+                const i = isFactory(s);
+                if (typeof e === 'string' || typeof e === 'symbol') {
+                    const t = i ? s() : s;
+                    this.privateContext.use(e, t);
+                    continue;
+                }
+                if (this.isSingleton && i) {
+                    const t = s();
+                    this.privateContext.register([
+                        e,
+                        t
+                    ], true);
+                } else {
+                    this.privateContext.register(t, true);
+                }
+            }
+            const t = TransversalManager.getInstance(this.publicContext);
+            for (const e of this.transversals){
+                t.registerTransversal(e, this.privateContext);
+            }
+            for (const e of this.injections){
+                const [s] = e;
+                if (isTransversal(s)) {
+                    const i = e.length > 1 ? e : [
+                        s
+                    ];
+                    t.registerTransversal(i, this.privateContext);
+                }
+            }
+            this.dependenciesIds = this.concrete ? resolveDependencies(this.concrete) : [];
+            if (this.globals) {
+                for(const t in this.globals){
+                    this.privateContext.addGlobal(t, this.globals[t]);
+                }
+            }
+        }
+        if (t.instance) {
+            this.singletonInstance = t.instance;
+        } else if (t.factory) {
+            const e = t.factory();
+            this.singletonInstance = e;
+        }
     }
 }
 
-export { ParameterResolverFactory };
+export { Injectable };

package/dist/index49.js

@@ -2,43 +2,18 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const dependencies = require('./index50.js');
-const transversalWeaver = require('./index38.js');
-const helpers = require('./index40.js');
+const resolverStore = require('./index34.js');
 
-class InjectableBuilder {
-    build(i) {
-        const r = this.mergeConfiguration(i);
-        let c;
-        if (this.injectable.singletonInstance) {
-            return this.injectable.singletonInstance;
-        }
-        if (this.injectable.factory) {
-            c = this.injectable.factory();
-        } else if (this.injectable.concrete) {
-            const e = dependencies.resolveInjectableParameters(this.injectable, r);
-            c = new this.injectable.concrete(...e);
-        } else {
-            throw new Error(`Injectable with identifier '${String(this.injectable.identifier)}' has neither concrete class nor factory.`);
-        }
-        const s = this.injectable.concrete || c.constructor;
-        const o = transversalWeaver.TransversalWeaver.weave(c, s, this.injectable.publicContext);
-        helpers.registerEvents(this.injectable, o);
-        return o;
+class ParameterResolverFactory {
+    static getResolver(r) {
+        return resolverStore.ResolverStore.getResolver(r);
     }
-    mergeConfiguration(e) {
-        const t = this.injectable.configuration || {};
-        if (e) {
-            return {
-                ...t,
-                ...e
-            };
-        }
-        return t;
+    static registerResolver(r, s) {
+        resolverStore.ResolverStore.register(r, s);
     }
-    constructor(e){
-        this.injectable = e;
+    static hasResolver(r) {
+        return resolverStore.ResolverStore.hasResolver(r);
     }
 }
 
-exports.InjectableBuilder = InjectableBuilder;
+exports.ParameterResolverFactory = ParameterResolverFactory;

package/dist/index49.mjs

@@ -1,40 +1,15 @@
-import { resolveInjectableParameters } from './index50.mjs';
-import { TransversalWeaver } from './index38.mjs';
-import { registerEvents } from './index40.mjs';
+import { ResolverStore } from './index34.mjs';
 
-class InjectableBuilder {
-    build(i) {
-        const r = this.mergeConfiguration(i);
-        let c;
-        if (this.injectable.singletonInstance) {
-            return this.injectable.singletonInstance;
-        }
-        if (this.injectable.factory) {
-            c = this.injectable.factory();
-        } else if (this.injectable.concrete) {
-            const e = resolveInjectableParameters(this.injectable, r);
-            c = new this.injectable.concrete(...e);
-        } else {
-            throw new Error(`Injectable with identifier '${String(this.injectable.identifier)}' has neither concrete class nor factory.`);
-        }
-        const s = this.injectable.concrete || c.constructor;
-        const o = TransversalWeaver.weave(c, s, this.injectable.publicContext);
-        registerEvents(this.injectable, o);
-        return o;
+class ParameterResolverFactory {
+    static getResolver(r) {
+        return ResolverStore.getResolver(r);
     }
-    mergeConfiguration(e) {
-        const t = this.injectable.configuration || {};
-        if (e) {
-            return {
-                ...t,
-                ...e
-            };
-        }
-        return t;
+    static registerResolver(r, s) {
+        ResolverStore.register(r, s);
     }
-    constructor(e){
-        this.injectable = e;
+    static hasResolver(r) {
+        return ResolverStore.hasResolver(r);
     }
 }
 
-export { InjectableBuilder };
+export { ParameterResolverFactory };