assemblerjs 1.0.0 → 1.1.0

package/dist/index43.mjs

@@ -0,0 +1,173 @@
+import { isClass, clearInstance } from '@assemblerjs/core';
+import { ReflectValue } from './index28.mjs';
+import { defineCustomMetadata } from './index34.mjs';
+import { InjectableBuilder } from './index48.mjs';
+import { resolveDependencies } from './index49.mjs';
+import { unregisterEvents } from './index36.mjs';
+import { HookManager } from './index31.mjs';
+import { isAssemblage } from './index3.mjs';
+import { getDefinition } from './index37.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;
+    }
+    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;
+        }
+    }
+}
+
+export { Injectable };