assemblerjs 1.1.2 → 1.1.3

package/dist/index43.mjs

@@ -1,195 +1,29 @@
-import { isClass, clearInstance } from '@assemblerjs/core';
-import { ReflectValue } from './index28.mjs';
-import { defineCustomMetadata } from './index35.mjs';
-import { InjectableBuilder } from './index48.mjs';
-import { resolveDependencies } from './index49.mjs';
-import { unregisterEvents } from './index29.mjs';
-import { HookManager } from './index32.mjs';
-import { isAssemblage } from './index3.mjs';
-import { isFactory } from './index41.mjs';
-import { getDefinition } from './index36.mjs';
-import { isTransversal } from './index11.mjs';
-import { TransversalManager } from './index13.mjs';
-
-class Injectable {
-    static of(t, e, s) {
-        return new Injectable(t, e, 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]
-            ];
-        }
-    }
-    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;
+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 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;
-        }
+}
+class TransientStrategy {
+    resolve(t, e) {
+        const n = t.build(e);
+        t.privateContext.prepareInitHook(n, t.configuration);
+        return n;
     }
 }
 
-export { Injectable };
+export { SingletonStrategy, TransientStrategy };