assemblerjs 0.9.6 → 1.0.0

package/dist/index28.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const eventManager = require('./index6.js');
+
+const registerEvents = (t, n)=>{
+    const o = t.concrete.prototype instanceof eventManager.EventManager;
+    if (o) {
+        const e = n;
+        const o = e.channels;
+        for (const n of t.events){
+            if (!o.has(n)) e.addChannels(n);
+            if (!t.privateContext.events.has(n)) t.privateContext.addChannels(n);
+        }
+        for (const e of t.events){
+            n.on(e, (...n)=>{
+                t.privateContext.emit(e, ...n);
+            });
+        }
+    } else {
+        for (const e of t.events){
+            if (!t.privateContext.events.has(e)) t.privateContext.addChannels(e);
+        }
+    }
+};
+const unregisterEvents = (t, n)=>{
+    const o = t.concrete.prototype instanceof eventManager.EventManager;
+    if (o) {
+        const e = n;
+        for (const n of t.events){
+            e.off(n);
+        }
+        e.removeChannels(...t.events);
+        t.privateContext.removeChannels(...t.events);
+    } else {
+        for (const e of t.events){
+            if (t.privateContext.events.has(e)) {
+                t.privateContext.removeChannels(e);
+            }
+        }
+    }
+};
+
+exports.registerEvents = registerEvents;
+exports.unregisterEvents = unregisterEvents;

package/dist/index28.mjs

@@ -0,0 +1,41 @@
+import { EventManager } from './index6.mjs';
+
+const registerEvents = (t, n)=>{
+    const o = t.concrete.prototype instanceof EventManager;
+    if (o) {
+        const e = n;
+        const o = e.channels;
+        for (const n of t.events){
+            if (!o.has(n)) e.addChannels(n);
+            if (!t.privateContext.events.has(n)) t.privateContext.addChannels(n);
+        }
+        for (const e of t.events){
+            n.on(e, (...n)=>{
+                t.privateContext.emit(e, ...n);
+            });
+        }
+    } else {
+        for (const e of t.events){
+            if (!t.privateContext.events.has(e)) t.privateContext.addChannels(e);
+        }
+    }
+};
+const unregisterEvents = (t, n)=>{
+    const o = t.concrete.prototype instanceof EventManager;
+    if (o) {
+        const e = n;
+        for (const n of t.events){
+            e.off(n);
+        }
+        e.removeChannels(...t.events);
+        t.privateContext.removeChannels(...t.events);
+    } else {
+        for (const e of t.events){
+            if (t.privateContext.events.has(e)) {
+                t.privateContext.removeChannels(e);
+            }
+        }
+    }
+};
+
+export { registerEvents, unregisterEvents };

package/dist/index29.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const ReflectParamTypes = 'design:paramtypes';
+const ReflectPrefix = '__';
+const ReflectSuffix = '__';
+exports.ReflectFlags = void 0;
+(function(e) {
+    e["IsAssemblage"] = "is_assemblage";
+})(exports.ReflectFlags || (exports.ReflectFlags = {}));
+exports.ReflectValue = void 0;
+(function(e) {
+    e["AssemblageDefinition"] = "assemblage:definition.value";
+    e["AssemblageContext"] = "assemblage:context.value";
+})(exports.ReflectValue || (exports.ReflectValue = {}));
+
+exports.ReflectParamTypes = ReflectParamTypes;
+exports.ReflectPrefix = ReflectPrefix;
+exports.ReflectSuffix = ReflectSuffix;

package/dist/index29.mjs

@@ -0,0 +1,14 @@
+const ReflectParamTypes = 'design:paramtypes';
+const ReflectPrefix = '__';
+const ReflectSuffix = '__';
+var ReflectFlags;
+(function(e) {
+    e["IsAssemblage"] = "is_assemblage";
+})(ReflectFlags || (ReflectFlags = {}));
+var ReflectValue;
+(function(e) {
+    e["AssemblageDefinition"] = "assemblage:definition.value";
+    e["AssemblageContext"] = "assemblage:context.value";
+})(ReflectValue || (ReflectValue = {}));
+
+export { ReflectFlags, ReflectParamTypes, ReflectPrefix, ReflectSuffix, ReflectValue };

package/dist/index3.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./index29.js');
+const reflection = require('./index30.js');
+
+const isAssemblage = (s)=>{
+    return reflection.getOwnCustomMetadata(constants.ReflectFlags.IsAssemblage, s) || false;
+};
+const getAssemblageDefinition = (e)=>{
+    return reflection.getOwnCustomMetadata(constants.ReflectValue.AssemblageDefinition, e);
+};
+const getAssemblageContext = (e)=>{
+    return reflection.getOwnCustomMetadata(constants.ReflectValue.AssemblageContext, e);
+};
+
+exports.getAssemblageContext = getAssemblageContext;
+exports.getAssemblageDefinition = getAssemblageDefinition;
+exports.isAssemblage = isAssemblage;

package/dist/index3.mjs

@@ -0,0 +1,14 @@
+import { ReflectFlags, ReflectValue } from './index29.mjs';
+import { getOwnCustomMetadata } from './index30.mjs';
+
+const isAssemblage = (s)=>{
+    return getOwnCustomMetadata(ReflectFlags.IsAssemblage, s) || false;
+};
+const getAssemblageDefinition = (e)=>{
+    return getOwnCustomMetadata(ReflectValue.AssemblageDefinition, e);
+};
+const getAssemblageContext = (e)=>{
+    return getOwnCustomMetadata(ReflectValue.AssemblageContext, e);
+};
+
+export { getAssemblageContext, getAssemblageDefinition, isAssemblage };

package/dist/index30.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./index29.js');
+
+const defineCustomMetadata = (t, o, n)=>{
+    Reflect.defineMetadata(`${constants.ReflectPrefix}${t}${constants.ReflectSuffix}`, o, n);
+};
+const getOwnCustomMetadata = (t, o)=>{
+    return Reflect.getOwnMetadata(`${constants.ReflectPrefix}${t}${constants.ReflectSuffix}`, o);
+};
+const getParamTypes = (e)=>{
+    return Reflect.getMetadata(constants.ReflectParamTypes, e) || [];
+};
+
+exports.defineCustomMetadata = defineCustomMetadata;
+exports.getOwnCustomMetadata = getOwnCustomMetadata;
+exports.getParamTypes = getParamTypes;

package/dist/index30.mjs

@@ -0,0 +1,13 @@
+import { ReflectPrefix, ReflectSuffix, ReflectParamTypes } from './index29.mjs';
+
+const defineCustomMetadata = (t, o, n)=>{
+    Reflect.defineMetadata(`${ReflectPrefix}${t}${ReflectSuffix}`, o, n);
+};
+const getOwnCustomMetadata = (t, o)=>{
+    return Reflect.getOwnMetadata(`${ReflectPrefix}${t}${ReflectSuffix}`, o);
+};
+const getParamTypes = (e)=>{
+    return Reflect.getMetadata(ReflectParamTypes, e) || [];
+};
+
+export { defineCustomMetadata, getOwnCustomMetadata, getParamTypes };

package/dist/index31.js

@@ -0,0 +1,100 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./index29.js');
+const reflection = require('./index30.js');
+const helpers = require('./index3.js');
+
+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)=>Array.isArray(r) && r.length == 2),
+        throw: ()=>{
+            throw new Error(`'use' property must be an array of tuples of length 2.`);
+        },
+        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
+    }
+};
+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.`);
+        }
+    }
+    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]);
+    }
+    return e;
+};
+const getDefinition = (e)=>{
+    if (!helpers.isAssemblage(e)) {
+        throw new Error(`Class '${e.name}' is not an assemblage.`);
+    }
+    return reflection.getOwnCustomMetadata(constants.ReflectValue.AssemblageDefinition, e);
+};
+const setDefinitionValue = (t, o, n)=>{
+    const s = getDefinition(n);
+    s[t] = o;
+    const i = validateDefinition(s);
+    reflection.defineCustomMetadata(constants.ReflectValue.AssemblageDefinition, i, n);
+    return i;
+};
+
+exports.getDefinition = getDefinition;
+exports.setDefinitionValue = setDefinitionValue;
+exports.validateDefinition = validateDefinition;

package/dist/index31.mjs

@@ -0,0 +1,94 @@
+import { ReflectValue } from './index29.mjs';
+import { defineCustomMetadata, getOwnCustomMetadata } from './index30.mjs';
+import { isAssemblage } from './index3.mjs';
+
+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)=>Array.isArray(r) && r.length == 2),
+        throw: ()=>{
+            throw new Error(`'use' property must be an array of tuples of length 2.`);
+        },
+        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
+    }
+};
+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.`);
+        }
+    }
+    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]);
+    }
+    return e;
+};
+const getDefinition = (e)=>{
+    if (!isAssemblage(e)) {
+        throw new Error(`Class '${e.name}' is not an assemblage.`);
+    }
+    return getOwnCustomMetadata(ReflectValue.AssemblageDefinition, e);
+};
+const setDefinitionValue = (t, o, n)=>{
+    const s = getDefinition(n);
+    s[t] = o;
+    const i = validateDefinition(s);
+    defineCustomMetadata(ReflectValue.AssemblageDefinition, i, n);
+    return i;
+};
+
+export { getDefinition, setDefinitionValue, validateDefinition };

package/dist/index32.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+class ResolverStore {
+    static register(e, r) {
+        this.resolvers.set(e, r);
+    }
+    static getResolver(e) {
+        const r = this.resolvers.get(e);
+        if (!r) {
+            throw new Error(`No resolver found for decorator type: ${e}`);
+        }
+        return new r();
+    }
+    static hasResolver(e) {
+        return this.resolvers.has(e);
+    }
+    static getRegisteredTypes() {
+        return Array.from(this.resolvers.keys());
+    }
+    static clear() {
+        this.resolvers.clear();
+    }
+}
+ResolverStore.resolvers = new Map();
+
+exports.ResolverStore = ResolverStore;

package/dist/index32.mjs

@@ -0,0 +1,24 @@
+class ResolverStore {
+    static register(e, r) {
+        this.resolvers.set(e, r);
+    }
+    static getResolver(e) {
+        const r = this.resolvers.get(e);
+        if (!r) {
+            throw new Error(`No resolver found for decorator type: ${e}`);
+        }
+        return new r();
+    }
+    static hasResolver(e) {
+        return this.resolvers.has(e);
+    }
+    static getRegisteredTypes() {
+        return Array.from(this.resolvers.keys());
+    }
+    static clear() {
+        this.resolvers.clear();
+    }
+}
+ResolverStore.resolvers = new Map();
+
+export { ResolverStore };

package/dist/index33.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+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.SingletonStrategy = SingletonStrategy;
+exports.TransientStrategy = TransientStrategy;

package/dist/index33.mjs

@@ -0,0 +1,29 @@
+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 { SingletonStrategy, TransientStrategy };

package/dist/index34.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const resolveInstanceInjectionTuple = (e)=>{
+    return {
+        identifier: e[0],
+        concrete: e[0],
+        instance: e[1],
+        configuration: {}
+    };
+};
+
+exports.resolveInstanceInjectionTuple = resolveInstanceInjectionTuple;

package/dist/index34.mjs

@@ -0,0 +1,10 @@
+const resolveInstanceInjectionTuple = (e)=>{
+    return {
+        identifier: e[0],
+        concrete: e[0],
+        instance: e[1],
+        configuration: {}
+    };
+};
+
+export { resolveInstanceInjectionTuple };

package/dist/index35.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@assemblerjs/core');
+
+const i = (e)=>{
+    return {
+        identifier: e[0],
+        concrete: e[0],
+        configuration: {}
+    };
+};
+const c = (o)=>{
+    const i = ()=>core.isClass(o[0]) && core.isClass(o[1]);
+    const c = ()=>core.isClass(o[0]) && core.isObject(o[1]);
+    const s = ()=>core.pipe(core.conditionally({
+            if: ()=>i(),
+            then: ()=>{
+                return {
+                    identifier: o[0],
+                    concrete: o[1],
+                    configuration: {}
+                };
+            }
+        }), core.conditionally({
+            if: ()=>c(),
+            then: ()=>{
+                return {
+                    identifier: o[0],
+                    concrete: o[0],
+                    configuration: o[1]
+                };
+            },
+            else: (e)=>e
+        }))();
+    return s();
+};
+const s = (e)=>{
+    return {
+        identifier: e[0],
+        concrete: e[1],
+        configuration: e[2]
+    };
+};
+const resolveInjectionTuple = (e)=>core.switchCase({
+        1: ()=>i(e),
+        2: ()=>c(e),
+        3: ()=>s(e)
+    }, ()=>{
+        throw new Error(`Injection tuple must be of length 1, 2 or 3.`);
+    })(e.length);
+
+exports.resolveInjectionTuple = resolveInjectionTuple;

package/dist/index35.mjs

@@ -0,0 +1,50 @@
+import { switchCase, pipe, conditionally, isClass, isObject } from '@assemblerjs/core';
+
+const i = (e)=>{
+    return {
+        identifier: e[0],
+        concrete: e[0],
+        configuration: {}
+    };
+};
+const c = (o)=>{
+    const i = ()=>isClass(o[0]) && isClass(o[1]);
+    const c = ()=>isClass(o[0]) && isObject(o[1]);
+    const s = ()=>pipe(conditionally({
+            if: ()=>i(),
+            then: ()=>{
+                return {
+                    identifier: o[0],
+                    concrete: o[1],
+                    configuration: {}
+                };
+            }
+        }), conditionally({
+            if: ()=>c(),
+            then: ()=>{
+                return {
+                    identifier: o[0],
+                    concrete: o[0],
+                    configuration: o[1]
+                };
+            },
+            else: (e)=>e
+        }))();
+    return s();
+};
+const s = (e)=>{
+    return {
+        identifier: e[0],
+        concrete: e[1],
+        configuration: e[2]
+    };
+};
+const resolveInjectionTuple = (e)=>switchCase({
+        1: ()=>i(e),
+        2: ()=>c(e),
+        3: ()=>s(e)
+    }, ()=>{
+        throw new Error(`Injection tuple must be of length 1, 2 or 3.`);
+    })(e.length);
+
+export { resolveInjectionTuple };