ts-ioc-container 41.1.2 → 41.3.0

package/cjm/DepKey.js

@@ -1,12 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.depKey = exports.isDepKey = void 0;
+exports.depKey = void 0;
 const Registration_1 = require("./registration/Registration");
 const Provider_1 = require("./provider/Provider");
-const isDepKey = (key) => {
-    return typeof key === 'object' && key !== null && 'key' in key;
-};
-exports.isDepKey = isDepKey;
 const depKey = (key) => {
     const scopePredicates = [];
     const mappers = [];

package/cjm/container/Container.js

@@ -44,12 +44,14 @@ class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
-    resolveClass(token, { args = [] } = {}) {
+    resolveClass(token, options) {
         this.validateContainer();
-        const instance = this.injector.resolve(this, token, { args });
-        this.instances.add(instance);
-        this.onConstruct(instance, this);
-        return instance;
+        return (0, utils_1.toLazyIf)(() => {
+            const instance = this.injector.resolve(this, token, options);
+            this.instances.add(instance);
+            this.onConstruct(instance, this);
+            return instance;
+        }, options?.lazy);
     }
     resolveOne(keyOrAlias, options) {
         return this.resolveOneStrategy(this, keyOrAlias, options);

package/cjm/container/IContainer.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_CONTAINER_RESOLVER = void 0;
-exports.isDependencyKey = isDependencyKey;
 const utils_1 = require("../utils");
 const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
-function isDependencyKey(token) {
-    return ['string', 'symbol'].includes(typeof token);
-}
 const DEFAULT_CONTAINER_RESOLVER = (scope, keyOrAlias, options) => {
-    if ((0, utils_1.isConstructor)(keyOrAlias)) {
+    if (utils_1.Is.constructor(keyOrAlias)) {
         return scope.resolveClass(keyOrAlias, options);
     }
     try {

package/cjm/hooks/hook.js

@@ -8,7 +8,7 @@ const utils_1 = require("../utils");
 const UnexpectedHookResultError_1 = require("../errors/UnexpectedHookResultError");
 const inject_1 = require("../injector/inject");
 const isHookClassConstructor = (execute) => {
-    return (0, utils_1.isConstructor)(execute) && execute.prototype.execute;
+    return utils_1.Is.constructor(execute) && execute.prototype.execute;
 };
 const toHookFn = (execute) => isHookClassConstructor(execute) ? (context) => context.scope.resolveOne(execute).execute(context) : execute;
 exports.toHookFn = toHookFn;

package/cjm/index.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.depKey = exports.by = exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.HookContext = exports.runOnDisposeHooks = exports.runOnConstructHooks = exports.onConstruct = exports.onDispose = exports.injectProp = exports.runHooksAsync = exports.runHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.asAlias = exports.asKey = exports.decorate = exports.MultiCache = exports.multiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.resolveArgs = exports.inject = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
-// Containers
-var IContainer_1 = require("./container/IContainer");
-Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
+exports.depKey = exports.Is = exports.by = exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.HookContext = exports.runOnDisposeHooks = exports.runOnConstructHooks = exports.onConstruct = exports.onDispose = exports.injectProp = exports.runHooksAsync = exports.runHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.asAlias = exports.asKey = exports.decorate = exports.MultiCache = exports.multiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.resolveArgs = exports.inject = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = void 0;
 var Container_1 = require("./container/Container");
 Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return Container_1.Container; } });
 var EmptyContainer_1 = require("./container/EmptyContainer");
@@ -79,5 +76,7 @@ Object.defineProperty(exports, "getParameterMetadata", { enumerable: true, get:
 // Others
 var resolve_1 = require("./resolve");
 Object.defineProperty(exports, "by", { enumerable: true, get: function () { return resolve_1.by; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "Is", { enumerable: true, get: function () { return utils_1.Is; } });
 var DepKey_1 = require("./DepKey");
 Object.defineProperty(exports, "depKey", { enumerable: true, get: function () { return DepKey_1.depKey; } });

package/cjm/injector/IInjector.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = void 0;
+class Injector {
+    resolve(scope, Target, options) {
+        return this.createInstance(scope, Target, options);
+    }
+}
+exports.Injector = Injector;

package/cjm/injector/MetadataInjector.js

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

package/cjm/injector/ProxyInjector.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyInjector = void 0;
+const IInjector_1 = require("./IInjector");
 function getProp(target, key) {
     // @ts-ignore
     return target[key];
 }
-class ProxyInjector {
-    resolve(container, Target, { args: deps }) {
+class ProxyInjector extends IInjector_1.Injector {
+    createInstance(scope, Target, { args: deps = [] } = {}) {
         const args = deps.reduce((acc, it) => ({ ...acc, ...it }), {});
         const proxy = new Proxy({}, {
             get(target, prop) {
@@ -14,8 +15,8 @@ class ProxyInjector {
                 return args.hasOwnProperty(prop)
                     ? getProp(args, prop)
                     : prop.toString().search(/array/gi) >= 0
-                        ? container.resolveMany(prop)
-                        : container.resolveOne(prop);
+                        ? scope.resolveMany(prop)
+                        : scope.resolveOne(prop);
             },
         });
         return new Target(proxy);

package/cjm/injector/SimpleInjector.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleInjector = void 0;
-class SimpleInjector {
-    resolve(container, Target, { args: deps }) {
-        return new Target(container, ...deps);
+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/injector/inject.js

@@ -4,10 +4,9 @@ exports.resolveArgs = exports.toInjectFn = exports.inject = void 0;
 exports.isInjectBuilder = isInjectBuilder;
 const metadata_1 = require("../metadata");
 const utils_1 = require("../utils");
-const IContainer_1 = require("../container/IContainer");
 const HookContext_1 = require("../hooks/HookContext");
 const inject = (fn) => (target, propertyKey, parameterIndex) => {
-    (0, metadata_1.setParameterMetadata)((0, HookContext_1.hookMetaKey)(propertyKey), (0, exports.toInjectFn)(fn))((0, utils_1.isInstance)(target) ? target.constructor : target, propertyKey, parameterIndex);
+    (0, metadata_1.setParameterMetadata)((0, HookContext_1.hookMetaKey)(propertyKey), (0, exports.toInjectFn)(fn))(utils_1.Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
 };
 exports.inject = inject;
 function isInjectBuilder(fn) {
@@ -17,10 +16,10 @@ const toInjectFn = (target) => {
     if (typeof target === 'object' && isInjectBuilder(target)) {
         return (s) => target.resolve(s);
     }
-    if ((0, utils_1.isConstructor)(target)) {
+    if (utils_1.Is.constructor(target)) {
         return (scope) => scope.resolveClass(target);
     }
-    if ((0, IContainer_1.isDependencyKey)(target)) {
+    if (utils_1.Is.dependencyKey(target)) {
         return (scope) => scope.resolveOne(target);
     }
     return target;

package/cjm/provider/Provider.js

@@ -24,9 +24,10 @@ class Provider {
         const fns = mappers.map((m) => ((0, ProviderPipe_1.isProviderPipe)(m) ? m.mapProvider.bind(m) : m));
         return (0, utils_1.pipe)(...fns)(this);
     }
-    resolve(container, { args, lazy }) {
-        const resolveDependency = () => this.resolveDependency(container, { args: [...this.argsFn(container, ...args), ...args] });
-        return (lazy ?? this.isLazy) ? (0, utils_1.lazyProxy)(resolveDependency) : resolveDependency();
+    resolve(container, { args = [], lazy } = {}) {
+        return (0, utils_1.toLazyIf)(() => this.resolveDependency(container, {
+            args: [...this.argsFn(container, ...args), ...args],
+        }), lazy ?? this.isLazy);
     }
     setAccessPredicate(predicate) {
         this.checkAccess = predicate;

package/cjm/provider/SingletonProvider.js

@@ -13,7 +13,8 @@ class SingletonProvider extends IProvider_1.ProviderDecorator {
         this.cache = cache;
     }
     resolve(container, options) {
-        const key = this.cache.getKey(...options.args);
+        const { args = [] } = options;
+        const key = this.cache.getKey(...args);
         if (!this.cache.hasValue(key)) {
             this.cache.setValue(key, this.provider.resolve(container, options));
         }

package/cjm/registration/IRegistration.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asKey = exports.asAlias = exports.register = exports.getTransformers = exports.scope = void 0;
-const IContainer_1 = require("../container/IContainer");
+const utils_1 = require("../utils");
 const metadata_1 = require("../metadata");
 const ProviderPipe_1 = require("../provider/ProviderPipe");
 const scope = (...predicates) => (r) => r.when(...predicates);
@@ -11,7 +11,7 @@ const getTransformers = (Target) => (0, metadata_1.getMetadata)(Target, METADATA
 exports.getTransformers = getTransformers;
 const register = (...mappers) => (0, metadata_1.setMetadata)(METADATA_KEY, mappers.map((m) => ((0, ProviderPipe_1.isProviderPipe)(m) ? (r) => m.mapRegistration(r) : m)));
 exports.register = register;
-const asAlias = (target) => (r) => r.bindToAlias((0, IContainer_1.isDependencyKey)(target) ? target : target.key);
+const asAlias = (target) => (r) => r.bindToAlias(utils_1.Is.dependencyKey(target) ? target : target.key);
 exports.asAlias = asAlias;
 const asKey = (key) => (r) => r.bindToKey(key);
 exports.asKey = asKey;

package/cjm/registration/Registration.js

@@ -15,7 +15,7 @@ class Registration {
         return transform(new Registration(() => Provider_1.Provider.fromClass(Target), Target.name));
     }
     static fromValue(value) {
-        if ((0, utils_1.isConstructor)(value)) {
+        if (utils_1.Is.constructor(value)) {
             const transform = (0, utils_1.pipe)(...(0, IRegistration_1.getTransformers)(value));
             return transform(new Registration(() => Provider_1.Provider.fromValue(value), value.name));
         }

package/cjm/resolve.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.by = exports.InstancesResolver = exports.InjectionResolver = void 0;
-const IContainer_1 = require("./container/IContainer");
-const DepKey_1 = require("./DepKey");
+const utils_1 = require("./utils");
 class InjectionResolver {
     resolveByOptions;
     isLazy = false;
@@ -55,18 +54,18 @@ class InstancesResolver {
 exports.InstancesResolver = InstancesResolver;
 exports.by = {
     many: (target) => {
-        const alias = (0, IContainer_1.isDependencyKey)(target) ? target : target.key;
+        const alias = utils_1.Is.dependencyKey(target) ? target : target.key;
         return new InjectionResolver((s, options) => s.resolveMany(alias, options));
     },
     one: (target) => {
-        const key = (0, DepKey_1.isDepKey)(target) ? target.key : target;
+        const key = utils_1.Is.DepKey(target) ? target.key : target;
         return new InjectionResolver((s, options) => s.resolveOne(key, options));
     },
     /**
      * Use it only for optimization. Otherwise, recommended to use `by.one`
      */
     aliasOne: (target) => {
-        const alias = (0, DepKey_1.isDepKey)(target) ? target.key : target;
+        const alias = utils_1.Is.DepKey(target) ? target.key : target;
         return new InjectionResolver((s, options) => s.resolveOneByAlias(alias, options));
     },
     instances: (predicate = () => true) => new InstancesResolver(predicate),

package/cjm/utils.js

@@ -1,20 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Is = exports.Filter = exports.List = exports.promisify = exports.constant = exports.pipe = exports.isConstructor = void 0;
-exports.isInstance = isInstance;
+exports.Is = exports.Filter = exports.List = exports.promisify = exports.constant = exports.pipe = void 0;
 exports.fillEmptyIndexes = fillEmptyIndexes;
 exports.lazyProxy = lazyProxy;
-/**
- * @deprecated Use Is.constructor instead
- */
-const isConstructor = (T) => typeof T === 'function' && !!T.prototype;
-exports.isConstructor = isConstructor;
-/**
- * @deprecated Use Is.instance instead
- */
-function isInstance(target) {
-    return Object.prototype.hasOwnProperty.call(target, 'constructor');
-}
+exports.toLazyIf = toLazyIf;
 const pipe = (...mappers) => (value) => mappers.reduce((acc, current) => current(acc), value);
 exports.pipe = pipe;
 function fillEmptyIndexes(baseArr, insertArr) {
@@ -39,6 +28,12 @@ function lazyProxy(resolveInstance) {
         },
     });
 }
+function toLazyIf(resolveInstance, isLazy = false) {
+    if (isLazy) {
+        return lazyProxy(resolveInstance);
+    }
+    return resolveInstance();
+}
 const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));
 exports.promisify = promisify;
 exports.List = {
@@ -56,4 +51,7 @@ exports.Is = {
     constructor: (target) => typeof target === 'function' && !!target.prototype,
     dependencyKey: (target) => ['string', 'symbol'].includes(typeof target),
     injectBuilder: (target) => exports.Is.object(target) && 'resolve' in target && typeof target['resolve'] === 'function',
+    DepKey: (key) => {
+        return typeof key === 'object' && key !== null && 'key' in key;
+    },
 };

package/esm/DepKey.js

@@ -1,8 +1,5 @@
 import { Registration } from './registration/Registration';
 import { Provider } from './provider/Provider';
-export const isDepKey = (key) => {
-    return typeof key === 'object' && key !== null && 'key' in key;
-};
 export const depKey = (key) => {
     const scopePredicates = [];
     const mappers = [];

package/esm/container/Container.js

@@ -2,7 +2,7 @@ import { DEFAULT_CONTAINER_RESOLVER, } from './IContainer';
 import { EmptyContainer } from './EmptyContainer';
 import { ContainerDisposedError } from '../errors/ContainerDisposedError';
 import { MetadataInjector } from '../injector/MetadataInjector';
-import { Filter as F } from '../utils';
+import { Filter as F, toLazyIf } from '../utils';
 import { AliasMap } from './AliasMap';
 import { DependencyNotFoundError } from '../errors/DependencyNotFoundError';
 export class Container {
@@ -41,12 +41,14 @@ export class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
-    resolveClass(token, { args = [] } = {}) {
+    resolveClass(token, options) {
         this.validateContainer();
-        const instance = this.injector.resolve(this, token, { args });
-        this.instances.add(instance);
-        this.onConstruct(instance, this);
-        return instance;
+        return toLazyIf(() => {
+            const instance = this.injector.resolve(this, token, options);
+            this.instances.add(instance);
+            this.onConstruct(instance, this);
+            return instance;
+        }, options?.lazy);
     }
     resolveOne(keyOrAlias, options) {
         return this.resolveOneStrategy(this, keyOrAlias, options);

package/esm/container/IContainer.js

@@ -1,10 +1,7 @@
-import { isConstructor } from '../utils';
+import { Is } from '../utils';
 import { DependencyNotFoundError } from '../errors/DependencyNotFoundError';
-export function isDependencyKey(token) {
-    return ['string', 'symbol'].includes(typeof token);
-}
 export const DEFAULT_CONTAINER_RESOLVER = (scope, keyOrAlias, options) => {
-    if (isConstructor(keyOrAlias)) {
+    if (Is.constructor(keyOrAlias)) {
         return scope.resolveClass(keyOrAlias, options);
     }
     try {

package/esm/hooks/hook.js

@@ -1,9 +1,9 @@
 import { createHookContext } from './HookContext';
-import { isConstructor, promisify } from '../utils';
+import { Is, promisify } from '../utils';
 import { UnexpectedHookResultError } from '../errors/UnexpectedHookResultError';
 import { toInjectFn } from '../injector/inject';
 const isHookClassConstructor = (execute) => {
-    return isConstructor(execute) && execute.prototype.execute;
+    return Is.constructor(execute) && execute.prototype.execute;
 };
 export const toHookFn = (execute) => isHookClassConstructor(execute) ? (context) => context.scope.resolveOne(execute).execute(context) : execute;
 export const hook = (key, ...fns) => (target, propertyKey) => {

package/esm/index.js

@@ -1,5 +1,3 @@
-// Containers
-export { isDependencyKey, } from './container/IContainer';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
@@ -29,4 +27,5 @@ export { HookContext } from './hooks/HookContext';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';
 // Others
 export { by } from './resolve';
+export { Is } from './utils';
 export { depKey } from './DepKey';

package/esm/injector/IInjector.js

@@ -1 +1,5 @@
-export {};
+export class Injector {
+    resolve(scope, Target, options) {
+        return this.createInstance(scope, Target, options);
+    }
+}

package/esm/injector/MetadataInjector.js

@@ -1,6 +1,7 @@
+import { Injector } from './IInjector';
 import { resolveArgs } from './inject';
-export class MetadataInjector {
-    resolve(scope, Target, { args: deps }) {
+export class MetadataInjector extends Injector {
+    createInstance(scope, Target, { args: deps = [] } = {}) {
         const args = resolveArgs(Target)(scope, ...deps);
         return new Target(...args);
     }

package/esm/injector/ProxyInjector.js

@@ -1,9 +1,10 @@
+import { Injector } from './IInjector';
 function getProp(target, key) {
     // @ts-ignore
     return target[key];
 }
-export class ProxyInjector {
-    resolve(container, Target, { args: deps }) {
+export class ProxyInjector extends Injector {
+    createInstance(scope, Target, { args: deps = [] } = {}) {
         const args = deps.reduce((acc, it) => ({ ...acc, ...it }), {});
         const proxy = new Proxy({}, {
             get(target, prop) {
@@ -11,8 +12,8 @@ export class ProxyInjector {
                 return args.hasOwnProperty(prop)
                     ? getProp(args, prop)
                     : prop.toString().search(/array/gi) >= 0
-                        ? container.resolveMany(prop)
-                        : container.resolveOne(prop);
+                        ? scope.resolveMany(prop)
+                        : scope.resolveOne(prop);
             },
         });
         return new Target(proxy);

package/esm/injector/SimpleInjector.js

@@ -1,5 +1,6 @@
-export class SimpleInjector {
-    resolve(container, Target, { args: deps }) {
-        return new Target(container, ...deps);
+import { Injector } from './IInjector';
+export class SimpleInjector extends Injector {
+    createInstance(container, Target, { args = [] } = {}) {
+        return new Target(container, ...args);
     }
 }

package/esm/injector/inject.js

@@ -1,9 +1,8 @@
 import { getParameterMetadata, setParameterMetadata } from '../metadata';
-import { constant, fillEmptyIndexes, isConstructor, isInstance } from '../utils';
-import { isDependencyKey } from '../container/IContainer';
+import { constant, fillEmptyIndexes, Is } from '../utils';
 import { hookMetaKey } from '../hooks/HookContext';
 export const inject = (fn) => (target, propertyKey, parameterIndex) => {
-    setParameterMetadata(hookMetaKey(propertyKey), toInjectFn(fn))(isInstance(target) ? target.constructor : target, propertyKey, parameterIndex);
+    setParameterMetadata(hookMetaKey(propertyKey), toInjectFn(fn))(Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
 };
 export function isInjectBuilder(fn) {
     return 'resolve' in fn && typeof fn['resolve'] === 'function';
@@ -12,10 +11,10 @@ export const toInjectFn = (target) => {
     if (typeof target === 'object' && isInjectBuilder(target)) {
         return (s) => target.resolve(s);
     }
-    if (isConstructor(target)) {
+    if (Is.constructor(target)) {
         return (scope) => scope.resolveClass(target);
     }
-    if (isDependencyKey(target)) {
+    if (Is.dependencyKey(target)) {
         return (scope) => scope.resolveOne(target);
     }
     return target;

package/esm/provider/Provider.js

@@ -1,4 +1,4 @@
-import { lazyProxy, pipe } from '../utils';
+import { pipe, toLazyIf } from '../utils';
 import { isProviderPipe } from './ProviderPipe';
 export class Provider {
     resolveDependency;
@@ -21,9 +21,10 @@ export class Provider {
         const fns = mappers.map((m) => (isProviderPipe(m) ? m.mapProvider.bind(m) : m));
         return pipe(...fns)(this);
     }
-    resolve(container, { args, lazy }) {
-        const resolveDependency = () => this.resolveDependency(container, { args: [...this.argsFn(container, ...args), ...args] });
-        return (lazy ?? this.isLazy) ? lazyProxy(resolveDependency) : resolveDependency();
+    resolve(container, { args = [], lazy } = {}) {
+        return toLazyIf(() => this.resolveDependency(container, {
+            args: [...this.argsFn(container, ...args), ...args],
+        }), lazy ?? this.isLazy);
     }
     setAccessPredicate(predicate) {
         this.checkAccess = predicate;

package/esm/provider/SingletonProvider.js

@@ -10,7 +10,8 @@ export class SingletonProvider extends ProviderDecorator {
         this.cache = cache;
     }
     resolve(container, options) {
-        const key = this.cache.getKey(...options.args);
+        const { args = [] } = options;
+        const key = this.cache.getKey(...args);
         if (!this.cache.hasValue(key)) {
             this.cache.setValue(key, this.provider.resolve(container, options));
         }

package/esm/registration/IRegistration.js

@@ -1,9 +1,9 @@
-import { isDependencyKey } from '../container/IContainer';
+import { Is } from '../utils';
 import { getMetadata, setMetadata } from '../metadata';
 import { isProviderPipe } from '../provider/ProviderPipe';
 export const scope = (...predicates) => (r) => r.when(...predicates);
 const METADATA_KEY = 'registration';
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];
 export const register = (...mappers) => setMetadata(METADATA_KEY, mappers.map((m) => (isProviderPipe(m) ? (r) => m.mapRegistration(r) : m)));
-export const asAlias = (target) => (r) => r.bindToAlias(isDependencyKey(target) ? target : target.key);
+export const asAlias = (target) => (r) => r.bindToAlias(Is.dependencyKey(target) ? target : target.key);
 export const asKey = (key) => (r) => r.bindToKey(key);

package/esm/registration/Registration.js

@@ -1,4 +1,4 @@
-import { isConstructor, pipe } from '../utils';
+import { Is, pipe } from '../utils';
 import { Provider } from '../provider/Provider';
 import { DependencyMissingKeyError } from '../errors/DependencyMissingKeyError';
 import { getTransformers } from './IRegistration';
@@ -12,7 +12,7 @@ export class Registration {
         return transform(new Registration(() => Provider.fromClass(Target), Target.name));
     }
     static fromValue(value) {
-        if (isConstructor(value)) {
+        if (Is.constructor(value)) {
             const transform = pipe(...getTransformers(value));
             return transform(new Registration(() => Provider.fromValue(value), value.name));
         }

package/esm/resolve.js

@@ -1,5 +1,4 @@
-import { isDependencyKey, } from './container/IContainer';
-import { isDepKey } from './DepKey';
+import { Is } from './utils';
 export class InjectionResolver {
     resolveByOptions;
     isLazy = false;
@@ -50,18 +49,18 @@ export class InstancesResolver {
 }
 export const by = {
     many: (target) => {
-        const alias = isDependencyKey(target) ? target : target.key;
+        const alias = Is.dependencyKey(target) ? target : target.key;
         return new InjectionResolver((s, options) => s.resolveMany(alias, options));
     },
     one: (target) => {
-        const key = isDepKey(target) ? target.key : target;
+        const key = Is.DepKey(target) ? target.key : target;
         return new InjectionResolver((s, options) => s.resolveOne(key, options));
     },
     /**
      * Use it only for optimization. Otherwise, recommended to use `by.one`
      */
     aliasOne: (target) => {
-        const alias = isDepKey(target) ? target.key : target;
+        const alias = Is.DepKey(target) ? target.key : target;
         return new InjectionResolver((s, options) => s.resolveOneByAlias(alias, options));
     },
     instances: (predicate = () => true) => new InstancesResolver(predicate),

package/esm/utils.js

@@ -1,13 +1,3 @@
-/**
- * @deprecated Use Is.constructor instead
- */
-export const isConstructor = (T) => typeof T === 'function' && !!T.prototype;
-/**
- * @deprecated Use Is.instance instead
- */
-export function isInstance(target) {
-    return Object.prototype.hasOwnProperty.call(target, 'constructor');
-}
 export const pipe = (...mappers) => (value) => mappers.reduce((acc, current) => current(acc), value);
 export function fillEmptyIndexes(baseArr, insertArr) {
     const a = [...baseArr];
@@ -30,6 +20,12 @@ export function lazyProxy(resolveInstance) {
         },
     });
 }
+export function toLazyIf(resolveInstance, isLazy = false) {
+    if (isLazy) {
+        return lazyProxy(resolveInstance);
+    }
+    return resolveInstance();
+}
 export const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));
 export const List = {
     lastOf: (arr) => arr[arr.length - 1],
@@ -46,4 +42,7 @@ export const Is = {
     constructor: (target) => typeof target === 'function' && !!target.prototype,
     dependencyKey: (target) => ['string', 'symbol'].includes(typeof target),
     injectBuilder: (target) => Is.object(target) && 'resolve' in target && typeof target['resolve'] === 'function',
+    DepKey: (key) => {
+        return typeof key === 'object' && key !== null && 'key' in key;
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "41.1.2",
+  "version": "41.3.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",

package/typings/DepKey.d.ts

@@ -12,5 +12,4 @@ export type DepKey<T> = IInjectFnResolver<T> & {
     when(value: ScopePredicate): DepKey<T>;
     asAlias: (registration: IRegistration<T>) => IRegistration<T>;
 };
-export declare const isDepKey: <T>(key: unknown) => key is DepKey<T>;
 export declare const depKey: <T>(key: DependencyKey) => DepKey<T>;

package/typings/container/AutoMockedContainer.d.ts

@@ -1,6 +1,7 @@
 import { type DependencyKey, type IContainer, type Instance, type ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer';
 import { type IRegistration } from '../registration/IRegistration';
 import { type constructor } from '../utils';
+import { InjectOptions } from '../injector/IInjector';
 export declare abstract class AutoMockedContainer implements IContainer {
     isDisposed: boolean;
     createScope(): IContainer;
@@ -15,9 +16,7 @@ export declare abstract class AutoMockedContainer implements IContainer {
     getRegistrations(): never[];
     addRegistration(registration: IRegistration): this;
     abstract resolveMany<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
-    abstract resolveClass<T>(target: constructor<T>, options?: {
-        args?: unknown[];
-    }): T;
+    abstract resolveClass<T>(target: constructor<T>, options?: InjectOptions): T;
     abstract resolveOneByKey<T>(keyOrAlias: DependencyKey, options?: ResolveOneOptions): T;
     abstract resolveOneByAlias<T>(keyOrAlias: DependencyKey, options?: ResolveOneOptions): T;
     abstract resolveOne<T>(alias: constructor<T> | DependencyKey, options?: ResolveManyOptions): T;

package/typings/container/Container.d.ts

@@ -1,6 +1,6 @@
 import { type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type Instance, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer';
 import { type IInjector } from '../injector/IInjector';
-import { type IProvider } from '../provider/IProvider';
+import { type IProvider, ProviderOptions } from '../provider/IProvider';
 import { type IRegistration } from '../registration/IRegistration';
 import { type constructor } from '../utils';
 type ResolveOneStrategy = <T>(scope: IContainer, keyOrAlias: constructor<T> | DependencyKey, options?: ResolveOneOptions) => T;
@@ -28,9 +28,7 @@ export declare class Container implements IContainer {
     register(key: DependencyKey, provider: IProvider, { aliases }?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
-    resolveClass<T>(token: constructor<T>, { args }?: {
-        args?: unknown[];
-    }): T;
+    resolveClass<T>(token: constructor<T>, options?: ProviderOptions): T;
     resolveOne<T>(keyOrAlias: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
     resolveOneByKey<T>(keyOrAlias: DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;
     resolveOneByAlias<T>(keyOrAlias: DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;

package/typings/container/EmptyContainer.d.ts

@@ -2,12 +2,11 @@ import { type DependencyKey, type IContainer, type IContainerModule, type Resolv
 import { type IProvider } from '../provider/IProvider';
 import { type IRegistration } from '../registration/IRegistration';
 import { type constructor } from '../utils';
+import { InjectOptions } from '../injector/IInjector';
 export declare class EmptyContainer implements IContainer {
     get isDisposed(): boolean;
     getParent(): undefined;
-    resolveClass<T>(token: constructor<T>, options?: {
-        args?: [];
-    }): T;
+    resolveClass<T>(token: constructor<T>, options?: InjectOptions): T;
     getScopes(): never[];
     getInstances(): never[];
     createScope(): IContainer;

package/typings/container/IContainer.d.ts

@@ -1,18 +1,17 @@
-import { type IProvider } from '../provider/IProvider';
+import { type IProvider, ProviderOptions } from '../provider/IProvider';
 import { type constructor } from '../utils';
 import { type IRegistration } from '../registration/IRegistration';
 export type Tag = string;
 export type DependencyKey = string | symbol;
-export declare function isDependencyKey(token: unknown): token is DependencyKey;
 export type InjectionToken<T = unknown> = constructor<T> | DependencyKey;
-export type ResolveOneOptions = {
-    args?: unknown[];
-    child?: Tagged;
-    lazy?: boolean;
+type WithChild = {
+    child: Tagged;
 };
-export type ResolveManyOptions = ResolveOneOptions & {
-    excludedKeys?: Set<DependencyKey>;
+export type ResolveOneOptions = ProviderOptions & Partial<WithChild>;
+type WithExcludedKeys = {
+    excludedKeys: Set<DependencyKey>;
 };
+export type ResolveManyOptions = ResolveOneOptions & Partial<WithExcludedKeys>;
 export interface Resolvable {
     resolve<T>(key: InjectionToken<T>, options?: ResolveOneOptions): T;
 }
@@ -22,9 +21,10 @@ export interface IContainerModule {
 export interface Tagged {
     hasTag(tag: Tag): boolean;
 }
-export type CreateScopeOptions = {
-    tags?: Tag[];
+type WithTags = {
+    tags: Tag[];
 };
+export type CreateScopeOptions = Partial<WithTags>;
 export interface Instance<T = unknown> {
     new (...args: unknown[]): T;
 }
@@ -36,9 +36,7 @@ export interface IContainer extends Tagged {
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
-    resolveClass<T>(target: constructor<T>, options?: {
-        args?: unknown[];
-    }): T;
+    resolveClass<T>(target: constructor<T>, options?: ProviderOptions): T;
     resolveOne<T>(alias: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
     resolveOneByKey<T>(key: DependencyKey, options?: ResolveOneOptions): T;
     resolveOneByAlias<T>(key: DependencyKey, options?: ResolveOneOptions): T;
@@ -52,3 +50,4 @@ export interface IContainer extends Tagged {
     dispose(): void;
 }
 export declare const DEFAULT_CONTAINER_RESOLVER: <T>(scope: IContainer, keyOrAlias: constructor<T> | DependencyKey, options?: ResolveOneOptions) => T;
+export {};

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-export { type IContainer, type Resolvable, type IContainerModule, isDependencyKey, type DependencyKey, type InjectionToken, type Tag, type Tagged, type Instance, } from './container/IContainer';
+export { type IContainer, type Resolvable, type IContainerModule, type DependencyKey, type InjectionToken, type Tag, type Tagged, type Instance, } from './container/IContainer';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
@@ -7,7 +7,7 @@ export { type IInjector, type InjectOptions } from './injector/IInjector';
 export { MetadataInjector } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
-export { type ResolveDependency, type IProvider, scopeAccess, lazy, argsFn, args, type ArgsFn, ProviderDecorator, type ProviderResolveOptions, type IMapper, } from './provider/IProvider';
+export { type ResolveDependency, type IProvider, scopeAccess, lazy, argsFn, args, type ArgsFn, ProviderDecorator, type IMapper, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { singleton, SingletonProvider } from './provider/SingletonProvider';
 export { type Cache, multiCache, MultiCache } from './provider/Cache';
@@ -23,6 +23,6 @@ export { getHooks, hook, hasHooks, type HookFn, type HookClass, runHooks, runHoo
 export { HookContext, type InjectFn, type IHookContext } from './hooks/HookContext';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';
 export { by } from './resolve';
-export { type constructor } from './utils';
+export { type constructor, Is } from './utils';
 export { depKey, type DepKey } from './DepKey';
 export { type InstancePredicate } from './resolve';

package/typings/injector/IInjector.d.ts

@@ -1,11 +1,17 @@
 import { type constructor } from '../utils';
 import { type IContainer, ResolveOneOptions } from '../container/IContainer';
-export type InjectOptions = {
+type WithArgs = {
     args: unknown[];
 };
+export type InjectOptions = Partial<WithArgs>;
 export interface IInjector {
-    resolve<T>(container: IContainer, value: constructor<T>, options: InjectOptions): T;
+    resolve<T>(container: IContainer, value: constructor<T>, options?: InjectOptions): T;
 }
 export interface IInjectFnResolver<T> {
     resolve(s: IContainer, options?: ResolveOneOptions): T;
 }
+export declare abstract class Injector implements IInjector {
+    resolve<T>(scope: IContainer, Target: constructor<T>, options?: InjectOptions): T;
+    protected abstract createInstance<T>(scope: IContainer, Target: constructor<T>, options?: InjectOptions): T;
+}
+export {};

package/typings/injector/MetadataInjector.d.ts

@@ -1,6 +1,6 @@
-import type { IInjector, InjectOptions } from './IInjector';
+import { InjectOptions, Injector } from './IInjector';
 import type { IContainer } from '../container/IContainer';
 import type { constructor } from '../utils';
-export declare class MetadataInjector implements IInjector {
-    resolve<T>(scope: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
+export declare class MetadataInjector extends Injector {
+    protected createInstance<T>(scope: IContainer, Target: constructor<T>, { args: deps }?: InjectOptions): T;
 }

package/typings/injector/ProxyInjector.d.ts

@@ -1,6 +1,6 @@
-import type { IInjector, InjectOptions } from './IInjector';
+import { InjectOptions, Injector } from './IInjector';
 import type { IContainer } from '../container/IContainer';
 import type { constructor } from '../utils';
-export declare class ProxyInjector implements IInjector {
-    resolve<T>(container: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
+export declare class ProxyInjector extends Injector {
+    protected createInstance<T>(scope: IContainer, Target: constructor<T>, { args: deps }?: InjectOptions): T;
 }

package/typings/injector/SimpleInjector.d.ts

@@ -1,6 +1,6 @@
-import type { IInjector, InjectOptions } from './IInjector';
+import { InjectOptions, Injector } from './IInjector';
 import type { IContainer } from '../container/IContainer';
-import type { constructor } from '../utils';
-export declare class SimpleInjector implements IInjector {
-    resolve<T>(container: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
+import { constructor } from '../utils';
+export declare class SimpleInjector extends Injector {
+    protected createInstance<T>(container: IContainer, Target: constructor<T>, { args }?: InjectOptions): T;
 }

package/typings/provider/DecoratorProvider.d.ts

@@ -1,11 +1,12 @@
 import type { IContainer } from '../container/IContainer';
-import type { IProvider, ProviderResolveOptions } from './IProvider';
+import type { IProvider } from './IProvider';
 import { ProviderDecorator } from './IProvider';
+import { InjectOptions } from '../injector/IInjector';
 export type DecorateFn<Instance = any> = (dep: Instance, scope: IContainer) => Instance;
 export declare class DecoratorProvider<Instance> extends ProviderDecorator<Instance> {
     private provider;
     private decorateFn;
     constructor(provider: IProvider<Instance>, decorateFn: DecorateFn<Instance>);
-    resolve(scope: IContainer, options: ProviderResolveOptions): Instance;
+    resolve(scope: IContainer, options: InjectOptions): Instance;
 }
 export declare const decorate: (decorateFn: DecorateFn) => import("./ProviderPipe").ProviderPipe<unknown>;

package/typings/provider/IProvider.d.ts

@@ -1,22 +1,23 @@
 import { IContainer, Tagged } from '../container/IContainer';
 import { MapFn } from '../utils';
 import { ProviderPipe } from './ProviderPipe';
-export type ProviderResolveOptions = {
-    args: unknown[];
-    lazy?: boolean;
+import { InjectOptions } from '../injector/IInjector';
+export type WithLazy = {
+    lazy: boolean;
 };
-export type ResolveDependency<T = unknown> = (container: IContainer, options: ProviderResolveOptions) => T;
+export type ProviderOptions = InjectOptions & Partial<WithLazy>;
+export type ResolveDependency<T = unknown> = (container: IContainer, options: InjectOptions) => T;
 export type ScopeAccessOptions = {
     invocationScope: Tagged;
     providerScope: Tagged;
 };
 export type ScopeAccessFn = (options: ScopeAccessOptions) => boolean;
 export type ArgsFn = (l: IContainer, ...args: unknown[]) => unknown[];
-export interface IMapper<T> {
+export interface IMapper {
     mapItem<T>(target: IProvider<T>): IProvider<T>;
 }
 export interface IProvider<T = any> {
-    resolve(container: IContainer, options: ProviderResolveOptions): T;
+    resolve(container: IContainer, options: ProviderOptions): T;
     hasAccess(options: ScopeAccessOptions): boolean;
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
     setAccessPredicate(hasAccessWhen: ScopeAccessFn): this;
@@ -33,7 +34,7 @@ export declare abstract class ProviderDecorator<T> implements IProvider<T> {
     protected constructor(decorated: IProvider<T>);
     setAccessPredicate(predicate: ScopeAccessFn): this;
     hasAccess(options: ScopeAccessOptions): boolean;
-    resolve(container: IContainer, options: ProviderResolveOptions): T;
+    resolve(container: IContainer, options: ProviderOptions): T;
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
     setArgs(argsFn: ArgsFn): this;
     lazy(): this;

package/typings/provider/Provider.d.ts

@@ -1,6 +1,6 @@
-import { ScopeAccessOptions, ArgsFn, ScopeAccessFn, IProvider, ProviderResolveOptions, ResolveDependency } from './IProvider';
+import { ArgsFn, IProvider, ProviderOptions, ResolveDependency, ScopeAccessFn, ScopeAccessOptions } from './IProvider';
 import type { DependencyKey, IContainer } from '../container/IContainer';
-import type { constructor, MapFn } from '../utils';
+import { constructor, MapFn } from '../utils';
 import type { ProviderPipe } from './ProviderPipe';
 export declare class Provider<T = any> implements IProvider<T> {
     private readonly resolveDependency;
@@ -12,7 +12,7 @@ export declare class Provider<T = any> implements IProvider<T> {
     private isLazy;
     constructor(resolveDependency: ResolveDependency<T>);
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
-    resolve(container: IContainer, { args, lazy }: ProviderResolveOptions): T;
+    resolve(container: IContainer, { args, lazy }?: ProviderOptions): T;
     setAccessPredicate(predicate: ScopeAccessFn): this;
     lazy(): this;
     setArgs(argsFn: ArgsFn): this;

package/typings/provider/SingletonProvider.d.ts

@@ -1,11 +1,12 @@
 import type { IContainer } from '../container/IContainer';
-import type { IProvider, ProviderResolveOptions } from './IProvider';
+import type { IProvider } from './IProvider';
 import { ProviderDecorator } from './IProvider';
 import type { Cache } from './Cache';
+import { InjectOptions } from '../injector/IInjector';
 export declare class SingletonProvider<T> extends ProviderDecorator<T> {
     private readonly provider;
     private readonly cache;
     constructor(provider: IProvider<T>, cache: Cache<unknown, T>);
-    resolve(container: IContainer, options: ProviderResolveOptions): T;
+    resolve(container: IContainer, options: InjectOptions): T;
 }
 export declare const singleton: <T = unknown>(cacheProvider?: () => Cache<unknown, T>) => import("./ProviderPipe").ProviderPipe<T>;

package/typings/registration/IRegistration.d.ts

@@ -1,5 +1,5 @@
 import type { DependencyKey, IContainer, IContainerModule } from '../container/IContainer';
-import type { constructor, MapFn } from '../utils';
+import { constructor, MapFn } from '../utils';
 import type { IProvider } from '../provider/IProvider';
 import type { DepKey } from '../DepKey';
 import { ProviderPipe } from '../provider/ProviderPipe';

package/typings/registration/Registration.d.ts

@@ -1,5 +1,5 @@
 import type { DependencyKey, IContainer } from '../container/IContainer';
-import type { constructor, MapFn } from '../utils';
+import { constructor, MapFn } from '../utils';
 import type { IProvider, ResolveDependency } from '../provider/IProvider';
 import type { IRegistration, ScopePredicate } from './IRegistration';
 import type { ProviderPipe } from '../provider/ProviderPipe';

package/typings/resolve.d.ts

@@ -2,17 +2,14 @@ import { type CreateScopeOptions, type DependencyKey, type IContainer, type Inst
 import { type constructor } from './utils';
 import { type DepKey } from './DepKey';
 import type { IInjectFnResolver } from './injector/IInjector';
+import { ProviderOptions } from './provider/IProvider';
 export type InstancePredicate = (dep: unknown) => boolean;
-export type InjectOptions = {
-    lazy: boolean;
-    args: unknown[];
-};
 export type ArgsFn = (l: IContainer) => unknown[];
 export declare class InjectionResolver<T> {
     private resolveByOptions;
     private isLazy;
     private getArgs;
-    constructor(resolveByOptions: (s: IContainer, options: InjectOptions) => T);
+    constructor(resolveByOptions: (s: IContainer, options: ProviderOptions) => T);
     args(...deps: unknown[]): this;
     argsFn(fn: ArgsFn): this;
     lazy(): this;

package/typings/utils.d.ts

@@ -1,22 +1,16 @@
 import { DependencyKey } from './container/IContainer';
 import { IInjectFnResolver } from './injector/IInjector';
+import { DepKey } from './DepKey';
 export type constructor<T> = new (...args: any[]) => T;
-/**
- * @deprecated Use Is.constructor instead
- */
-export declare const isConstructor: (T: unknown) => T is constructor<unknown>;
 export interface InstanceOfClass<T = unknown> {
     new (...args: unknown[]): T;
 }
-/**
- * @deprecated Use Is.instance instead
- */
-export declare function isInstance(target: object): target is InstanceOfClass;
 export type MapFn<T> = (value: T) => T;
 export declare const pipe: <T>(...mappers: MapFn<T>[]) => MapFn<T>;
 export declare function fillEmptyIndexes<T>(baseArr: (T | undefined)[], insertArr: T[]): T[];
 export declare const constant: <T>(value: T) => () => T;
 export declare function lazyProxy<T>(resolveInstance: () => T): T;
+export declare function toLazyIf<T>(resolveInstance: () => T, isLazy?: boolean): T;
 export declare const promisify: <T>(arg: T | Promise<T>) => Promise<T>;
 export declare const List: {
     lastOf: <T>(arr: T[]) => T;
@@ -30,4 +24,5 @@ export declare const Is: {
     constructor: (target: unknown) => target is constructor<unknown>;
     dependencyKey: (target: unknown) => target is DependencyKey;
     injectBuilder: (target: unknown) => target is IInjectFnResolver<unknown>;
+    DepKey: <T>(key: unknown) => key is DepKey<T>;
 };