assemblerjs 1.1.2 → 1.1.4

package/dist/index30.js

@@ -2,70 +2,112 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const hookManager = require('./index32.js');
-const resolutionStrategies = require('./index40.js');
-const use = require('./index41.js');
-const inject = require('./index42.js');
-const injectable = require('./index43.js');
+const constants = require('./index28.js');
+const reflection = require('./index29.js');
+const helpers = require('./index3.js');
 
-class InjectableManager {
-    setContexts(e, t) {
-        this.privateContext = e;
-        this.publicContext = t;
-    }
-    register(r, n = false) {
-        const o = n === true ? use.resolveInstanceInjectionTuple(r) : inject.resolveInjectionTuple(r);
-        if (this.has(o.identifier)) {
-            throw new Error(`An assemblage is already registered with identifier '${o.identifier.name}'.`);
-        }
-        const a = injectable.Injectable.of(o, this.privateContext, this.publicContext);
-        this.injectables.set(a.identifier, a);
-        if (a.concrete) {
-            hookManager.HookManager.callHook(a.concrete, 'onRegister', this.publicContext, a.configuration);
-        }
-        return a;
-    }
-    has(e) {
-        return this.injectables.has(e);
-    }
-    require(e, t) {
-        if (!this.injectables.has(e)) {
-            throw new Error(`Class with identifier '${e.name}' has not been registered or is a circular dependency.`);
-        }
-        const i = this.injectables.get(e);
-        if (i.isSingleton) {
-            return this.singletonStrategy.resolve(i, t);
-        } else {
-            return this.transientStrategy.resolve(i, t);
+const n = {
+    singleton: {
+        test: (r)=>typeof r === 'boolean' || typeof r === 'undefined',
+        throw: ()=>{
+            throw new Error(`'singleton' property must be of type 'boolean' or 'undefined'.`);
+        },
+        transform: (r)=>{
+            return typeof r === 'undefined' ? true : r ? true : false;
         }
+    },
+    events: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>typeof r === 'string'),
+        throw: ()=>{
+            throw new Error(`'events' property must be an array of strings or 'undefined'.`);
+        },
+        transform: (r)=>r
+    },
+    inject: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>Array.isArray(r) && r.length >= 1 && r.length <= 3),
+        throw: ()=>{
+            throw new Error(`'inject' property must be an array of tuples of length 1, 2 or 3.`);
+        },
+        transform: (r)=>r
+    },
+    use: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>{
+                if (!Array.isArray(r) || r.length !== 2) {
+                    return false;
+                }
+                const e = r[1];
+                return typeof e !== 'undefined';
+            }),
+        throw: ()=>{
+            throw new Error(`'use' property must be an array of tuples of length 2 with [identifier, instance | factory].`);
+        },
+        transform: (r)=>r
+    },
+    engage: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>Array.isArray(r) && r.length >= 1 && r.length <= 3),
+        throw: ()=>{
+            throw new Error(`'engage' property must be an array of tuples of length 1, 2 or 3.`);
+        },
+        transform: (r)=>r
+    },
+    tags: {
+        test: (r)=>typeof r === 'undefined' || typeof r === 'string' || Array.isArray(r) && r.every((r)=>typeof r === 'string'),
+        throw: ()=>{
+            throw new Error(`'tags' property must be a string or an array of strings.`);
+        },
+        transform: (r)=>typeof r === 'string' ? [
+                r
+            ] : r
+    },
+    metadata: {
+        test: (r)=>(typeof r === 'object' || typeof r === 'undefined') && !Array.isArray(r),
+        throw: ()=>{
+            throw new Error(`'metadata' property must be of type 'object' or 'undefined'.`);
+        },
+        transform: (r)=>r
+    },
+    global: {
+        test: (r)=>(typeof r === 'object' || typeof r === 'undefined') && !Array.isArray(r),
+        throw: ()=>{
+            throw new Error(`'global' property must be of type 'object' or 'undefined'.`);
+        },
+        transform: (r)=>r
     }
-    concrete(e) {
-        const t = this.injectables.get(e);
-        if (t) return t.concrete;
-        return;
-    }
-    tagged(...e) {
-        const t = [];
-        for (const i of e){
-            for (const [e, s] of this.injectables){
-                if (s.tags.includes(i)) t.push(s.build());
-            }
+};
+const validateDefinition = (r)=>{
+    const e = {
+        ...r
+    };
+    for(const r in e){
+        if (!Object.keys(n).includes(r)) {
+            throw new Error(`Property '${r}' is not a valid assemblage definition property.`);
         }
-        return t;
     }
-    dispose() {
-        for (const [e, t] of this.injectables){
-            t.dispose();
+    for(const r in n){
+        const t = n[r].test;
+        const o = n[r].throw;
+        const s = n[r].transform;
+        if (!t(e[r])) {
+            o();
         }
+        e[r] = s(e[r]);
     }
-    get size() {
-        return this.injectables.size;
-    }
-    constructor(){
-        this.injectables = new Map();
-        this.singletonStrategy = new resolutionStrategies.SingletonStrategy();
-        this.transientStrategy = new resolutionStrategies.TransientStrategy();
+    return e;
+};
+const getDefinition = (e)=>{
+    if (!helpers.isAssemblage(e)) {
+        throw new Error(`Class '${e.name}' is not an assemblage or transversal.`);
     }
-}
+    return reflection.getOwnCustomMetadata(constants.ReflectValue.AssemblageDefinition, e);
+};
+const setDefinitionValue = (t, o, n)=>{
+    const s = getDefinition(n);
+    s[t] = o;
+    const a = validateDefinition(s);
+    reflection.defineCustomMetadata(constants.ReflectValue.AssemblageDefinition, a, n);
+    return a;
+};
 
-exports.InjectableManager = InjectableManager;
+exports.getDefinition = getDefinition;
+exports.setDefinitionValue = setDefinitionValue;
+exports.validateDefinition = validateDefinition;

package/dist/index30.mjs

@@ -1,67 +1,107 @@
-import { HookManager } from './index32.mjs';
-import { SingletonStrategy, TransientStrategy } from './index40.mjs';
-import { resolveInstanceInjectionTuple } from './index41.mjs';
-import { resolveInjectionTuple } from './index42.mjs';
-import { Injectable } from './index43.mjs';
+import { ReflectValue } from './index28.mjs';
+import { getOwnCustomMetadata, defineCustomMetadata } from './index29.mjs';
+import { isAssemblage } from './index3.mjs';
 
-class InjectableManager {
-    setContexts(e, t) {
-        this.privateContext = e;
-        this.publicContext = t;
-    }
-    register(r, n = false) {
-        const o = n === true ? resolveInstanceInjectionTuple(r) : resolveInjectionTuple(r);
-        if (this.has(o.identifier)) {
-            throw new Error(`An assemblage is already registered with identifier '${o.identifier.name}'.`);
-        }
-        const a = Injectable.of(o, this.privateContext, this.publicContext);
-        this.injectables.set(a.identifier, a);
-        if (a.concrete) {
-            HookManager.callHook(a.concrete, 'onRegister', this.publicContext, a.configuration);
-        }
-        return a;
-    }
-    has(e) {
-        return this.injectables.has(e);
-    }
-    require(e, t) {
-        if (!this.injectables.has(e)) {
-            throw new Error(`Class with identifier '${e.name}' has not been registered or is a circular dependency.`);
-        }
-        const i = this.injectables.get(e);
-        if (i.isSingleton) {
-            return this.singletonStrategy.resolve(i, t);
-        } else {
-            return this.transientStrategy.resolve(i, t);
+const n = {
+    singleton: {
+        test: (r)=>typeof r === 'boolean' || typeof r === 'undefined',
+        throw: ()=>{
+            throw new Error(`'singleton' property must be of type 'boolean' or 'undefined'.`);
+        },
+        transform: (r)=>{
+            return typeof r === 'undefined' ? true : r ? true : false;
         }
+    },
+    events: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>typeof r === 'string'),
+        throw: ()=>{
+            throw new Error(`'events' property must be an array of strings or 'undefined'.`);
+        },
+        transform: (r)=>r
+    },
+    inject: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>Array.isArray(r) && r.length >= 1 && r.length <= 3),
+        throw: ()=>{
+            throw new Error(`'inject' property must be an array of tuples of length 1, 2 or 3.`);
+        },
+        transform: (r)=>r
+    },
+    use: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>{
+                if (!Array.isArray(r) || r.length !== 2) {
+                    return false;
+                }
+                const e = r[1];
+                return typeof e !== 'undefined';
+            }),
+        throw: ()=>{
+            throw new Error(`'use' property must be an array of tuples of length 2 with [identifier, instance | factory].`);
+        },
+        transform: (r)=>r
+    },
+    engage: {
+        test: (r)=>typeof r === 'undefined' || Array.isArray(r) && r.every((r)=>Array.isArray(r) && r.length >= 1 && r.length <= 3),
+        throw: ()=>{
+            throw new Error(`'engage' property must be an array of tuples of length 1, 2 or 3.`);
+        },
+        transform: (r)=>r
+    },
+    tags: {
+        test: (r)=>typeof r === 'undefined' || typeof r === 'string' || Array.isArray(r) && r.every((r)=>typeof r === 'string'),
+        throw: ()=>{
+            throw new Error(`'tags' property must be a string or an array of strings.`);
+        },
+        transform: (r)=>typeof r === 'string' ? [
+                r
+            ] : r
+    },
+    metadata: {
+        test: (r)=>(typeof r === 'object' || typeof r === 'undefined') && !Array.isArray(r),
+        throw: ()=>{
+            throw new Error(`'metadata' property must be of type 'object' or 'undefined'.`);
+        },
+        transform: (r)=>r
+    },
+    global: {
+        test: (r)=>(typeof r === 'object' || typeof r === 'undefined') && !Array.isArray(r),
+        throw: ()=>{
+            throw new Error(`'global' property must be of type 'object' or 'undefined'.`);
+        },
+        transform: (r)=>r
     }
-    concrete(e) {
-        const t = this.injectables.get(e);
-        if (t) return t.concrete;
-        return;
-    }
-    tagged(...e) {
-        const t = [];
-        for (const i of e){
-            for (const [e, s] of this.injectables){
-                if (s.tags.includes(i)) t.push(s.build());
-            }
+};
+const validateDefinition = (r)=>{
+    const e = {
+        ...r
+    };
+    for(const r in e){
+        if (!Object.keys(n).includes(r)) {
+            throw new Error(`Property '${r}' is not a valid assemblage definition property.`);
         }
-        return t;
     }
-    dispose() {
-        for (const [e, t] of this.injectables){
-            t.dispose();
+    for(const r in n){
+        const t = n[r].test;
+        const o = n[r].throw;
+        const s = n[r].transform;
+        if (!t(e[r])) {
+            o();
         }
+        e[r] = s(e[r]);
     }
-    get size() {
-        return this.injectables.size;
-    }
-    constructor(){
-        this.injectables = new Map();
-        this.singletonStrategy = new SingletonStrategy();
-        this.transientStrategy = new TransientStrategy();
+    return e;
+};
+const getDefinition = (e)=>{
+    if (!isAssemblage(e)) {
+        throw new Error(`Class '${e.name}' is not an assemblage or transversal.`);
     }
-}
+    return getOwnCustomMetadata(ReflectValue.AssemblageDefinition, e);
+};
+const setDefinitionValue = (t, o, n)=>{
+    const s = getDefinition(n);
+    s[t] = o;
+    const a = validateDefinition(s);
+    defineCustomMetadata(ReflectValue.AssemblageDefinition, a, n);
+    return a;
+};
 
-export { InjectableManager };
+export { getDefinition, setDefinitionValue, validateDefinition };

package/dist/index31.js

@@ -2,36 +2,79 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-class ObjectManager {
-    use(e, t) {
-        if (this.has(e)) {
-            throw new Error(`A value is already registered with identifier '${String(e)}'.`);
+const hookManager = require('./index33.js');
+const resolutionStrategies = require('./index43.js');
+const debugLogger = require('./index36.js');
+const use = require('./index42.js');
+const inject = require('./index41.js');
+const injectable = require('./index44.js');
+
+class InjectableManager {
+    setContexts(e, t) {
+        this.privateContext = e;
+        this.publicContext = t;
+    }
+    register(s, n = false) {
+        const a = debugLogger.DebugLogger.getInstance();
+        const c = n === true ? use.resolveInstanceInjectionTuple(s) : inject.resolveInjectionTuple(s);
+        if (this.has(c.identifier)) {
+            throw new Error(`An assemblage is already registered with identifier '${c.identifier.name}'.`);
         }
-        this.objects.set(e, t);
-        return t;
+        const l = injectable.Injectable.of(c, this.privateContext, this.publicContext);
+        a.logRegistration(l);
+        this.injectables.set(l.identifier, l);
+        if (l.concrete) {
+            hookManager.HookManager.callHook(l.concrete, 'onRegister', this.publicContext, l.configuration);
+        }
+        return l;
     }
     has(e) {
-        return this.objects.has(e);
+        return this.injectables.has(e);
     }
-    require(e) {
-        if (!this.objects.has(e)) {
-            throw new Error(`Injected object with identifier '${String(e)}' has not been registered.`);
+    require(e, t, i) {
+        if (!this.injectables.has(e)) {
+            const t = `Class with identifier '${e.name}' has not been registered or is a circular dependency.`;
+            debugLogger.DebugLogger.getInstance().log('error', 'Resolution failed', {
+                identifier: e.name,
+                caller: i ? i?.name || String(i) : 'unknown',
+                error: t
+            });
+            throw new Error(t);
+        }
+        const r = this.injectables.get(e);
+        if (r.isSingleton) {
+            return this.singletonStrategy.resolve(r, t);
+        } else {
+            return this.transientStrategy.resolve(r, t);
         }
-        return this.objects.get(e);
     }
-    addGlobal(e, t) {
-        if (this.globals.has(e)) {
-            throw new Error(`Global value with key '${e}' has already been registered.`);
+    concrete(e) {
+        const t = this.injectables.get(e);
+        if (t) return t.concrete;
+        return;
+    }
+    tagged(...e) {
+        const t = [];
+        for (const i of e){
+            for (const [e, r] of this.injectables){
+                if (r.tags.includes(i)) t.push(r.build());
+            }
+        }
+        return t;
+    }
+    dispose() {
+        for (const [e, t] of this.injectables){
+            t.dispose();
         }
-        this.globals.set(e, t);
     }
-    global(e) {
-        return this.globals.get(e);
+    get size() {
+        return this.injectables.size;
     }
     constructor(){
-        this.objects = new Map();
-        this.globals = new Map();
+        this.injectables = new Map();
+        this.singletonStrategy = new resolutionStrategies.SingletonStrategy();
+        this.transientStrategy = new resolutionStrategies.TransientStrategy();
     }
 }
 
-exports.ObjectManager = ObjectManager;
+exports.InjectableManager = InjectableManager;

package/dist/index31.mjs

@@ -1,33 +1,76 @@
-class ObjectManager {
-    use(e, t) {
-        if (this.has(e)) {
-            throw new Error(`A value is already registered with identifier '${String(e)}'.`);
+import { HookManager } from './index33.mjs';
+import { SingletonStrategy, TransientStrategy } from './index43.mjs';
+import { DebugLogger } from './index36.mjs';
+import { resolveInstanceInjectionTuple } from './index42.mjs';
+import { resolveInjectionTuple } from './index41.mjs';
+import { Injectable } from './index44.mjs';
+
+class InjectableManager {
+    setContexts(e, t) {
+        this.privateContext = e;
+        this.publicContext = t;
+    }
+    register(s, n = false) {
+        const a = DebugLogger.getInstance();
+        const c = n === true ? resolveInstanceInjectionTuple(s) : resolveInjectionTuple(s);
+        if (this.has(c.identifier)) {
+            throw new Error(`An assemblage is already registered with identifier '${c.identifier.name}'.`);
         }
-        this.objects.set(e, t);
-        return t;
+        const l = Injectable.of(c, this.privateContext, this.publicContext);
+        a.logRegistration(l);
+        this.injectables.set(l.identifier, l);
+        if (l.concrete) {
+            HookManager.callHook(l.concrete, 'onRegister', this.publicContext, l.configuration);
+        }
+        return l;
     }
     has(e) {
-        return this.objects.has(e);
+        return this.injectables.has(e);
     }
-    require(e) {
-        if (!this.objects.has(e)) {
-            throw new Error(`Injected object with identifier '${String(e)}' has not been registered.`);
+    require(e, t, i) {
+        if (!this.injectables.has(e)) {
+            const t = `Class with identifier '${e.name}' has not been registered or is a circular dependency.`;
+            DebugLogger.getInstance().log('error', 'Resolution failed', {
+                identifier: e.name,
+                caller: i ? i?.name || String(i) : 'unknown',
+                error: t
+            });
+            throw new Error(t);
+        }
+        const r = this.injectables.get(e);
+        if (r.isSingleton) {
+            return this.singletonStrategy.resolve(r, t);
+        } else {
+            return this.transientStrategy.resolve(r, t);
         }
-        return this.objects.get(e);
     }
-    addGlobal(e, t) {
-        if (this.globals.has(e)) {
-            throw new Error(`Global value with key '${e}' has already been registered.`);
+    concrete(e) {
+        const t = this.injectables.get(e);
+        if (t) return t.concrete;
+        return;
+    }
+    tagged(...e) {
+        const t = [];
+        for (const i of e){
+            for (const [e, r] of this.injectables){
+                if (r.tags.includes(i)) t.push(r.build());
+            }
+        }
+        return t;
+    }
+    dispose() {
+        for (const [e, t] of this.injectables){
+            t.dispose();
         }
-        this.globals.set(e, t);
     }
-    global(e) {
-        return this.globals.get(e);
+    get size() {
+        return this.injectables.size;
     }
     constructor(){
-        this.objects = new Map();
-        this.globals = new Map();
+        this.injectables = new Map();
+        this.singletonStrategy = new SingletonStrategy();
+        this.transientStrategy = new TransientStrategy();
     }
 }
 
-export { ObjectManager };
+export { InjectableManager };

package/dist/index32.js

@@ -2,70 +2,36 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const core = require('@assemblerjs/core');
-
-class HookManager {
-    prepareInitHook(e, t) {
-        this.initCache.push({
-            instance: e,
-            configuration: t
-        });
-        return this.initCache;
-    }
-    callInitHooks(e) {
-        for (const t of this.initCache){
-            HookManager.callHookImmediate(t.instance, 'onInit', e, t.configuration);
+class ObjectManager {
+    use(e, t) {
+        if (this.has(e)) {
+            throw new Error(`A value is already registered with identifier '${String(e)}'.`);
         }
+        this.objects.set(e, t);
+        return t;
     }
-    callInitedHooks(e) {
-        for (const t of [
-            ...this.initCache
-        ].reverse()){
-            HookManager.callHookImmediate(t.instance, 'onInited', e, t.configuration);
+    has(e) {
+        return this.objects.has(e);
+    }
+    require(e) {
+        if (!this.objects.has(e)) {
+            throw new Error(`Injected object with identifier '${String(e)}' has not been registered.`);
         }
+        return this.objects.get(e);
     }
-    clearCache() {
-        this.initCache.length = 0;
+    addGlobal(e, t) {
+        if (this.globals.has(e)) {
+            throw new Error(`Global value with key '${e}' has already been registered.`);
+        }
+        this.globals.set(e, t);
     }
-    getCache() {
-        return this.initCache;
+    global(e) {
+        return this.globals.get(e);
     }
     constructor(){
-        this.initCache = [];
+        this.objects = new Map();
+        this.globals = new Map();
     }
 }
-HookManager.callHook = (t, i, o, n)=>{
-    return new Promise((a, c)=>{
-        const r = t[i];
-        if (r) {
-            if (core.isAsync(r)) {
-                r.bind(t)(o, n).then(()=>{
-                    a();
-                }).catch((e)=>{
-                    c(e);
-                });
-                return;
-            }
-            try {
-                r.bind(t)(o, n);
-                a();
-            } catch (e) {
-                c(e);
-            }
-        } else {
-            a();
-        }
-    });
-};
-HookManager.callHookImmediate = (t, i, o, n)=>{
-    const a = t[i];
-    if (a) {
-        if (core.isAsync(a)) {
-            a.bind(t)(o, n).catch(()=>{});
-            return;
-        }
-        a.bind(t)(o, n);
-    }
-};
 
-exports.HookManager = HookManager;
+exports.ObjectManager = ObjectManager;