@decohere/crucible 0.0.1-dev.39 → 0.0.1-dev.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/crucible",
-  "version": "0.0.1-dev.39",
+  "version": "0.0.1-dev.4",
   "description": "Lightweight dependency injection container with decorator-based wiring",
   "keywords": [
     "typescript",
@@ -30,8 +30,8 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/nexus": "0.0.1-dev.39",
-    "@decohere/scribe": "0.0.1-dev.39"
+    "@decohere/nexus": "0.0.1-dev.4",
+    "@decohere/scribe": "0.0.1-dev.4"
   },
   "devDependencies": {}
 }

package/{es6/src → src}/decorators/inject.decorator.js

@@ -1,4 +1,4 @@
-import { defineMeta, getMeta } from "@decohere/nexus/reflection";
+import { defineMeta, getMeta } from "../../../nexus/src/reflection/index.js";
 import { CrucibleMeta } from "../const.js";
 export function inject(key) {
     return (target, _propertyKey, idx)=>{
@@ -14,4 +14,4 @@ function getExistingMeta(target) {
     return meta;
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9kZWNvcmF0b3JzL2luamVjdC5kZWNvcmF0b3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZGVmaW5lTWV0YSwgZ2V0TWV0YSB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvcmVmbGVjdGlvblwiO1xuaW1wb3J0IHsgQ3J1Y2libGVNZXRhIH0gZnJvbSBcIi4uL2NvbnN0LmpzXCI7XG5cbmV4cG9ydCB0eXBlIEluamVjdGlvbk1ldGFkYXRhID0gTWFwPG51bWJlciwgSW5qZWN0aW9uVG9rZW4+O1xuXG5leHBvcnQgdHlwZSBJbmplY3Rpb25Ub2tlbiA9IHtcblx0a2V5OiBzdHJpbmcgfCBzeW1ib2w7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0KGtleTogc3RyaW5nIHwgc3ltYm9sKSB7XG5cdHJldHVybiAodGFyZ2V0OiBvYmplY3QsIF9wcm9wZXJ0eUtleTogc3RyaW5nIHwgc3ltYm9sIHwgdW5kZWZpbmVkLCBpZHg6IG51bWJlcikgPT4ge1xuXHRcdGNvbnN0IG1ldGFkYXRhID0gZ2V0RXhpc3RpbmdNZXRhKHRhcmdldCk7XG5cdFx0bWV0YWRhdGEuc2V0KGlkeCwgeyBrZXkgfSk7XG5cdFx0ZGVmaW5lTWV0YShDcnVjaWJsZU1ldGEuaW5qZWN0dG9rZW4sIG1ldGFkYXRhLCB0YXJnZXQpO1xuXHR9O1xufVxuXG5mdW5jdGlvbiBnZXRFeGlzdGluZ01ldGEodGFyZ2V0OiBvYmplY3QpIHtcblx0Y29uc3QgbWV0YSA9XG5cdFx0Z2V0TWV0YTxNYXA8bnVtYmVyLCBJbmplY3Rpb25Ub2tlbj4+KENydWNpYmxlTWV0YS5pbmplY3R0b2tlbiwgdGFyZ2V0KSA/P1xuXHRcdG5ldyBNYXA8bnVtYmVyLCBJbmplY3Rpb25Ub2tlbj4oKTtcblx0cmV0dXJuIG1ldGE7XG59XG4iXSwibmFtZXMiOlsiZGVmaW5lTWV0YSIsImdldE1ldGEiLCJDcnVjaWJsZU1ldGEiLCJpbmplY3QiLCJrZXkiLCJ0YXJnZXQiLCJfcHJvcGVydHlLZXkiLCJpZHgiLCJtZXRhZGF0YSIsImdldEV4aXN0aW5nTWV0YSIsInNldCIsImluamVjdHRva2VuIiwibWV0YSIsIk1hcCJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsVUFBVSxFQUFFQyxPQUFPLFFBQVEsNkJBQTZCO0FBQ2pFLFNBQVNDLFlBQVksUUFBUSxjQUFjO0FBUTNDLE9BQU8sU0FBU0MsT0FBT0MsR0FBb0I7SUFDMUMsT0FBTyxDQUFDQyxRQUFnQkMsY0FBMkNDO1FBQ2xFLE1BQU1DLFdBQVdDLGdCQUFnQko7UUFDakNHLFNBQVNFLEdBQUcsQ0FBQ0gsS0FBSztZQUFFSDtRQUFJO1FBQ3hCSixXQUFXRSxhQUFhUyxXQUFXLEVBQUVILFVBQVVIO0lBQ2hEO0FBQ0Q7QUFFQSxTQUFTSSxnQkFBZ0JKLE1BQWM7SUFDdEMsTUFBTU8sT0FDTFgsUUFBcUNDLGFBQWFTLFdBQVcsRUFBRU4sV0FDL0QsSUFBSVE7SUFDTCxPQUFPRDtBQUNSIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9kZWNvcmF0b3JzL2luamVjdC5kZWNvcmF0b3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZGVmaW5lTWV0YSwgZ2V0TWV0YSB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvcmVmbGVjdGlvblwiO1xuaW1wb3J0IHsgQ3J1Y2libGVNZXRhIH0gZnJvbSBcIi4uL2NvbnN0LmpzXCI7XG5cbmV4cG9ydCB0eXBlIEluamVjdGlvbk1ldGFkYXRhID0gTWFwPG51bWJlciwgSW5qZWN0aW9uVG9rZW4+O1xuXG5leHBvcnQgdHlwZSBJbmplY3Rpb25Ub2tlbiA9IHtcblx0a2V5OiBzdHJpbmcgfCBzeW1ib2w7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0KGtleTogc3RyaW5nIHwgc3ltYm9sKSB7XG5cdHJldHVybiAodGFyZ2V0OiBvYmplY3QsIF9wcm9wZXJ0eUtleTogc3RyaW5nIHwgc3ltYm9sIHwgdW5kZWZpbmVkLCBpZHg6IG51bWJlcikgPT4ge1xuXHRcdGNvbnN0IG1ldGFkYXRhID0gZ2V0RXhpc3RpbmdNZXRhKHRhcmdldCk7XG5cdFx0bWV0YWRhdGEuc2V0KGlkeCwgeyBrZXkgfSk7XG5cdFx0ZGVmaW5lTWV0YShDcnVjaWJsZU1ldGEuaW5qZWN0dG9rZW4sIG1ldGFkYXRhLCB0YXJnZXQpO1xuXHR9O1xufVxuXG5mdW5jdGlvbiBnZXRFeGlzdGluZ01ldGEodGFyZ2V0OiBvYmplY3QpIHtcblx0Y29uc3QgbWV0YSA9XG5cdFx0Z2V0TWV0YTxNYXA8bnVtYmVyLCBJbmplY3Rpb25Ub2tlbj4+KENydWNpYmxlTWV0YS5pbmplY3R0b2tlbiwgdGFyZ2V0KSA/P1xuXHRcdG5ldyBNYXA8bnVtYmVyLCBJbmplY3Rpb25Ub2tlbj4oKTtcblx0cmV0dXJuIG1ldGE7XG59XG4iXSwibmFtZXMiOlsiZGVmaW5lTWV0YSIsImdldE1ldGEiLCJDcnVjaWJsZU1ldGEiLCJpbmplY3QiLCJrZXkiLCJ0YXJnZXQiLCJfcHJvcGVydHlLZXkiLCJpZHgiLCJtZXRhZGF0YSIsImdldEV4aXN0aW5nTWV0YSIsInNldCIsImluamVjdHRva2VuIiwibWV0YSIsIk1hcCJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsVUFBVSxFQUFFQyxPQUFPLFFBQVEseUNBQTZCO0FBQ2pFLFNBQVNDLFlBQVksUUFBUSxjQUFjO0FBUTNDLE9BQU8sU0FBU0MsT0FBT0MsR0FBb0I7SUFDMUMsT0FBTyxDQUFDQyxRQUFnQkMsY0FBMkNDO1FBQ2xFLE1BQU1DLFdBQVdDLGdCQUFnQko7UUFDakNHLFNBQVNFLEdBQUcsQ0FBQ0gsS0FBSztZQUFFSDtRQUFJO1FBQ3hCSixXQUFXRSxhQUFhUyxXQUFXLEVBQUVILFVBQVVIO0lBQ2hEO0FBQ0Q7QUFFQSxTQUFTSSxnQkFBZ0JKLE1BQWM7SUFDdEMsTUFBTU8sT0FDTFgsUUFBcUNDLGFBQWFTLFdBQVcsRUFBRU4sV0FDL0QsSUFBSVE7SUFDTCxPQUFPRDtBQUNSIn0=

package/src/services/crucible.js

@@ -0,0 +1,133 @@
+import { getMeta, isArrayType, isConstructable, ReflectionMeta } from "../../../nexus/src/reflection/index.js";
+import { scribe } from "../../../scribe/scribe/src/index.js";
+import { CrucibleMeta, LifetimeScopeToken, Scopes } from "../const.js";
+import { RegistrationKey } from "../models/registration-key.model.js";
+import { DuplicateScopeError, ResolveError } from "../types/errors.js";
+import { ServiceRegistry } from "./service-registry.js";
+export class Crucible {
+    key;
+    instances = new Map();
+    serviceRegistry;
+    rootScope;
+    scopes = new Map();
+    logger = scribe.logger(Crucible.name);
+    isDisposed = false;
+    constructor(options){
+        this.key = options?.key;
+        this.serviceRegistry = new ServiceRegistry(options?.serviceRegistry);
+        this.registerLifetimeScope();
+        this.rootScope = options?.rootScope ?? this;
+    }
+    resolveMany(resolveRequest) {
+        const key = new RegistrationKey(resolveRequest);
+        const registrations = this.getRegistrationFrom(key) ?? [];
+        const services = Array.of();
+        for (const registration of registrations){
+            const service = this.resolveRegistration(registration);
+            services.push(service);
+        }
+        return services;
+    }
+    resolve(resolveRequest) {
+        const key = new RegistrationKey(resolveRequest);
+        const registration = this.getRegistrationFrom(key);
+        if (registration == null) {
+            this.logger.warn(`Cannot resolve dependency ${key.toString()}`);
+            return null;
+        }
+        if (registration.length > 1) {
+            throw new ResolveError(`There are multiple services registered with key ${key.toString()}. Use resolveMany to resolve all implementations.`);
+        }
+        const service = this.resolveRegistration(registration[0]);
+        return service;
+    }
+    beginScope(name) {
+        if (this.scopes.has(name)) {
+            throw new DuplicateScopeError(`Cannot create duplicate scope. Scope with ${name} is already created and has not been disposed.`);
+        }
+        const scope = new Crucible({
+            key: name,
+            serviceRegistry: this.serviceRegistry,
+            rootScope: this
+        });
+        this.scopes.set(name, scope);
+        return scope;
+    }
+    [Symbol.dispose]() {
+        if (this.isDisposed) {
+            return;
+        }
+        this.dispose();
+    }
+    dispose() {
+        if (this.isDisposed) {
+            return;
+        }
+        this.isDisposed = true;
+        for (const [, inst] of this.instances){
+            if (inst === this) {
+                continue;
+            }
+            inst[Symbol.dispose]?.();
+        }
+    }
+    getRegistrationFrom(key) {
+        const registration = this.serviceRegistry.getRegistration(key.value);
+        return registration;
+    }
+    resolveRegistration(registration) {
+        const { scope } = registration;
+        switch(scope){
+            case Scopes.transient:
+                return this.createInstance(registration);
+            case Scopes.singleton:
+                return this.rootScope.getOrCreateInstance(registration);
+            case Scopes.request:
+                return this.getOrCreateInstance(registration);
+        }
+    }
+    getOrCreateInstance(registration) {
+        if (this.isDisposed) {
+            throw new Error("This continer has been disposed");
+        }
+        const { key, type, isInstance } = registration;
+        const cacheKey = isInstance ? key.value : type;
+        const existingInstance = this.instances.get(cacheKey);
+        if (existingInstance != null) {
+            return existingInstance;
+        }
+        const instance = isInstance ? type : this.createInstance(registration);
+        this.instances.set(cacheKey, instance);
+        return instance;
+    }
+    createInstance(registration) {
+        const type = registration.type;
+        const canConstruct = isConstructable(type);
+        const deps = this.resolveDependencies(type);
+        const inst = canConstruct ? new type(...deps) : type();
+        return inst;
+    }
+    resolveDependencies(type) {
+        const params = getMeta(ReflectionMeta.paramtypes, type) ?? [];
+        const injectTokens = getMeta(CrucibleMeta.injecttoken, type) ?? new Map();
+        //TODO: put a try catch here so we can throw the name of the service
+        let resolved = [];
+        for(let i = 0; i < params.length; i++){
+            const token = injectTokens.get(i)?.key ?? params[i].name;
+            const dep = isArrayType(params[i]) ? this.resolveMany(token) : this.resolve(token);
+            resolved = [
+                ...resolved,
+                dep
+            ];
+        }
+        return resolved;
+    }
+    registerLifetimeScope() {
+        this.serviceRegistry.registerType(Scopes.request, {
+            typeOrKey: LifetimeScopeToken,
+            typeOrInstance: this
+        });
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/crucible/src/services/crucible.ts"],"sourcesContent":["import {\n\ttype Constructable,\n\ttype FunctionType,\n\tgetMeta,\n\tisArrayType,\n\tisConstructable,\n\tReflectionMeta,\n} from \"@decohere/nexus/reflection\";\nimport { scribe } from \"@decohere/scribe\";\nimport { CrucibleMeta, LifetimeScopeToken, Scopes } from \"../const.js\";\nimport type { InjectionMetadata } from \"../decorators/inject.decorator.js\";\nimport { RegistrationKey } from \"../models/registration-key.model.js\";\nimport type { ServiceRegistration } from \"../models/service-registration.model.js\";\nimport { DuplicateScopeError, ResolveError } from \"../types/errors.js\";\nimport type { IContainer, LifetimeScope, ResolveRequest } from \"../types/types.js\";\nimport { ServiceRegistry } from \"./service-registry.js\";\n\ntype CrucibleOptions = {\n\tkey?: string;\n\trootScope?: Crucible;\n\tserviceRegistry: ServiceRegistry;\n};\n\nexport class Crucible implements IContainer {\n\tpublic key: string;\n\tprotected instances = new Map<unknown, object>();\n\tprivate serviceRegistry: ServiceRegistry;\n\tprivate rootScope: Crucible;\n\tprivate scopes = new Map<string, LifetimeScope>();\n\tprivate logger = scribe.logger(Crucible.name);\n\tprivate isDisposed = false;\n\tpublic constructor(options?: CrucibleOptions) {\n\t\tthis.key = options?.key;\n\t\tthis.serviceRegistry = new ServiceRegistry(options?.serviceRegistry);\n\t\tthis.registerLifetimeScope();\n\t\tthis.rootScope = options?.rootScope ?? this;\n\t}\n\n\tpublic resolveMany<T extends object = object>(resolveRequest: ResolveRequest<T>): T[] {\n\t\tconst key = new RegistrationKey(resolveRequest);\n\t\tconst registrations = this.getRegistrationFrom(key) ?? [];\n\n\t\tconst services = Array.of<T>();\n\t\tfor (const registration of registrations) {\n\t\t\tconst service = this.resolveRegistration<T>(registration);\n\t\t\tservices.push(service);\n\t\t}\n\t\treturn services;\n\t}\n\n\tpublic resolve<T extends object | object[]>(resolveRequest: ResolveRequest<T>): T {\n\t\tconst key = new RegistrationKey(resolveRequest);\n\t\tconst registration = this.getRegistrationFrom(key);\n\t\tif (registration == null) {\n\t\t\tthis.logger.warn(`Cannot resolve dependency ${key.toString()}`);\n\t\t\treturn null;\n\t\t}\n\n\t\tif (registration.length > 1) {\n\t\t\tthrow new ResolveError(\n\t\t\t\t`There are multiple services registered with key ${key.toString()}. Use resolveMany to resolve all implementations.`,\n\t\t\t);\n\t\t}\n\n\t\tconst service = this.resolveRegistration<T>(registration[0]);\n\t\treturn service;\n\t}\n\n\tpublic beginScope(name?: string) {\n\t\tif (this.scopes.has(name)) {\n\t\t\tthrow new DuplicateScopeError(\n\t\t\t\t`Cannot create duplicate scope. Scope with ${name} is already created and has not been disposed.`,\n\t\t\t);\n\t\t}\n\n\t\tconst scope = new Crucible({\n\t\t\tkey: name,\n\t\t\tserviceRegistry: this.serviceRegistry,\n\t\t\trootScope: this,\n\t\t});\n\n\t\tthis.scopes.set(name, scope);\n\t\treturn scope;\n\t}\n\n\tpublic [Symbol.dispose]() {\n\t\tif (this.isDisposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.dispose();\n\t}\n\n\tprivate dispose() {\n\t\tif (this.isDisposed) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.isDisposed = true;\n\t\tfor (const [, inst] of this.instances) {\n\t\t\tif (inst === this) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tinst[Symbol.dispose]?.();\n\t\t}\n\t}\n\n\tprivate getRegistrationFrom(key: RegistrationKey) {\n\t\tconst registration = this.serviceRegistry.getRegistration(key.value);\n\t\treturn registration;\n\t}\n\n\tprivate resolveRegistration<T extends object>(registration: ServiceRegistration): T {\n\t\tconst { scope } = registration;\n\t\tswitch (scope) {\n\t\t\tcase Scopes.transient:\n\t\t\t\treturn this.createInstance(registration);\n\t\t\tcase Scopes.singleton:\n\t\t\t\treturn this.rootScope.getOrCreateInstance(registration);\n\t\t\tcase Scopes.request:\n\t\t\t\treturn this.getOrCreateInstance(registration);\n\t\t}\n\t}\n\n\tprivate getOrCreateInstance<T extends object>(registration: ServiceRegistration): T {\n\t\tif (this.isDisposed) {\n\t\t\tthrow new Error(\"This continer has been disposed\");\n\t\t}\n\t\tconst { key, type, isInstance } = registration;\n\t\tconst cacheKey = isInstance ? key.value : type;\n\t\tconst existingInstance = this.instances.get(cacheKey);\n\t\tif (existingInstance != null) {\n\t\t\treturn existingInstance as T;\n\t\t}\n\n\t\tconst instance = isInstance ? (type as T) : this.createInstance<T>(registration);\n\t\tthis.instances.set(cacheKey, instance);\n\t\treturn instance;\n\t}\n\n\tprivate createInstance<T extends object>(registration: ServiceRegistration): T {\n\t\tconst type = registration.type as Constructable | FunctionType;\n\t\tconst canConstruct = isConstructable(type);\n\t\tconst deps = this.resolveDependencies(type);\n\t\tconst inst = (canConstruct ? new type(...deps) : type()) as T;\n\t\treturn inst;\n\t}\n\n\tprivate resolveDependencies(type: Constructable | FunctionType): unknown[] {\n\t\tconst params = getMeta<Array<Constructable>>(ReflectionMeta.paramtypes, type) ?? [];\n\n\t\tconst injectTokens =\n\t\t\tgetMeta<InjectionMetadata>(CrucibleMeta.injecttoken, type) ?? new Map();\n\n\t\t//TODO: put a try catch here so we can throw the name of the service\n\t\tlet resolved = [];\n\t\tfor (let i = 0; i < params.length; i++) {\n\t\t\tconst token = injectTokens.get(i)?.key ?? params[i].name;\n\t\t\tconst dep = isArrayType(params[i]) ? this.resolveMany(token) : this.resolve(token);\n\t\t\tresolved = [...resolved, dep];\n\t\t}\n\t\treturn resolved;\n\t}\n\n\tprivate registerLifetimeScope() {\n\t\tthis.serviceRegistry.registerType(Scopes.request, {\n\t\t\ttypeOrKey: LifetimeScopeToken,\n\t\t\ttypeOrInstance: this,\n\t\t});\n\t}\n}\n"],"names":["getMeta","isArrayType","isConstructable","ReflectionMeta","scribe","CrucibleMeta","LifetimeScopeToken","Scopes","RegistrationKey","DuplicateScopeError","ResolveError","ServiceRegistry","Crucible","key","instances","Map","serviceRegistry","rootScope","scopes","logger","name","isDisposed","options","registerLifetimeScope","resolveMany","resolveRequest","registrations","getRegistrationFrom","services","Array","of","registration","service","resolveRegistration","push","resolve","warn","toString","length","beginScope","has","scope","set","Symbol","dispose","inst","getRegistration","value","transient","createInstance","singleton","getOrCreateInstance","request","Error","type","isInstance","cacheKey","existingInstance","get","instance","canConstruct","deps","resolveDependencies","params","paramtypes","injectTokens","injecttoken","resolved","i","token","dep","registerType","typeOrKey","typeOrInstance"],"mappings":"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"}

package/tests/container.spec.js

@@ -0,0 +1,259 @@
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+import { CrucibleBuilder } from "../src/index.js";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+class Disposable {
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+    dispose() {}
+}
+class Singleton {
+    nonce;
+    constructor(){
+        this.nonce = getRandomInt();
+    }
+}
+describe("CrucibleBuilder", ()=>{
+    let builder;
+    beforeEach(()=>{
+        vi.clearAllMocks();
+        builder = new CrucibleBuilder();
+    });
+    describe("Factories", ()=>{
+        const FACTORY_KEY = "MY_FACTORY";
+        // using a spy for the factory changes the type
+        // this is the only way to ensure the factory is actually called
+        it("should support arrow functions", ()=>{
+            const builder = new CrucibleBuilder();
+            const expected = {
+                field: "fieldValue"
+            };
+            const factory = ()=>expected;
+            builder.registerRequestScoped(FACTORY_KEY, factory);
+            const container = builder.build();
+            const actual = container.resolve(FACTORY_KEY);
+            expect(actual).toEqual(expected);
+        });
+    });
+    describe("Dispose", ()=>{
+        const dispose = vi.spyOn(Disposable.prototype, "dispose");
+        it("should dispose the child scope", ()=>{
+            {
+                const env = {
+                    stack: [],
+                    error: void 0,
+                    hasError: false
+                };
+                try {
+                    const builder = new CrucibleBuilder();
+                    builder.registerRequestScoped(Disposable);
+                    const container = builder.build();
+                    const scope = _ts_add_disposable_resource(env, container.beginScope(), false);
+                    scope.resolve(Disposable);
+                } catch (e) {
+                    env.error = e;
+                    env.hasError = true;
+                } finally{
+                    _ts_dispose_resources(env);
+                }
+            }
+            expect(dispose).toHaveBeenCalled();
+        });
+        it("should dispose root container without recursive self-disposal", ()=>{
+            const builder = new CrucibleBuilder();
+            const container = builder.build();
+            container.resolve("LIFETIME_SCOPE");
+            expect(()=>container[Symbol.dispose]()).not.toThrow();
+        });
+    // it("should support n level scoped?", () => {
+    // 	const builder = new CrucibleBuilder();
+    // 	builder.registerRequestScoped(Disposable);
+    // 	const container = builder.build();
+    // 	using scope = container.beginScope();
+    // });
+    });
+    describe("Singletons", ()=>{
+        it("should resolve singleton from the root scope", ()=>{
+            // this checks that the same singleton is resolved in all child scopes
+            const builder = new CrucibleBuilder();
+            builder.registerSingleton(Singleton);
+            const container = builder.build();
+            const child = container.beginScope();
+            const inst1 = container.resolve(Singleton);
+            const inst2 = child.resolve(Singleton);
+            const manualInst = new Singleton();
+            expect(inst1).toBe(inst2);
+            expect(manualInst).not.toEqual(inst1);
+            expect(manualInst).not.toEqual(inst2);
+        });
+    });
+    describe("registerRequestScoped", ()=>{
+        it("should resolve the same instance in the same scope", ()=>{
+            builder.registerRequestScoped(Disposable);
+            const container = builder.build();
+            const childA = container.beginScope(getRandomInt().toString());
+            const serviceA = childA.resolve(Disposable);
+            const serviceB = childA.resolve(Disposable);
+            expect(serviceA).toBe(serviceB);
+        });
+        it("should resolve a new instance per scope", ()=>{
+            builder.registerRequestScoped(Disposable);
+            const container = builder.build();
+            const childA = container.beginScope(generateScopeId());
+            const serviceA = childA.resolve(Disposable);
+            const childB = container.beginScope(generateScopeId());
+            const serviceB = childB.resolve(Disposable);
+            expect(serviceA).not.toBe(serviceB);
+        });
+    });
+    describe("beginScope", ()=>{
+        it("should support n level isolated scopes", ()=>{
+            builder.registerRequestScoped(Disposable);
+            const container = builder.build();
+            const childA = container.beginScope(generateScopeId());
+            const gandchildA = childA.beginScope(generateScopeId());
+            const serviceChildA = childA.resolve(Disposable);
+            const serviceGandchildA = gandchildA.resolve(Disposable);
+            expect(serviceChildA).not.toBe(serviceGandchildA);
+        });
+        it("should not dispose the child scope if parent is disposed", ()=>{
+            builder.registerRequestScoped(Disposable);
+            const container = builder.build();
+            let grandChild;
+            {
+                const env = {
+                    stack: [],
+                    error: void 0,
+                    hasError: false
+                };
+                try {
+                    const child = _ts_add_disposable_resource(env, container.beginScope(generateScopeId()), false);
+                    grandChild = child.beginScope(generateScopeId());
+                } catch (e) {
+                    env.error = e;
+                    env.hasError = true;
+                } finally{
+                    _ts_dispose_resources(env);
+                }
+            }
+            expect(()=>grandChild.resolve(Disposable)).not.toThrow();
+        });
+        it("should throw if resolving singleton owned by root if roto scope disposed", ()=>{
+            builder.registerSingleton(Singleton);
+            let child;
+            {
+                const env = {
+                    stack: [],
+                    error: void 0,
+                    hasError: false
+                };
+                try {
+                    const container = _ts_add_disposable_resource(env, builder.build(), false);
+                    child = container.beginScope(generateScopeId());
+                } catch (e) {
+                    env.error = e;
+                    env.hasError = true;
+                } finally{
+                    _ts_dispose_resources(env);
+                }
+            }
+            expect(()=>child.resolve(Singleton)).toThrow();
+        });
+        it("should dispose if exception is throw", ()=>{
+            builder.registerRequestScoped(Disposable);
+            let containerRef;
+            try {
+                const env = {
+                    stack: [],
+                    error: void 0,
+                    hasError: false
+                };
+                try {
+                    const container = _ts_add_disposable_resource(env, builder.build(), false);
+                    containerRef = container;
+                    throw "ERROR";
+                } catch (e) {
+                    env.error = e;
+                    env.hasError = true;
+                } finally{
+                    _ts_dispose_resources(env);
+                }
+            } catch  {}
+            expect(()=>containerRef.resolve(Disposable)).toThrow();
+        });
+    });
+});
+function generateScopeId() {
+    return getRandomInt().toString();
+}
+function getRandomInt() {
+    const min = Math.ceil(0);
+    const max = Math.floor(10_000);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/crucible/tests/container.spec.ts"],"sourcesContent":["import { type Crucible, CrucibleBuilder, type LifetimeScope } from \"@decohere/crucible\";\nimport { beforeEach, describe, expect, it, vi } from \"vitest\";\n\nclass Disposable {\n\tpublic [Symbol.dispose]() {\n\t\tthis.dispose();\n\t}\n\tpublic dispose() {}\n}\n\nclass Singleton {\n\tpublic nonce: number;\n\tpublic constructor() {\n\t\tthis.nonce = getRandomInt();\n\t}\n}\n\ndescribe(\"CrucibleBuilder\", () => {\n\tlet builder: CrucibleBuilder;\n\tbeforeEach(() => {\n\t\tvi.clearAllMocks();\n\t\tbuilder = new CrucibleBuilder();\n\t});\n\n\tdescribe(\"Factories\", () => {\n\t\ttype FactoryResponse = { field: \"fieldValue\" };\n\t\tconst FACTORY_KEY = \"MY_FACTORY\";\n\t\t// using a spy for the factory changes the type\n\t\t// this is the only way to ensure the factory is actually called\n\t\tit(\"should support arrow functions\", () => {\n\t\t\tconst builder = new CrucibleBuilder();\n\t\t\tconst expected: FactoryResponse = { field: \"fieldValue\" };\n\t\t\tconst factory = () => expected;\n\t\t\tbuilder.registerRequestScoped<FactoryResponse>(FACTORY_KEY, factory);\n\t\t\tconst container = builder.build();\n\t\t\tconst actual = container.resolve(FACTORY_KEY);\n\t\t\texpect(actual).toEqual(expected);\n\t\t});\n\t});\n\n\tdescribe(\"Dispose\", () => {\n\t\tconst dispose = vi.spyOn(Disposable.prototype, \"dispose\");\n\n\t\tit(\"should dispose the child scope\", () => {\n\t\t\t{\n\t\t\t\tconst builder = new CrucibleBuilder();\n\t\t\t\tbuilder.registerRequestScoped(Disposable);\n\t\t\t\tconst container = builder.build();\n\t\t\t\tusing scope = container.beginScope();\n\t\t\t\tscope.resolve(Disposable);\n\t\t\t}\n\n\t\t\texpect(dispose).toHaveBeenCalled();\n\t\t});\n\n\t\tit(\"should dispose root container without recursive self-disposal\", () => {\n\t\t\tconst builder = new CrucibleBuilder();\n\t\t\tconst container = builder.build();\n\t\t\tcontainer.resolve(\"LIFETIME_SCOPE\");\n\n\t\t\texpect(() => container[Symbol.dispose]()).not.toThrow();\n\t\t});\n\n\t\t// it(\"should support n level scoped?\", () => {\n\t\t// \tconst builder = new CrucibleBuilder();\n\t\t// \tbuilder.registerRequestScoped(Disposable);\n\t\t// \tconst container = builder.build();\n\t\t// \tusing scope = container.beginScope();\n\n\t\t// });\n\t});\n\n\tdescribe(\"Singletons\", () => {\n\t\tit(\"should resolve singleton from the root scope\", () => {\n\t\t\t// this checks that the same singleton is resolved in all child scopes\n\t\t\tconst builder = new CrucibleBuilder();\n\t\t\tbuilder.registerSingleton(Singleton);\n\t\t\tconst container = builder.build();\n\t\t\tconst child = container.beginScope();\n\t\t\tconst inst1 = container.resolve(Singleton);\n\t\t\tconst inst2 = child.resolve(Singleton);\n\t\t\tconst manualInst = new Singleton();\n\t\t\texpect(inst1).toBe(inst2);\n\t\t\texpect(manualInst).not.toEqual(inst1);\n\t\t\texpect(manualInst).not.toEqual(inst2);\n\t\t});\n\t});\n\n\tdescribe(\"registerRequestScoped\", () => {\n\t\tit(\"should resolve the same instance in the same scope\", () => {\n\t\t\tbuilder.registerRequestScoped(Disposable);\n\t\t\tconst container = builder.build();\n\t\t\tconst childA = container.beginScope(getRandomInt().toString());\n\t\t\tconst serviceA = childA.resolve(Disposable);\n\t\t\tconst serviceB = childA.resolve(Disposable);\n\t\t\texpect(serviceA).toBe(serviceB);\n\t\t});\n\n\t\tit(\"should resolve a new instance per scope\", () => {\n\t\t\tbuilder.registerRequestScoped(Disposable);\n\t\t\tconst container = builder.build();\n\t\t\tconst childA = container.beginScope(generateScopeId());\n\t\t\tconst serviceA = childA.resolve(Disposable);\n\t\t\tconst childB = container.beginScope(generateScopeId());\n\t\t\tconst serviceB = childB.resolve(Disposable);\n\t\t\texpect(serviceA).not.toBe(serviceB);\n\t\t});\n\t});\n\n\tdescribe(\"beginScope\", () => {\n\t\tit(\"should support n level isolated scopes\", () => {\n\t\t\tbuilder.registerRequestScoped(Disposable);\n\t\t\tconst container = builder.build();\n\t\t\tconst childA = container.beginScope(generateScopeId());\n\t\t\tconst gandchildA = childA.beginScope(generateScopeId());\n\t\t\tconst serviceChildA = childA.resolve(Disposable);\n\t\t\tconst serviceGandchildA = gandchildA.resolve(Disposable);\n\t\t\texpect(serviceChildA).not.toBe(serviceGandchildA);\n\t\t});\n\n\t\tit(\"should not dispose the child scope if parent is disposed\", () => {\n\t\t\tbuilder.registerRequestScoped(Disposable);\n\t\t\tconst container = builder.build();\n\t\t\tlet grandChild: Crucible;\n\t\t\t{\n\t\t\t\tusing child = container.beginScope(generateScopeId());\n\t\t\t\tgrandChild = child.beginScope(generateScopeId());\n\t\t\t}\n\t\t\texpect(() => grandChild.resolve(Disposable)).not.toThrow();\n\t\t});\n\n\t\tit(\"should throw if resolving singleton owned by root if roto scope disposed\", () => {\n\t\t\tbuilder.registerSingleton(Singleton);\n\t\t\tlet child: LifetimeScope;\n\t\t\t{\n\t\t\t\tusing container = builder.build();\n\t\t\t\tchild = container.beginScope(generateScopeId());\n\t\t\t}\n\n\t\t\texpect(() => child.resolve(Singleton)).toThrow();\n\t\t});\n\n\t\tit(\"should dispose if exception is throw\", () => {\n\t\t\tbuilder.registerRequestScoped(Disposable);\n\t\t\tlet containerRef: Crucible;\n\t\t\ttry {\n\t\t\t\tusing container = builder.build();\n\t\t\t\tcontainerRef = container;\n\t\t\t\tthrow \"ERROR\";\n\t\t\t} catch {}\n\n\t\t\texpect(() => containerRef.resolve(Disposable)).toThrow();\n\t\t});\n\t});\n});\n\nfunction generateScopeId() {\n\treturn getRandomInt().toString();\n}\n\nfunction getRandomInt() {\n\tconst min = Math.ceil(0);\n\tconst max = Math.floor(10_000);\n\treturn Math.floor(Math.random() * (max - min + 1)) + min;\n}\n"],"names":["CrucibleBuilder","beforeEach","describe","expect","it","vi","Disposable","Symbol","dispose","Singleton","nonce","getRandomInt","builder","clearAllMocks","FACTORY_KEY","expected","field","factory","registerRequestScoped","container","build","actual","resolve","toEqual","spyOn","prototype","scope","beginScope","toHaveBeenCalled","not","toThrow","registerSingleton","child","inst1","inst2","manualInst","toBe","childA","toString","serviceA","serviceB","generateScopeId","childB","gandchildA","serviceChildA","serviceGandchildA","grandChild","containerRef","min","Math","ceil","max","floor","random"],"mappings":"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"}

package/commonjs/src/const.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get CrucibleMeta () {
-        return CrucibleMeta;
-    },
-    get LifetimeScopeToken () {
-        return LifetimeScopeToken;
-    },
-    get Scopes () {
-        return Scopes;
-    }
-});
-const Crucible = "Crucible";
-const LifetimeScopeToken = Symbol("LifetimeScope");
-const CrucibleMeta = {
-    injecttoken: `${Crucible}:injecttoken`
-};
-const Scopes = {
-    request: "request",
-    singleton: "single-instance",
-    transient: "transient"
-};
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9jb25zdC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFNjb3BlIH0gZnJvbSBcIi4vdHlwZXMvdHlwZXMuanNcIjtcblxuY29uc3QgQ3J1Y2libGUgPSBcIkNydWNpYmxlXCI7XG50eXBlIENydWNpYmxlTWV0YSA9IFwiaW5qZWN0dG9rZW5cIjtcblxuZXhwb3J0IGNvbnN0IExpZmV0aW1lU2NvcGVUb2tlbiA9IFN5bWJvbChcIkxpZmV0aW1lU2NvcGVcIik7XG5cbmV4cG9ydCBjb25zdCBDcnVjaWJsZU1ldGEgPSB7XG5cdGluamVjdHRva2VuOiBgJHtDcnVjaWJsZX06aW5qZWN0dG9rZW5gLFxufSBzYXRpc2ZpZXMgUmVjb3JkPENydWNpYmxlTWV0YSwgc3RyaW5nPjtcblxuZXhwb3J0IGNvbnN0IFNjb3BlcyA9IHtcblx0cmVxdWVzdDogXCJyZXF1ZXN0XCIsXG5cdHNpbmdsZXRvbjogXCJzaW5nbGUtaW5zdGFuY2VcIixcblx0dHJhbnNpZW50OiBcInRyYW5zaWVudFwiLFxufSBzYXRpc2ZpZXMgUmVjb3JkPHN0cmluZywgU2NvcGU+O1xuIl0sIm5hbWVzIjpbIkNydWNpYmxlTWV0YSIsIkxpZmV0aW1lU2NvcGVUb2tlbiIsIlNjb3BlcyIsIkNydWNpYmxlIiwiU3ltYm9sIiwiaW5qZWN0dG9rZW4iLCJyZXF1ZXN0Iiwic2luZ2xldG9uIiwidHJhbnNpZW50Il0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztRQU9hQTtlQUFBQTs7UUFGQUM7ZUFBQUE7O1FBTUFDO2VBQUFBOzs7QUFUYixNQUFNQyxXQUFXO0FBR1YsTUFBTUYscUJBQXFCRyxPQUFPO0FBRWxDLE1BQU1KLGVBQWU7SUFDM0JLLGFBQWEsR0FBR0YsU0FBUyxZQUFZLENBQUM7QUFDdkM7QUFFTyxNQUFNRCxTQUFTO0lBQ3JCSSxTQUFTO0lBQ1RDLFdBQVc7SUFDWEMsV0FBVztBQUNaIn0=

package/commonjs/src/decorators/index.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./inject.decorator.js"), exports);
-_export_star(require("./injectable.dectorator.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9kZWNvcmF0b3JzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2luamVjdC5kZWNvcmF0b3IuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2luamVjdGFibGUuZGVjdG9yYXRvci5qc1wiO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWM7cUJBQ0EifQ==

package/commonjs/src/decorators/inject.decorator.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "inject", {
-    enumerable: true,
-    get: function() {
-        return inject;
-    }
-});
-const _reflection = require("@decohere/nexus/reflection");
-const _const = require("../const.js");
-function inject(key) {
-    return (target, _propertyKey, idx)=>{
-        const metadata = getExistingMeta(target);
-        metadata.set(idx, {
-            key
-        });
-        (0, _reflection.defineMeta)(_const.CrucibleMeta.injecttoken, metadata, target);
-    };
-}
-function getExistingMeta(target) {
-    const meta = (0, _reflection.getMeta)(_const.CrucibleMeta.injecttoken, target) ?? new Map();
-    return meta;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9kZWNvcmF0b3JzL2luamVjdC5kZWNvcmF0b3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZGVmaW5lTWV0YSwgZ2V0TWV0YSB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvcmVmbGVjdGlvblwiO1xuaW1wb3J0IHsgQ3J1Y2libGVNZXRhIH0gZnJvbSBcIi4uL2NvbnN0LmpzXCI7XG5cbmV4cG9ydCB0eXBlIEluamVjdGlvbk1ldGFkYXRhID0gTWFwPG51bWJlciwgSW5qZWN0aW9uVG9rZW4+O1xuXG5leHBvcnQgdHlwZSBJbmplY3Rpb25Ub2tlbiA9IHtcblx0a2V5OiBzdHJpbmcgfCBzeW1ib2w7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0KGtleTogc3RyaW5nIHwgc3ltYm9sKSB7XG5cdHJldHVybiAodGFyZ2V0OiBvYmplY3QsIF9wcm9wZXJ0eUtleTogc3RyaW5nIHwgc3ltYm9sIHwgdW5kZWZpbmVkLCBpZHg6IG51bWJlcikgPT4ge1xuXHRcdGNvbnN0IG1ldGFkYXRhID0gZ2V0RXhpc3RpbmdNZXRhKHRhcmdldCk7XG5cdFx0bWV0YWRhdGEuc2V0KGlkeCwgeyBrZXkgfSk7XG5cdFx0ZGVmaW5lTWV0YShDcnVjaWJsZU1ldGEuaW5qZWN0dG9rZW4sIG1ldGFkYXRhLCB0YXJnZXQpO1xuXHR9O1xufVxuXG5mdW5jdGlvbiBnZXRFeGlzdGluZ01ldGEodGFyZ2V0OiBvYmplY3QpIHtcblx0Y29uc3QgbWV0YSA9XG5cdFx0Z2V0TWV0YTxNYXA8bnVtYmVyLCBJbmplY3Rpb25Ub2tlbj4+KENydWNpYmxlTWV0YS5pbmplY3R0b2tlbiwgdGFyZ2V0KSA/P1xuXHRcdG5ldyBNYXA8bnVtYmVyLCBJbmplY3Rpb25Ub2tlbj4oKTtcblx0cmV0dXJuIG1ldGE7XG59XG4iXSwibmFtZXMiOlsiaW5qZWN0Iiwia2V5IiwidGFyZ2V0IiwiX3Byb3BlcnR5S2V5IiwiaWR4IiwibWV0YWRhdGEiLCJnZXRFeGlzdGluZ01ldGEiLCJzZXQiLCJkZWZpbmVNZXRhIiwiQ3J1Y2libGVNZXRhIiwiaW5qZWN0dG9rZW4iLCJtZXRhIiwiZ2V0TWV0YSIsIk1hcCJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFTZ0JBOzs7ZUFBQUE7Ozs0QkFUb0I7dUJBQ1A7QUFRdEIsU0FBU0EsT0FBT0MsR0FBb0I7SUFDMUMsT0FBTyxDQUFDQyxRQUFnQkMsY0FBMkNDO1FBQ2xFLE1BQU1DLFdBQVdDLGdCQUFnQko7UUFDakNHLFNBQVNFLEdBQUcsQ0FBQ0gsS0FBSztZQUFFSDtRQUFJO1FBQ3hCTyxJQUFBQSxzQkFBVSxFQUFDQyxtQkFBWSxDQUFDQyxXQUFXLEVBQUVMLFVBQVVIO0lBQ2hEO0FBQ0Q7QUFFQSxTQUFTSSxnQkFBZ0JKLE1BQWM7SUFDdEMsTUFBTVMsT0FDTEMsSUFBQUEsbUJBQU8sRUFBOEJILG1CQUFZLENBQUNDLFdBQVcsRUFBRVIsV0FDL0QsSUFBSVc7SUFDTCxPQUFPRjtBQUNSIn0=

package/commonjs/src/decorators/injectable.dectorator.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "injectable", {
-    enumerable: true,
-    get: function() {
-        return injectable;
-    }
-});
-function injectable() {
-    // no implementation for now. Just used to ensure reflect metadata is generated
-    return ()=>{};
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9kZWNvcmF0b3JzL2luamVjdGFibGUuZGVjdG9yYXRvci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gaW5qZWN0YWJsZSgpOiBDbGFzc0RlY29yYXRvciB7XG5cdC8vIG5vIGltcGxlbWVudGF0aW9uIGZvciBub3cuIEp1c3QgdXNlZCB0byBlbnN1cmUgcmVmbGVjdCBtZXRhZGF0YSBpcyBnZW5lcmF0ZWRcblx0cmV0dXJuICgpID0+IHt9O1xufVxuIl0sIm5hbWVzIjpbImluamVjdGFibGUiXSwibWFwcGluZ3MiOiI7Ozs7K0JBQWdCQTs7O2VBQUFBOzs7QUFBVCxTQUFTQTtJQUNmLCtFQUErRTtJQUMvRSxPQUFPLEtBQU87QUFDZiJ9

package/commonjs/src/index.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./const.js"), exports);
-_export_star(require("./services/index.js"), exports);
-_export_star(require("./types/index.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb25zdC5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2VydmljZXMvaW5kZXguanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzL2luZGV4LmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztxQkFBYztxQkFDQTtxQkFDQSJ9

package/commonjs/src/models/registration-key.model.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RegistrationKey", {
-    enumerable: true,
-    get: function() {
-        return RegistrationKey;
-    }
-});
-class RegistrationKey {
-    constructor(key){
-        this.value = this.getValue(key);
-    }
-    value;
-    getValue(key) {
-        switch(typeof key){
-            case "string":
-                return key;
-            case "symbol":
-                return key.valueOf().description;
-            default:
-                return key.name;
-        }
-    }
-    toString() {
-        return this.value;
-    }
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NydWNpYmxlL3NyYy9tb2RlbHMvcmVnaXN0cmF0aW9uLWtleS5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IENvbnN0cnVjdGFibGUgfSBmcm9tIFwiQGRlY29oZXJlL25leHVzL3JlZmxlY3Rpb25cIjtcblxuZXhwb3J0IGNsYXNzIFJlZ2lzdHJhdGlvbktleSB7XG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihrZXk6IHN0cmluZyB8IHN5bWJvbCB8IENvbnN0cnVjdGFibGUpIHtcblx0XHR0aGlzLnZhbHVlID0gdGhpcy5nZXRWYWx1ZShrZXkpO1xuXHR9XG5cblx0cHVibGljIHZhbHVlOiBzdHJpbmc7XG5cblx0cHJpdmF0ZSBnZXRWYWx1ZShrZXk6IHN0cmluZyB8IHN5bWJvbCB8IENvbnN0cnVjdGFibGUpOiBzdHJpbmcge1xuXHRcdHN3aXRjaCAodHlwZW9mIGtleSkge1xuXHRcdFx0Y2FzZSBcInN0cmluZ1wiOlxuXHRcdFx0XHRyZXR1cm4ga2V5O1xuXHRcdFx0Y2FzZSBcInN5bWJvbFwiOlxuXHRcdFx0XHRyZXR1cm4ga2V5LnZhbHVlT2YoKS5kZXNjcmlwdGlvbjtcblx0XHRcdGRlZmF1bHQ6XG5cdFx0XHRcdHJldHVybiBrZXkubmFtZTtcblx0XHR9XG5cdH1cblxuXHRwdWJsaWMgdG9TdHJpbmcoKSB7XG5cdFx0cmV0dXJuIHRoaXMudmFsdWU7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJSZWdpc3RyYXRpb25LZXkiLCJrZXkiLCJ2YWx1ZSIsImdldFZhbHVlIiwidmFsdWVPZiIsImRlc2NyaXB0aW9uIiwibmFtZSIsInRvU3RyaW5nIl0sIm1hcHBpbmdzIjoiOzs7OytCQUVhQTs7O2VBQUFBOzs7QUFBTixNQUFNQTtJQUNaLFlBQW1CQyxHQUFvQyxDQUFFO1FBQ3hELElBQUksQ0FBQ0MsS0FBSyxHQUFHLElBQUksQ0FBQ0MsUUFBUSxDQUFDRjtJQUM1QjtJQUVPQyxNQUFjO0lBRWJDLFNBQVNGLEdBQW9DLEVBQVU7UUFDOUQsT0FBUSxPQUFPQTtZQUNkLEtBQUs7Z0JBQ0osT0FBT0E7WUFDUixLQUFLO2dCQUNKLE9BQU9BLElBQUlHLE9BQU8sR0FBR0MsV0FBVztZQUNqQztnQkFDQyxPQUFPSixJQUFJSyxJQUFJO1FBQ2pCO0lBQ0Q7SUFFT0MsV0FBVztRQUNqQixPQUFPLElBQUksQ0FBQ0wsS0FBSztJQUNsQjtBQUNEIn0=