ts-ioc-container 56.1.0 → 56.2.0

package/cjm/index.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onContainerDisposedHooksRunner = exports.AddOnConstructAsyncHookModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.UnexpectedHookResultError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = exports.appendArgsFn = exports.appendArgs = exports.decorate = exports.singleton = exports.lazy = exports.scopeAccess = exports.scope = exports.bindTo = exports.register = exports.Provider = exports.ProxyInjector = exports.SimpleInjector = exports.resolveArgs = exports.argsFn = exports.args = exports.inject = exports.MetadataInjector = exports.Injector = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.resolveConstructor = exports.Is = exports.pipe = exports.select = exports.once = exports.shallowCache = exports.debounce = exports.throttle = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.getClassMeta = exports.addClassMeta = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onContainerDisposed = void 0;
+var IContainer_1 = require("./container/IContainer");
+Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
+var Container_1 = require("./container/Container");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return Container_1.Container; } });
+var EmptyContainer_1 = require("./container/EmptyContainer");
+Object.defineProperty(exports, "EmptyContainer", { enumerable: true, get: function () { return EmptyContainer_1.EmptyContainer; } });
+var IInjector_1 = require("./injector/IInjector");
+Object.defineProperty(exports, "Injector", { enumerable: true, get: function () { return IInjector_1.Injector; } });
+var MetadataInjector_1 = require("./injector/MetadataInjector");
+Object.defineProperty(exports, "MetadataInjector", { enumerable: true, get: function () { return MetadataInjector_1.MetadataInjector; } });
+Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return MetadataInjector_1.inject; } });
+Object.defineProperty(exports, "args", { enumerable: true, get: function () { return MetadataInjector_1.args; } });
+Object.defineProperty(exports, "argsFn", { enumerable: true, get: function () { return MetadataInjector_1.argsFn; } });
+Object.defineProperty(exports, "resolveArgs", { enumerable: true, get: function () { return MetadataInjector_1.resolveArgs; } });
+var SimpleInjector_1 = require("./injector/SimpleInjector");
+Object.defineProperty(exports, "SimpleInjector", { enumerable: true, get: function () { return SimpleInjector_1.SimpleInjector; } });
+var ProxyInjector_1 = require("./injector/ProxyInjector");
+Object.defineProperty(exports, "ProxyInjector", { enumerable: true, get: function () { return ProxyInjector_1.ProxyInjector; } });
+var Provider_1 = require("./provider/Provider");
+Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return Provider_1.Provider; } });
+var IRegistration_1 = require("./registration/IRegistration");
+Object.defineProperty(exports, "register", { enumerable: true, get: function () { return IRegistration_1.register; } });
+Object.defineProperty(exports, "bindTo", { enumerable: true, get: function () { return IRegistration_1.bindTo; } });
+Object.defineProperty(exports, "scope", { enumerable: true, get: function () { return IRegistration_1.scope; } });
+Object.defineProperty(exports, "scopeAccess", { enumerable: true, get: function () { return IRegistration_1.scopeAccess; } });
+Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return IRegistration_1.lazy; } });
+Object.defineProperty(exports, "singleton", { enumerable: true, get: function () { return IRegistration_1.singleton; } });
+Object.defineProperty(exports, "decorate", { enumerable: true, get: function () { return IRegistration_1.decorate; } });
+Object.defineProperty(exports, "appendArgs", { enumerable: true, get: function () { return IRegistration_1.appendArgs; } });
+Object.defineProperty(exports, "appendArgsFn", { enumerable: true, get: function () { return IRegistration_1.appendArgsFn; } });
+var Registration_1 = require("./registration/Registration");
+Object.defineProperty(exports, "Registration", { enumerable: true, get: function () { return Registration_1.Registration; } });
+var ContainerError_1 = require("./errors/ContainerError");
+Object.defineProperty(exports, "ContainerError", { enumerable: true, get: function () { return ContainerError_1.ContainerError; } });
+var DependencyNotFoundError_1 = require("./errors/DependencyNotFoundError");
+Object.defineProperty(exports, "DependencyNotFoundError", { enumerable: true, get: function () { return DependencyNotFoundError_1.DependencyNotFoundError; } });
+var ContainerNotFoundError_1 = require("./errors/ContainerNotFoundError");
+Object.defineProperty(exports, "ContainerNotFoundError", { enumerable: true, get: function () { return ContainerNotFoundError_1.ContainerNotFoundError; } });
+var DependencyMissingKeyError_1 = require("./errors/DependencyMissingKeyError");
+Object.defineProperty(exports, "DependencyMissingKeyError", { enumerable: true, get: function () { return DependencyMissingKeyError_1.DependencyMissingKeyError; } });
+var MethodNotImplementedError_1 = require("./errors/MethodNotImplementedError");
+Object.defineProperty(exports, "MethodNotImplementedError", { enumerable: true, get: function () { return MethodNotImplementedError_1.MethodNotImplementedError; } });
+var ContainerDisposedError_1 = require("./errors/ContainerDisposedError");
+Object.defineProperty(exports, "ContainerDisposedError", { enumerable: true, get: function () { return ContainerDisposedError_1.ContainerDisposedError; } });
+var ProviderDisposedError_1 = require("./errors/ProviderDisposedError");
+Object.defineProperty(exports, "ProviderDisposedError", { enumerable: true, get: function () { return ProviderDisposedError_1.ProviderDisposedError; } });
+var UnexpectedHookResultError_1 = require("./errors/UnexpectedHookResultError");
+Object.defineProperty(exports, "UnexpectedHookResultError", { enumerable: true, get: function () { return UnexpectedHookResultError_1.UnexpectedHookResultError; } });
+var CannonSingletonApplyTwiceError_1 = require("./errors/CannonSingletonApplyTwiceError");
+Object.defineProperty(exports, "CannonSingletonApplyTwiceError", { enumerable: true, get: function () { return CannonSingletonApplyTwiceError_1.CannonSingletonApplyTwiceError; } });
+var UnsupportedTokenTypeError_1 = require("./errors/UnsupportedTokenTypeError");
+Object.defineProperty(exports, "UnsupportedTokenTypeError", { enumerable: true, get: function () { return UnsupportedTokenTypeError_1.UnsupportedTokenTypeError; } });
+var hook_1 = require("./hooks/hook");
+Object.defineProperty(exports, "getHooks", { enumerable: true, get: function () { return hook_1.getHooks; } });
+Object.defineProperty(exports, "hook", { enumerable: true, get: function () { return hook_1.hook; } });
+Object.defineProperty(exports, "hasHooks", { enumerable: true, get: function () { return hook_1.hasHooks; } });
+Object.defineProperty(exports, "appendHooks", { enumerable: true, get: function () { return hook_1.appendHooks; } });
+Object.defineProperty(exports, "prependHooks", { enumerable: true, get: function () { return hook_1.prependHooks; } });
+Object.defineProperty(exports, "append", { enumerable: true, get: function () { return hook_1.append; } });
+Object.defineProperty(exports, "prepend", { enumerable: true, get: function () { return hook_1.prepend; } });
+var HookContext_1 = require("./hooks/HookContext");
+Object.defineProperty(exports, "HookContext", { enumerable: true, get: function () { return HookContext_1.HookContext; } });
+Object.defineProperty(exports, "createHookContextFactory", { enumerable: true, get: function () { return HookContext_1.createHookContextFactory; } });
+Object.defineProperty(exports, "createHookContext", { enumerable: true, get: function () { return HookContext_1.createHookContext; } });
+var injectProp_1 = require("./hooks/injectProp");
+Object.defineProperty(exports, "injectProp", { enumerable: true, get: function () { return injectProp_1.injectProp; } });
+var onConstruct_1 = require("./hooks/onConstruct");
+Object.defineProperty(exports, "onConstructHooksRunner", { enumerable: true, get: function () { return onConstruct_1.onConstructHooksRunner; } });
+Object.defineProperty(exports, "onConstruct", { enumerable: true, get: function () { return onConstruct_1.onConstruct; } });
+Object.defineProperty(exports, "AddOnConstructHookModule", { enumerable: true, get: function () { return onConstruct_1.AddOnConstructHookModule; } });
+var onConstructAsync_1 = require("./hooks/onConstructAsync");
+Object.defineProperty(exports, "onConstructAsyncHooksRunner", { enumerable: true, get: function () { return onConstructAsync_1.onConstructAsyncHooksRunner; } });
+Object.defineProperty(exports, "onConstructAsync", { enumerable: true, get: function () { return onConstructAsync_1.onConstructAsync; } });
+Object.defineProperty(exports, "AddOnConstructAsyncHookModule", { enumerable: true, get: function () { return onConstructAsync_1.AddOnConstructAsyncHookModule; } });
+var onContainerDisposed_1 = require("./hooks/onContainerDisposed");
+Object.defineProperty(exports, "onContainerDisposedHooksRunner", { enumerable: true, get: function () { return onContainerDisposed_1.onContainerDisposedHooksRunner; } });
+Object.defineProperty(exports, "onContainerDisposed", { enumerable: true, get: function () { return onContainerDisposed_1.onContainerDisposed; } });
+Object.defineProperty(exports, "AddOnDisposeHookModule", { enumerable: true, get: function () { return onContainerDisposed_1.AddOnDisposeHookModule; } });
+var HooksRunner_1 = require("./hooks/HooksRunner");
+Object.defineProperty(exports, "HooksRunner", { enumerable: true, get: function () { return HooksRunner_1.HooksRunner; } });
+var InjectionToken_1 = require("./token/InjectionToken");
+Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return InjectionToken_1.InjectionToken; } });
+var GroupAliasToken_1 = require("./token/GroupAliasToken");
+Object.defineProperty(exports, "GroupAliasToken", { enumerable: true, get: function () { return GroupAliasToken_1.GroupAliasToken; } });
+Object.defineProperty(exports, "toGroupAlias", { enumerable: true, get: function () { return GroupAliasToken_1.toGroupAlias; } });
+var SingleAliasToken_1 = require("./token/SingleAliasToken");
+Object.defineProperty(exports, "SingleAliasToken", { enumerable: true, get: function () { return SingleAliasToken_1.SingleAliasToken; } });
+Object.defineProperty(exports, "toSingleAlias", { enumerable: true, get: function () { return SingleAliasToken_1.toSingleAlias; } });
+var ClassToken_1 = require("./token/ClassToken");
+Object.defineProperty(exports, "ClassToken", { enumerable: true, get: function () { return ClassToken_1.ClassToken; } });
+var SingleToken_1 = require("./token/SingleToken");
+Object.defineProperty(exports, "SingleToken", { enumerable: true, get: function () { return SingleToken_1.SingleToken; } });
+var FunctionToken_1 = require("./token/FunctionToken");
+Object.defineProperty(exports, "FunctionToken", { enumerable: true, get: function () { return FunctionToken_1.FunctionToken; } });
+var ConstantToken_1 = require("./token/ConstantToken");
+Object.defineProperty(exports, "ConstantToken", { enumerable: true, get: function () { return ConstantToken_1.ConstantToken; } });
+var GroupInstanceToken_1 = require("./token/GroupInstanceToken");
+Object.defineProperty(exports, "GroupInstanceToken", { enumerable: true, get: function () { return GroupInstanceToken_1.GroupInstanceToken; } });
+var class_1 = require("./metadata/class");
+Object.defineProperty(exports, "addClassMeta", { enumerable: true, get: function () { return class_1.addClassMeta; } });
+Object.defineProperty(exports, "getClassMeta", { enumerable: true, get: function () { return class_1.getClassMeta; } });
+Object.defineProperty(exports, "addClassLabel", { enumerable: true, get: function () { return class_1.addClassLabel; } });
+Object.defineProperty(exports, "getClassLabels", { enumerable: true, get: function () { return class_1.getClassLabels; } });
+Object.defineProperty(exports, "addClassTag", { enumerable: true, get: function () { return class_1.addClassTag; } });
+Object.defineProperty(exports, "getClassTags", { enumerable: true, get: function () { return class_1.getClassTags; } });
+var parameter_1 = require("./metadata/parameter");
+Object.defineProperty(exports, "addParamMeta", { enumerable: true, get: function () { return parameter_1.addParamMeta; } });
+Object.defineProperty(exports, "getParamMeta", { enumerable: true, get: function () { return parameter_1.getParamMeta; } });
+Object.defineProperty(exports, "addParamLabel", { enumerable: true, get: function () { return parameter_1.addParamLabel; } });
+Object.defineProperty(exports, "getParamLabels", { enumerable: true, get: function () { return parameter_1.getParamLabels; } });
+Object.defineProperty(exports, "addParamTag", { enumerable: true, get: function () { return parameter_1.addParamTag; } });
+Object.defineProperty(exports, "getParamTags", { enumerable: true, get: function () { return parameter_1.getParamTags; } });
+var method_1 = require("./metadata/method");
+Object.defineProperty(exports, "addMethodMeta", { enumerable: true, get: function () { return method_1.addMethodMeta; } });
+Object.defineProperty(exports, "getMethodMeta", { enumerable: true, get: function () { return method_1.getMethodMeta; } });
+Object.defineProperty(exports, "addMethodLabel", { enumerable: true, get: function () { return method_1.addMethodLabel; } });
+Object.defineProperty(exports, "getMethodLabels", { enumerable: true, get: function () { return method_1.getMethodLabels; } });
+Object.defineProperty(exports, "addMethodTag", { enumerable: true, get: function () { return method_1.addMethodTag; } });
+Object.defineProperty(exports, "getMethodTags", { enumerable: true, get: function () { return method_1.getMethodTags; } });
+var errorHandler_1 = require("./utils/errorHandler");
+Object.defineProperty(exports, "handleError", { enumerable: true, get: function () { return errorHandler_1.handleError; } });
+Object.defineProperty(exports, "handleAsyncError", { enumerable: true, get: function () { return errorHandler_1.handleAsyncError; } });
+var throttle_1 = require("./utils/throttle");
+Object.defineProperty(exports, "throttle", { enumerable: true, get: function () { return throttle_1.throttle; } });
+var debounce_1 = require("./utils/debounce");
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return debounce_1.debounce; } });
+var shallowCache_1 = require("./utils/shallowCache");
+Object.defineProperty(exports, "shallowCache", { enumerable: true, get: function () { return shallowCache_1.shallowCache; } });
+var once_1 = require("./utils/once");
+Object.defineProperty(exports, "once", { enumerable: true, get: function () { return once_1.once; } });
+var select_1 = require("./select");
+Object.defineProperty(exports, "select", { enumerable: true, get: function () { return select_1.select; } });
+var fp_1 = require("./utils/fp");
+Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return fp_1.pipe; } });
+var basic_1 = require("./utils/basic");
+Object.defineProperty(exports, "Is", { enumerable: true, get: function () { return basic_1.Is; } });
+Object.defineProperty(exports, "resolveConstructor", { enumerable: true, get: function () { return basic_1.resolveConstructor; } });

package/cjm/injector/IInjector.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = void 0;
+const proxy_1 = require("../utils/proxy");
+class Injector {
+    resolve(scope, Target, { args, lazy } = {}) {
+        return (0, proxy_1.toLazyIf)(() => {
+            const instance = this.createInstance(scope, Target, { args });
+            scope.addInstance(instance);
+            return instance;
+        }, lazy);
+    }
+}
+exports.Injector = Injector;

package/cjm/injector/MetadataInjector.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveArgs = exports.args = exports.argsFn = exports.inject = exports.MetadataInjector = void 0;
+const IInjector_1 = require("./IInjector");
+const basic_1 = require("../utils/basic");
+const parameter_1 = require("../metadata/parameter");
+const toToken_1 = require("../token/toToken");
+const FunctionToken_1 = require("../token/FunctionToken");
+class MetadataInjector extends IInjector_1.Injector {
+    createInstance(scope, Target, { args: deps = [] } = {}) {
+        const args = (0, exports.resolveArgs)(Target)(scope, { args: deps });
+        return new Target(...args);
+    }
+}
+exports.MetadataInjector = MetadataInjector;
+const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
+const inject = (fn, selectFn = (instance) => instance) => (target, propertyKey, parameterIndex) => {
+    const toSelectedToken = () => {
+        const token = (0, toToken_1.toToken)(fn);
+        return new FunctionToken_1.FunctionToken((scope, options) => selectFn(token.resolve(scope, options)));
+    };
+    (0, parameter_1.addParamMeta)(hookMetaKey(propertyKey), toSelectedToken)(basic_1.Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
+};
+exports.inject = inject;
+const argsFn = (predicate) => (c, { args = [] }) => args.find((value, index) => predicate(value, index));
+exports.argsFn = argsFn;
+const args = (index) => (0, exports.argsFn)((value, i) => i === index);
+exports.args = args;
+const resolveArgs = (Target, methodName) => {
+    const tokens = (0, parameter_1.getParamMeta)(hookMetaKey(methodName), Target);
+    return (scope, { args = [], lazy }) => tokens.map((fn) => fn.resolve(scope, { args: args.map(toToken_1.argToToken).map((t) => t.resolve(scope)), lazy }));
+};
+exports.resolveArgs = resolveArgs;

package/cjm/injector/ProxyInjector.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyInjector = void 0;
+const IInjector_1 = require("./IInjector");
+class ProxyInjector extends IInjector_1.Injector {
+    createInstance(scope, Target, { args = [] } = {}) {
+        const proxy = new Proxy({}, {
+            get(target, prop) {
+                if (prop === 'args') {
+                    return args;
+                }
+                return prop.toString().search(/alias/gi) >= 0 ? scope.resolveByAlias(prop) : scope.resolve(prop);
+            },
+        });
+        return new Target(proxy);
+    }
+}
+exports.ProxyInjector = ProxyInjector;

package/cjm/injector/SimpleInjector.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleInjector = void 0;
+const IInjector_1 = require("./IInjector");
+class SimpleInjector extends IInjector_1.Injector {
+    createInstance(container, Target, { args = [] } = {}) {
+        return new Target(container, ...args);
+    }
+}
+exports.SimpleInjector = SimpleInjector;

package/cjm/metadata/class.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.addClassMeta = void 0;
+exports.getClassMeta = getClassMeta;
+const basic_1 = require("../utils/basic");
+const addClassMeta = (key, mapFn) => (target) => {
+    const value = Reflect.getOwnMetadata(key, target);
+    Reflect.defineMetadata(key, mapFn(value), target);
+};
+exports.addClassMeta = addClassMeta;
+function getClassMeta(target, key) {
+    return Reflect.getOwnMetadata(key, (0, basic_1.resolveConstructor)(target));
+}
+const addClassLabel = (key, label) => (0, exports.addClassMeta)('label', (prev = new Map()) => prev.set(key, label));
+exports.addClassLabel = addClassLabel;
+const getClassLabels = (target) => getClassMeta(target, 'label') ?? new Map();
+exports.getClassLabels = getClassLabels;
+const addClassTag = (tag) => (0, exports.addClassMeta)('tag', (prev = new Set()) => prev.add(tag));
+exports.addClassTag = addClassTag;
+const getClassTags = (target) => getClassMeta(target, 'tag') ?? new Set();
+exports.getClassTags = getClassTags;

package/cjm/metadata/method.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = void 0;
+const basic_1 = require("../utils/basic");
+const addMethodMeta = (key, mapFn) => (target, propertyKey) => {
+    const metadata = Reflect.getMetadata(key, target.constructor, propertyKey);
+    Reflect.defineMetadata(key, mapFn(metadata), target.constructor, propertyKey);
+};
+exports.addMethodMeta = addMethodMeta;
+const getMethodMeta = (key, target, propertyKey) => Reflect.getMetadata(key, (0, basic_1.resolveConstructor)(target), propertyKey);
+exports.getMethodMeta = getMethodMeta;
+const addMethodLabel = (key, label) => (0, exports.addMethodMeta)('label', (prev = new Map()) => prev.set(key, label));
+exports.addMethodLabel = addMethodLabel;
+const getMethodLabels = (target, propertyKey) => (0, exports.getMethodMeta)('label', target, propertyKey) ?? new Map();
+exports.getMethodLabels = getMethodLabels;
+const addMethodTag = (tag) => (0, exports.addMethodMeta)('tag', (prev = new Set()) => prev.add(tag));
+exports.addMethodTag = addMethodTag;
+const getMethodTags = (target, propertyKey) => (0, exports.getMethodMeta)('tag', target, propertyKey) ?? new Set();
+exports.getMethodTags = getMethodTags;

package/cjm/metadata/parameter.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = void 0;
+const basic_1 = require("../utils/basic");
+const addParamMeta = (key, mapFn) => (target, _, parameterIndex) => {
+    const metadata = Reflect.getOwnMetadata(key, target) ?? [];
+    metadata[parameterIndex] = mapFn(metadata[parameterIndex]);
+    Reflect.defineMetadata(key, metadata, target);
+};
+exports.addParamMeta = addParamMeta;
+const getParamMeta = (key, target) => {
+    return Reflect.getOwnMetadata(key, (0, basic_1.resolveConstructor)(target)) ?? [];
+};
+exports.getParamMeta = getParamMeta;
+const addParamLabel = (key, label) => (0, exports.addParamMeta)('label', (prev) => {
+    const map = prev ?? new Map();
+    return map.set(key, label);
+});
+exports.addParamLabel = addParamLabel;
+const getParamLabels = (target, parameterIndex) => {
+    const all = (0, exports.getParamMeta)('label', target);
+    return all[parameterIndex] ?? new Map();
+};
+exports.getParamLabels = getParamLabels;
+const addParamTag = (tag) => (0, exports.addParamMeta)('tag', (prev) => {
+    const set = prev ?? new Set();
+    return set.add(tag);
+});
+exports.addParamTag = addParamTag;
+const getParamTags = (target, parameterIndex) => {
+    const all = (0, exports.getParamMeta)('tag', target);
+    return all[parameterIndex] ?? new Set();
+};
+exports.getParamTags = getParamTags;

package/cjm/provider/IProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjm/provider/Provider.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Provider = void 0;
+const CannonSingletonApplyTwiceError_1 = require("../errors/CannonSingletonApplyTwiceError");
+const ProviderDisposedError_1 = require("../errors/ProviderDisposedError");
+class Provider {
+    resolveDependency;
+    static fromClass(Target) {
+        return new Provider((container, options) => container.resolve(Target, options));
+    }
+    static fromValue(value) {
+        return new Provider(() => value);
+    }
+    static fromKey(key) {
+        return new Provider((c) => c.resolve(key));
+    }
+    argsFnList = [];
+    accessRules = [];
+    mappers = [];
+    isLazy = false;
+    cache = new Map();
+    getKey;
+    isDisposed = false;
+    constructor(resolveDependency) {
+        this.resolveDependency = resolveDependency;
+    }
+    resolve(scope, options) {
+        ProviderDisposedError_1.ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
+        if (!this.getKey) {
+            return this.resolveDep(scope, options);
+        }
+        const key = this.getKey(...(options.args ?? []));
+        if (!this.cache.has(key)) {
+            this.cache.set(key, this.resolveDep(scope, options));
+        }
+        return this.cache.get(key);
+    }
+    resolveDep(scope, { args = [], lazy } = {}) {
+        const dependency = this.resolveDependency(scope, {
+            args: this.argsFnList.reduce((acc, current) => current(scope, { args: acc }), args),
+            lazy: lazy ?? this.isLazy,
+        });
+        return this.mappers.reduce((acc, current) => current(acc, scope), dependency);
+    }
+    map(...mappers) {
+        this.mappers.push(...mappers);
+        return this;
+    }
+    addAccessRule(...rules) {
+        this.accessRules.push(...rules);
+        return this;
+    }
+    lazy() {
+        this.isLazy = true;
+        return this;
+    }
+    addArgsFn(...fns) {
+        this.argsFnList.push(...fns);
+        return this;
+    }
+    hasAccess(options) {
+        ProviderDisposedError_1.ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
+        return this.accessRules.reduce((acc, rule) => rule(options, acc), true);
+    }
+    singleton(getCacheKey = () => '1') {
+        CannonSingletonApplyTwiceError_1.CannonSingletonApplyTwiceError.assert(!this.getKey, 'Provider is already singleton');
+        this.getKey = getCacheKey;
+        return this;
+    }
+    dispose() {
+        ProviderDisposedError_1.ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
+        this.isDisposed = true;
+        this.getKey = undefined;
+        this.cache.clear();
+        this.accessRules.splice(0, this.accessRules.length);
+        this.mappers.splice(0, this.mappers.length);
+        this.argsFnList.splice(0, this.argsFnList.length);
+    }
+}
+exports.Provider = Provider;

package/cjm/registration/IRegistration.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.singleton = exports.decorate = exports.lazy = exports.scopeAccess = exports.appendArgsFn = exports.appendArgs = exports.scope = exports.bindTo = exports.register = exports.getTransformers = exports.registerPipe = exports.isProviderPipe = void 0;
+const IContainer_1 = require("../container/IContainer");
+const SingleToken_1 = require("../token/SingleToken");
+const BindToken_1 = require("../token/BindToken");
+const class_1 = require("../metadata/class");
+const isProviderPipe = (obj) => obj !== null && typeof obj === 'object' && 'mapProvider' in obj;
+exports.isProviderPipe = isProviderPipe;
+const registerPipe = (mapProvider) => ({
+    mapProvider,
+    mapRegistration: (r) => r.pipe(mapProvider),
+});
+exports.registerPipe = registerPipe;
+const METADATA_KEY = 'registration';
+const getTransformers = (Target) => (0, class_1.getClassMeta)(Target, METADATA_KEY) ?? [];
+exports.getTransformers = getTransformers;
+const register = (...mappers) => (0, class_1.addClassMeta)(METADATA_KEY, (acc) => {
+    const result = mappers.map((m) => {
+        if ((0, exports.isProviderPipe)(m))
+            return (r) => m.mapRegistration(r);
+        if ((0, BindToken_1.isBindToken)(m) || (0, IContainer_1.isDependencyKey)(m))
+            return (0, exports.bindTo)(m);
+        return m;
+    });
+    return acc ? [...result, ...acc] : result;
+});
+exports.register = register;
+const bindTo = (...tokens) => (r) => {
+    for (const token of tokens) {
+        const targetToken = (0, BindToken_1.isBindToken)(token) ? token : new SingleToken_1.SingleToken(token);
+        targetToken.bindTo(r);
+    }
+    return r;
+};
+exports.bindTo = bindTo;
+const scope = (...rules) => (r) => r.when(...rules);
+exports.scope = scope;
+const appendArgs = (...extraArgs) => (0, exports.registerPipe)((p) => p.addArgsFn((_, { args = [] } = {}) => [...args, ...extraArgs]));
+exports.appendArgs = appendArgs;
+const appendArgsFn = (fn) => (0, exports.registerPipe)((p) => p.addArgsFn((scope, options) => [...(options?.args ?? []), ...fn(scope, options)]));
+exports.appendArgsFn = appendArgsFn;
+const scopeAccess = (rule) => (0, exports.registerPipe)((p) => p.addAccessRule(rule));
+exports.scopeAccess = scopeAccess;
+const lazy = () => (0, exports.registerPipe)((p) => p.lazy());
+exports.lazy = lazy;
+const decorate = (...fns) => (0, exports.registerPipe)((p) => p.map(...fns));
+exports.decorate = decorate;
+const singleton = (getCacheKey) => (0, exports.registerPipe)((p) => p.singleton(getCacheKey));
+exports.singleton = singleton;

package/cjm/registration/Registration.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Registration = void 0;
+const IContainer_1 = require("../container/IContainer");
+const Provider_1 = require("../provider/Provider");
+const DependencyMissingKeyError_1 = require("../errors/DependencyMissingKeyError");
+const IRegistration_1 = require("./IRegistration");
+const IRegistration_2 = require("./IRegistration");
+const SingleToken_1 = require("../token/SingleToken");
+const fp_1 = require("../utils/fp");
+const basic_1 = require("../utils/basic");
+class Registration {
+    createProvider;
+    key;
+    scopeRules;
+    static fromClass(Target, { name } = {}) {
+        const transform = (0, fp_1.pipe)(...(0, IRegistration_2.getTransformers)(Target));
+        return transform(new Registration(() => Provider_1.Provider.fromClass(Target), name ?? Target.name));
+    }
+    static fromValue(value) {
+        if (basic_1.Is.constructor(value)) {
+            const transform = (0, fp_1.pipe)(...(0, IRegistration_2.getTransformers)(value));
+            return transform(new Registration(() => Provider_1.Provider.fromValue(value), value.name));
+        }
+        return new Registration(() => Provider_1.Provider.fromValue(value));
+    }
+    static fromFn(fn) {
+        return new Registration(() => new Provider_1.Provider(fn));
+    }
+    static fromKey(key) {
+        return new Registration(() => Provider_1.Provider.fromKey(key));
+    }
+    mappers = [];
+    aliases = new Set();
+    constructor(createProvider, key, scopeRules = []) {
+        this.createProvider = createProvider;
+        this.key = key;
+        this.scopeRules = scopeRules;
+    }
+    bindToKey(key) {
+        this.key = key;
+        return this;
+    }
+    bindToAlias(alias) {
+        this.aliases.add(alias);
+        return this;
+    }
+    pipe(...mappers) {
+        const fns = mappers.map((m) => ((0, IRegistration_1.isProviderPipe)(m) ? m.mapProvider.bind(m) : m));
+        this.mappers.push(...fns);
+        return this;
+    }
+    when(...predicates) {
+        this.scopeRules.push(...predicates);
+        return this;
+    }
+    bindTo(key) {
+        if ((0, IContainer_1.isDependencyKey)(key)) {
+            new SingleToken_1.SingleToken(key).bindTo(this);
+            return this;
+        }
+        key.bindTo(this);
+        return this;
+    }
+    matchScope(container) {
+        return this.scopeRules.reduce((prev, curr) => curr(container, prev), true);
+    }
+    applyTo(container) {
+        if (!this.matchScope(container)) {
+            return;
+        }
+        if (!this.key) {
+            throw new DependencyMissingKeyError_1.DependencyMissingKeyError('No key provided for registration');
+        }
+        const provider = this.mappers.reduce((p, m) => m(p), this.createProvider());
+        container.register(this.key, provider, { aliases: [...this.aliases] });
+    }
+    getKeyOrFail() {
+        if (!this.key) {
+            throw new DependencyMissingKeyError_1.DependencyMissingKeyError('No key provided for registration');
+        }
+        return this.key;
+    }
+}
+exports.Registration = Registration;

package/cjm/select.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.select = void 0;
+const GroupAliasToken_1 = require("./token/GroupAliasToken");
+const FunctionToken_1 = require("./token/FunctionToken");
+const GroupInstanceToken_1 = require("./token/GroupInstanceToken");
+const toToken_1 = require("./token/toToken");
+exports.select = {
+    alias: GroupAliasToken_1.toGroupAlias,
+    token: toToken_1.toToken,
+    instances: (predicate = () => true) => new GroupInstanceToken_1.GroupInstanceToken(predicate),
+    scope: {
+        current: new FunctionToken_1.FunctionToken((s) => s),
+        create: (options) => new FunctionToken_1.FunctionToken((s) => s.createScope(options)),
+    },
+};

package/cjm/token/BindToken.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBindToken = isBindToken;
+const basic_1 = require("../utils/basic");
+function isBindToken(token) {
+    return !basic_1.Is.nullish(token) && typeof token === 'object' && 'bindTo' in token;
+}

package/cjm/token/ClassToken.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassToken = void 0;
+const InjectionToken_1 = require("./InjectionToken");
+class ClassToken extends InjectionToken_1.InjectionToken {
+    target;
+    _getArgsFn;
+    _isLazy;
+    constructor(target, { getArgsFn = () => [], isLazy = false } = {}) {
+        super();
+        this.target = target;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
+    }
+    select(fn) {
+        return (s) => fn(this.resolve(s));
+    }
+    resolve(s, { args = [], lazy } = {}) {
+        return s.resolve(this.target, {
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
+        });
+    }
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
+        return new ClassToken(this.target, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
+        });
+    }
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
+        return new ClassToken(this.target, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
+        });
+    }
+    lazy() {
+        return new ClassToken(this.target, {
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
+        });
+    }
+}
+exports.ClassToken = ClassToken;

package/cjm/token/ConstantToken.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantToken = void 0;
+const InjectionToken_1 = require("./InjectionToken");
+const MethodNotImplementedError_1 = require("../errors/MethodNotImplementedError");
+class ConstantToken extends InjectionToken_1.InjectionToken {
+    token;
+    constructor(token) {
+        super();
+        this.token = token;
+    }
+    resolve(s) {
+        return this.token;
+    }
+    args(...deps) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
+    }
+    argsFn(getArgsFn) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
+    }
+    lazy() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
+    }
+}
+exports.ConstantToken = ConstantToken;