assemblerjs 1.1.1 → 1.1.3

package/dist/index43.mjs

@@ -1,173 +1,29 @@
-import { isClass, clearInstance } from '@assemblerjs/core';
-import { ReflectValue } from './index28.mjs';
-import { defineCustomMetadata } from './index29.mjs';
-import { InjectableBuilder } from './index48.mjs';
-import { resolveDependencies } from './index49.mjs';
-import { unregisterEvents } from './index37.mjs';
-import { HookManager } from './index34.mjs';
-import { isAssemblage } from './index3.mjs';
-import { getDefinition } from './index30.mjs';
-import { isTransversal } from './index11.mjs';
-import { TransversalManager } from './index13.mjs';
-
-class Injectable {
-    static of(e, t, s) {
-        return new Injectable(e, t, s);
-    }
-    resolveTransversalToInjection(e) {
-        if (e.length === 1) {
-            return [
-                e[0]
-            ];
-        } else if (e.length === 2) {
-            const s = e[1];
-            if (isClass(s)) {
-                return [
-                    e[0],
-                    e[1]
-                ];
-            } else {
-                return [
-                    e[0],
-                    e[1]
-                ];
-            }
-        } else {
-            return [
-                e[0],
-                e[1],
-                e[2]
-            ];
-        }
-    }
-    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;
+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();
     }
-    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(e, t, r){
-        this.privateContext = t;
-        this.publicContext = r;
-        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.transversals){
-            const t = this.resolveTransversalToInjection(e);
-            this.privateContext.register(t);
-        }
-        for (const e of this.injections){
-            const [t] = e;
-            if (isTransversal(t)) {
-                this.privateContext.register(e);
-            }
-        }
-        for (const e of this.injections){
-            const [t] = e;
-            if (!isTransversal(t)) {
-                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);
-            }
-        }
-        const a = TransversalManager.getInstance(this.publicContext);
-        for (const e of this.transversals){
-            a.registerTransversal(e, this.privateContext);
-        }
-        for (const e of this.injections){
-            const [t] = e;
-            if (isTransversal(t)) {
-                const s = e.length > 1 ? e : [
-                    t
-                ];
-                a.registerTransversal(s, this.privateContext);
-            }
-        }
-        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;
-        }
+}
+class TransientStrategy {
+    resolve(t, e) {
+        const n = t.build(e);
+        t.privateContext.prepareInitHook(n, t.configuration);
+        return n;
     }
 }
 
-export { Injectable };
+export { SingletonStrategy, TransientStrategy };