assemblerjs 0.9.7 → 1.0.0

package/dist/index10.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+class AbstractEventManager {
+}
+
+exports.AbstractEventManager = AbstractEventManager;

package/dist/index10.mjs

@@ -0,0 +1,4 @@
+class AbstractEventManager {
+}
+
+export { AbstractEventManager };

package/dist/index11.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Await = (t, e = 25)=>{
+    return (n, s, a)=>{
+        const i = a.value;
+        a.value = async function() {
+            return new Promise((n)=>{
+                if (this[t]) {
+                    i.apply(this);
+                    n();
+                } else {
+                    const s = setInterval(()=>{
+                        if (this[t]) {
+                            clearInterval(s);
+                            i.apply(this);
+                            n();
+                        }
+                    }, e);
+                }
+            });
+        };
+    };
+};
+
+exports.Await = Await;

package/dist/index11.mjs

@@ -0,0 +1,23 @@
+const Await = (t, e = 25)=>{
+    return (n, s, a)=>{
+        const i = a.value;
+        a.value = async function() {
+            return new Promise((n)=>{
+                if (this[t]) {
+                    i.apply(this);
+                    n();
+                } else {
+                    const s = setInterval(()=>{
+                        if (this[t]) {
+                            clearInterval(s);
+                            i.apply(this);
+                            n();
+                        }
+                    }, e);
+                }
+            });
+        };
+    };
+};
+
+export { Await };

package/dist/index12.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const reflection = require('./index30.js');
+
+const t = (t)=>()=>{
+        return (e, c, n)=>{
+            const a = reflection.getOwnCustomMetadata(t, e) || [];
+            a.push(n);
+            reflection.defineCustomMetadata(t, a, e);
+        };
+    };
+const createParamIndexDecorator = t;
+
+exports.createParamIndexDecorator = createParamIndexDecorator;

package/dist/index12.mjs

@@ -0,0 +1,12 @@
+import { getOwnCustomMetadata, defineCustomMetadata } from './index30.mjs';
+
+const t = (t)=>()=>{
+        return (e, c, n)=>{
+            const a = getOwnCustomMetadata(t, e) || [];
+            a.push(n);
+            defineCustomMetadata(t, a, e);
+        };
+    };
+const createParamIndexDecorator = t;
+
+export { createParamIndexDecorator };

package/dist/index13.js

@@ -0,0 +1,94 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const reflection = require('./index30.js');
+
+class ParameterDecoratorFactory {
+    static create(e) {
+        const { name: r, valueType: t = 'single', handler: a } = e;
+        if (this.registeredDecorators.has(r)) {
+            throw new Error(`Decorator ${r} already exists`);
+        }
+        const s = `assemblage:${r.toLowerCase()}.param.index`;
+        const o = `assemblage:${r.toLowerCase()}.param.value`;
+        const c = this.createDecoratorFunction(s, o, t);
+        this.registeredDecorators.set(r, {
+            name: r,
+            valueType: t,
+            handler: a
+        });
+        return c;
+    }
+    static createDecoratorFunction(e, r, t) {
+        return (a)=>{
+            return (s, o, c)=>{
+                this.storeParameterData(a, s, c, e, r, t);
+            };
+        };
+    }
+    static validateSingleDecoratorPerParameter(r, t, a) {
+        for (const s of this.registeredDecorators.keys()){
+            const o = `assemblage:${s.toLowerCase()}.param.index`;
+            if (o === a) {
+                continue;
+            }
+            const c = reflection.getOwnCustomMetadata(o, r) || [];
+            if (c.includes(t)) {
+                throw new Error(`Parameter at index ${t} already has decorator @${s}. ` + `Multiple decorators per parameter are not allowed.`);
+            }
+        }
+    }
+    static storeParameterData(t, a, s, o, c, i) {
+        this.validateSingleDecoratorPerParameter(a, s, o);
+        const n = reflection.getOwnCustomMetadata(o, a) || [];
+        n.push(s);
+        reflection.defineCustomMetadata(o, n, a);
+        switch(i){
+            case 'single':
+                {
+                    reflection.defineCustomMetadata(c, t, a);
+                    break;
+                }
+            case 'array':
+                {
+                    const o = reflection.getOwnCustomMetadata(c, a) || [];
+                    o[s] = t;
+                    reflection.defineCustomMetadata(c, o, a);
+                    break;
+                }
+            case 'map':
+                {
+                    const o = reflection.getOwnCustomMetadata(c, a) || {};
+                    o[s] = t;
+                    reflection.defineCustomMetadata(c, o, a);
+                    break;
+                }
+        }
+    }
+    static createParameterIndexGetter(r) {
+        return (t)=>{
+            return reflection.getOwnCustomMetadata(r, t) || [];
+        };
+    }
+    static createParameterValueGetter(r, t) {
+        return (t)=>{
+            return reflection.getOwnCustomMetadata(r, t);
+        };
+    }
+    static getRegisteredDecorators() {
+        return Array.from(this.registeredDecorators.keys());
+    }
+    static isRegistered(e) {
+        return this.registeredDecorators.has(e);
+    }
+    static getDecoratorMetadata(e) {
+        return this.registeredDecorators.get(e);
+    }
+    static getDecoratorHandler(e) {
+        return this.registeredDecorators.get(e)?.handler;
+    }
+}
+ParameterDecoratorFactory.registeredDecorators = new Map();
+
+exports.ParameterDecoratorFactory = ParameterDecoratorFactory;

package/dist/index13.mjs

@@ -0,0 +1,90 @@
+import { getOwnCustomMetadata, defineCustomMetadata } from './index30.mjs';
+
+class ParameterDecoratorFactory {
+    static create(e) {
+        const { name: r, valueType: t = 'single', handler: a } = e;
+        if (this.registeredDecorators.has(r)) {
+            throw new Error(`Decorator ${r} already exists`);
+        }
+        const s = `assemblage:${r.toLowerCase()}.param.index`;
+        const o = `assemblage:${r.toLowerCase()}.param.value`;
+        const c = this.createDecoratorFunction(s, o, t);
+        this.registeredDecorators.set(r, {
+            name: r,
+            valueType: t,
+            handler: a
+        });
+        return c;
+    }
+    static createDecoratorFunction(e, r, t) {
+        return (a)=>{
+            return (s, o, c)=>{
+                this.storeParameterData(a, s, c, e, r, t);
+            };
+        };
+    }
+    static validateSingleDecoratorPerParameter(r, t, a) {
+        for (const s of this.registeredDecorators.keys()){
+            const o = `assemblage:${s.toLowerCase()}.param.index`;
+            if (o === a) {
+                continue;
+            }
+            const c = getOwnCustomMetadata(o, r) || [];
+            if (c.includes(t)) {
+                throw new Error(`Parameter at index ${t} already has decorator @${s}. ` + `Multiple decorators per parameter are not allowed.`);
+            }
+        }
+    }
+    static storeParameterData(t, a, s, o, c, i) {
+        this.validateSingleDecoratorPerParameter(a, s, o);
+        const n = getOwnCustomMetadata(o, a) || [];
+        n.push(s);
+        defineCustomMetadata(o, n, a);
+        switch(i){
+            case 'single':
+                {
+                    defineCustomMetadata(c, t, a);
+                    break;
+                }
+            case 'array':
+                {
+                    const o = getOwnCustomMetadata(c, a) || [];
+                    o[s] = t;
+                    defineCustomMetadata(c, o, a);
+                    break;
+                }
+            case 'map':
+                {
+                    const o = getOwnCustomMetadata(c, a) || {};
+                    o[s] = t;
+                    defineCustomMetadata(c, o, a);
+                    break;
+                }
+        }
+    }
+    static createParameterIndexGetter(r) {
+        return (t)=>{
+            return getOwnCustomMetadata(r, t) || [];
+        };
+    }
+    static createParameterValueGetter(r, t) {
+        return (t)=>{
+            return getOwnCustomMetadata(r, t);
+        };
+    }
+    static getRegisteredDecorators() {
+        return Array.from(this.registeredDecorators.keys());
+    }
+    static isRegistered(e) {
+        return this.registeredDecorators.has(e);
+    }
+    static getDecoratorMetadata(e) {
+        return this.registeredDecorators.get(e);
+    }
+    static getDecoratorHandler(e) {
+        return this.registeredDecorators.get(e)?.handler;
+    }
+}
+ParameterDecoratorFactory.registeredDecorators = new Map();
+
+export { ParameterDecoratorFactory };

package/dist/index14.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const parameterDecoratorFactory = require('./index13.js');
+const resolverStore = require('./index32.js');
+
+let ContextResolver = class ContextResolver {
+    resolve(e, r, t) {
+        return r.publicContext;
+    }
+};
+const Context = (()=>{
+    resolverStore.ResolverStore.register('Context', ContextResolver);
+    return parameterDecoratorFactory.ParameterDecoratorFactory.create({
+        name: 'Context',
+        valueType: 'array',
+        resolver: ContextResolver
+    });
+})();
+
+exports.Context = Context;

package/dist/index14.mjs

@@ -0,0 +1,18 @@
+import { ParameterDecoratorFactory } from './index13.mjs';
+import { ResolverStore } from './index32.mjs';
+
+let ContextResolver = class ContextResolver {
+    resolve(e, r, t) {
+        return r.publicContext;
+    }
+};
+const Context = (()=>{
+    ResolverStore.register('Context', ContextResolver);
+    return ParameterDecoratorFactory.create({
+        name: 'Context',
+        valueType: 'array',
+        resolver: ContextResolver
+    });
+})();
+
+export { Context };

package/dist/index15.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const parameterDecoratorFactory = require('./index13.js');
+const resolverStore = require('./index32.js');
+
+let ConfigurationResolver = class ConfigurationResolver {
+    resolve(r, o, e, n) {
+        return n || o.configuration;
+    }
+};
+const Configuration = (()=>{
+    resolverStore.ResolverStore.register('Configuration', ConfigurationResolver);
+    return parameterDecoratorFactory.ParameterDecoratorFactory.create({
+        name: 'Configuration',
+        valueType: 'array',
+        resolver: ConfigurationResolver
+    });
+})();
+
+exports.Configuration = Configuration;

package/dist/index15.mjs

@@ -0,0 +1,18 @@
+import { ParameterDecoratorFactory } from './index13.mjs';
+import { ResolverStore } from './index32.mjs';
+
+let ConfigurationResolver = class ConfigurationResolver {
+    resolve(r, o, e, n) {
+        return n || o.configuration;
+    }
+};
+const Configuration = (()=>{
+    ResolverStore.register('Configuration', ConfigurationResolver);
+    return ParameterDecoratorFactory.create({
+        name: 'Configuration',
+        valueType: 'array',
+        resolver: ConfigurationResolver
+    });
+})();
+
+export { Configuration };

package/dist/index16.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const parameterDecoratorFactory = require('./index13.js');
+const resolverStore = require('./index32.js');
+
+let DefinitionResolver = class DefinitionResolver {
+    resolve(e, r) {
+        return r.definition;
+    }
+};
+const Definition = (()=>{
+    resolverStore.ResolverStore.register('Definition', DefinitionResolver);
+    return parameterDecoratorFactory.ParameterDecoratorFactory.create({
+        name: 'Definition',
+        valueType: 'array',
+        resolver: DefinitionResolver
+    });
+})();
+
+exports.Definition = Definition;

package/dist/index16.mjs

@@ -0,0 +1,18 @@
+import { ParameterDecoratorFactory } from './index13.mjs';
+import { ResolverStore } from './index32.mjs';
+
+let DefinitionResolver = class DefinitionResolver {
+    resolve(e, r) {
+        return r.definition;
+    }
+};
+const Definition = (()=>{
+    ResolverStore.register('Definition', DefinitionResolver);
+    return ParameterDecoratorFactory.create({
+        name: 'Definition',
+        valueType: 'array',
+        resolver: DefinitionResolver
+    });
+})();
+
+export { Definition };

package/dist/index17.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const parameterDecoratorFactory = require('./index13.js');
+const resolverStore = require('./index32.js');
+
+let DisposeResolver = class DisposeResolver {
+    resolve(e, r, s) {
+        return r.privateContext.dispose;
+    }
+};
+const Dispose = (()=>{
+    resolverStore.ResolverStore.register('Dispose', DisposeResolver);
+    return parameterDecoratorFactory.ParameterDecoratorFactory.create({
+        name: 'Dispose',
+        valueType: 'array',
+        resolver: DisposeResolver
+    });
+})();
+
+exports.Dispose = Dispose;

package/dist/index17.mjs

@@ -0,0 +1,18 @@
+import { ParameterDecoratorFactory } from './index13.mjs';
+import { ResolverStore } from './index32.mjs';
+
+let DisposeResolver = class DisposeResolver {
+    resolve(e, r, s) {
+        return r.privateContext.dispose;
+    }
+};
+const Dispose = (()=>{
+    ResolverStore.register('Dispose', DisposeResolver);
+    return ParameterDecoratorFactory.create({
+        name: 'Dispose',
+        valueType: 'array',
+        resolver: DisposeResolver
+    });
+})();
+
+export { Dispose };

package/dist/index18.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const reflection = require('./index30.js');
+const parameterDecoratorFactory = require('./index13.js');
+const helpers = require('./index21.js');
+const resolverStore = require('./index32.js');
+
+let UseResolver = class UseResolver {
+    resolve(r, o, t) {
+        const a = reflection.getOwnCustomMetadata(helpers.getParamValueKey('Use'), t);
+        const m = a[r];
+        return o.privateContext.require(m);
+    }
+};
+const decorateUse = (e, r, o)=>{
+    Use(e)(r, undefined, o);
+};
+const Use = (()=>{
+    resolverStore.ResolverStore.register('Use', UseResolver);
+    return parameterDecoratorFactory.ParameterDecoratorFactory.create({
+        name: 'Use',
+        valueType: 'map',
+        resolver: UseResolver,
+        handler: decorateUse
+    });
+})();
+
+exports.Use = Use;
+exports.decorateUse = decorateUse;

package/dist/index18.mjs

@@ -0,0 +1,26 @@
+import { getOwnCustomMetadata } from './index30.mjs';
+import { ParameterDecoratorFactory } from './index13.mjs';
+import { getParamValueKey } from './index21.mjs';
+import { ResolverStore } from './index32.mjs';
+
+let UseResolver = class UseResolver {
+    resolve(r, o, t) {
+        const a = getOwnCustomMetadata(getParamValueKey('Use'), t);
+        const m = a[r];
+        return o.privateContext.require(m);
+    }
+};
+const decorateUse = (e, r, o)=>{
+    Use(e)(r, undefined, o);
+};
+const Use = (()=>{
+    ResolverStore.register('Use', UseResolver);
+    return ParameterDecoratorFactory.create({
+        name: 'Use',
+        valueType: 'map',
+        resolver: UseResolver,
+        handler: decorateUse
+    });
+})();
+
+export { Use, decorateUse };

package/dist/index19.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const reflection = require('./index30.js');
+const parameterDecoratorFactory = require('./index13.js');
+const helpers = require('./index21.js');
+const resolverStore = require('./index32.js');
+
+let GlobalResolver = class GlobalResolver {
+    resolve(e, r, a) {
+        const t = reflection.getOwnCustomMetadata(helpers.getParamValueKey('Global'), a);
+        const s = t[e];
+        return r.privateContext.global(s);
+    }
+};
+const decorateGlobal = (o, e, r)=>{
+    Global(o)(e, undefined, r);
+};
+const Global = (()=>{
+    resolverStore.ResolverStore.register('Global', GlobalResolver);
+    return parameterDecoratorFactory.ParameterDecoratorFactory.create({
+        name: 'Global',
+        valueType: 'map',
+        resolver: GlobalResolver,
+        handler: decorateGlobal
+    });
+})();
+
+exports.Global = Global;
+exports.decorateGlobal = decorateGlobal;

package/dist/index19.mjs

@@ -0,0 +1,26 @@
+import { getOwnCustomMetadata } from './index30.mjs';
+import { ParameterDecoratorFactory } from './index13.mjs';
+import { getParamValueKey } from './index21.mjs';
+import { ResolverStore } from './index32.mjs';
+
+let GlobalResolver = class GlobalResolver {
+    resolve(e, r, a) {
+        const t = getOwnCustomMetadata(getParamValueKey('Global'), a);
+        const s = t[e];
+        return r.privateContext.global(s);
+    }
+};
+const decorateGlobal = (o, e, r)=>{
+    Global(o)(e, undefined, r);
+};
+const Global = (()=>{
+    ResolverStore.register('Global', GlobalResolver);
+    return ParameterDecoratorFactory.create({
+        name: 'Global',
+        valueType: 'map',
+        resolver: GlobalResolver,
+        handler: decorateGlobal
+    });
+})();
+
+export { Global, decorateGlobal };

package/dist/index2.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./index29.js');
+const reflection = require('./index30.js');
+const schema = require('./index31.js');
+
+const Assemblage = (e)=>{
+    return (r)=>{
+        return decorateAssemblage(r, e);
+    };
+};
+const decorateAssemblage = (t, m)=>{
+    const n = schema.validateDefinition(m || {});
+    reflection.defineCustomMetadata(constants.ReflectFlags.IsAssemblage, true, t);
+    reflection.defineCustomMetadata(constants.ReflectValue.AssemblageDefinition, n, t);
+    return t;
+};
+
+exports.Assemblage = Assemblage;
+exports.decorateAssemblage = decorateAssemblage;

package/dist/index2.mjs

@@ -0,0 +1,17 @@
+import { ReflectFlags, ReflectValue } from './index29.mjs';
+import { defineCustomMetadata } from './index30.mjs';
+import { validateDefinition } from './index31.mjs';
+
+const Assemblage = (e)=>{
+    return (r)=>{
+        return decorateAssemblage(r, e);
+    };
+};
+const decorateAssemblage = (t, m)=>{
+    const n = validateDefinition(m || {});
+    defineCustomMetadata(ReflectFlags.IsAssemblage, true, t);
+    defineCustomMetadata(ReflectValue.AssemblageDefinition, n, t);
+    return t;
+};
+
+export { Assemblage, decorateAssemblage };

package/dist/index20.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const reflection = require('./index30.js');
+const parameterDecoratorFactory = require('./index13.js');
+const helpers = require('./index21.js');
+const resolverStore = require('./index32.js');
+
+let OptionalResolver = class OptionalResolver {
+    resolve(o, t, n) {
+        try {
+            const r = reflection.getParamTypes(n);
+            const a = r[o];
+            return t.privateContext.require(a);
+        } catch  {
+            const e = reflection.getOwnCustomMetadata(helpers.getParamValueKey('Optional'), n);
+            return e?.[o];
+        }
+    }
+};
+const Optional = (()=>{
+    resolverStore.ResolverStore.register('Optional', OptionalResolver);
+    return parameterDecoratorFactory.ParameterDecoratorFactory.create({
+        name: 'Optional',
+        valueType: 'map',
+        resolver: OptionalResolver
+    });
+})();
+
+exports.Optional = Optional;

package/dist/index20.mjs

@@ -0,0 +1,27 @@
+import { getParamTypes, getOwnCustomMetadata } from './index30.mjs';
+import { ParameterDecoratorFactory } from './index13.mjs';
+import { getParamValueKey } from './index21.mjs';
+import { ResolverStore } from './index32.mjs';
+
+let OptionalResolver = class OptionalResolver {
+    resolve(o, t, n) {
+        try {
+            const r = getParamTypes(n);
+            const a = r[o];
+            return t.privateContext.require(a);
+        } catch  {
+            const e = getOwnCustomMetadata(getParamValueKey('Optional'), n);
+            return e?.[o];
+        }
+    }
+};
+const Optional = (()=>{
+    ResolverStore.register('Optional', OptionalResolver);
+    return ParameterDecoratorFactory.create({
+        name: 'Optional',
+        valueType: 'map',
+        resolver: OptionalResolver
+    });
+})();
+
+export { Optional };