ts-ioc-container 41.1.0 → 41.1.2

package/README.md

@@ -84,7 +84,6 @@ And `tsconfig.json` should have next options:
 ### Basic usage
 
 ```typescript
-import 'reflect-metadata';
 import { type IContainer, by, Container, inject, Registration as R } from 'ts-ioc-container';
 
 describe('Basic usage', function () {
@@ -125,7 +124,6 @@ Sometimes you need to create a scope of container. For example, when you want to
 - NOTICE: when you create a scope then we clone ONLY tags-matched providers.
 
 ```typescript
-import 'reflect-metadata';
 import {
   asKey,
   by,
@@ -173,7 +171,6 @@ Sometimes you want to get all instances from container and its scopes. For examp
 - you can get instances from container and scope which were created by injector
 
 ```typescript
-import 'reflect-metadata';
 import { asKey, by, Container, inject, register, Registration as R } from 'ts-ioc-container';
 
 describe('Instances', function () {
@@ -243,7 +240,6 @@ Sometimes you want to dispose container and all its scopes. For example, when yo
 - when container is disposed then it unregisters all providers and remove all instances
 
 ```typescript
-import 'reflect-metadata';
 import { by, Container, ContainerDisposedError, Registration as R } from 'ts-ioc-container';
 
 class Logger {}
@@ -369,7 +365,6 @@ This type of injector uses `@inject` decorator to mark where dependencies should
 Also you can [inject property.](#inject-property)
 
 ```typescript
-import 'reflect-metadata';
 import { Container, inject, Registration as R } from 'ts-ioc-container';
 
 class Logger {
@@ -404,7 +399,6 @@ describe('Reflection Injector', function () {
 This type of injector just passes container to constructor with others arguments.
 
 ```typescript
-import 'reflect-metadata';
 import { Container, type IContainer, Registration as R, SimpleInjector } from 'ts-ioc-container';
 
 describe('SimpleInjector', function () {
@@ -444,7 +438,6 @@ describe('SimpleInjector', function () {
 This type of injector injects dependencies as dictionary `Record<string, unknown>`.
 
 ```typescript
-import 'reflect-metadata';
 import { Container, ProxyInjector, args, Registration as R } from 'ts-ioc-container';
 
 describe('ProxyInjector', function () {
@@ -522,7 +515,6 @@ describe('ProxyInjector', function () {
     mockContainer.addRegistration(R.fromClass(Service).bindToKey('service'));
 
     const app = mockContainer.resolveOne(App);
-    console.log('App loggers:', app.loggers);
     expect(app.loggers).toBeInstanceOf(Array);
     expect(app.loggers.length).toBe(1);
     expect(app.loggers[0]).toBe(mockLogger);
@@ -542,7 +534,6 @@ Provider is dependency factory which creates dependency.
 - `new Provider((container, ...args) => container.resolve(Logger, {args}))`
 
 ```typescript
-import 'reflect-metadata';
 import {
   args,
   argsFn,
@@ -752,7 +743,7 @@ describe('Provider', () => {
     }
 
     const root = new Container({ tags: ['root'] }).addRegistration(R.fromClass(Logger));
-    const main = root.resolveByClass(Main);
+    const main = root.resolveClass(Main);
 
     expect(isLoggerCreated).toBe(false);
 
@@ -780,7 +771,7 @@ describe('Provider', () => {
     }
 
     const root = new Container({ tags: ['root'] }).addRegistration(R.fromClass(Logger));
-    const main = root.resolveByClass(Main);
+    const main = root.resolveClass(Main);
 
     expect(main.getChannel()).toBe('file');
   });
@@ -809,7 +800,7 @@ describe('Provider', () => {
       .addRegistration(R.fromValue('file').bindToKey('channel'))
       .addRegistration(R.fromClass(Logger));
 
-    const main = root.resolveByClass(Main);
+    const main = root.resolveClass(Main);
 
     expect(main.getChannel()).toBe('file');
   });
@@ -824,7 +815,6 @@ Sometimes you need to create only one instance of dependency per scope. For exam
 - NOTICE: if you create a scope 'A' of container 'root' then Logger of A !== Logger of root.
 
 ```typescript
-import 'reflect-metadata';
 import { asKey, Container, register, Registration as R, singleton } from 'ts-ioc-container';
 
 @register(asKey('logger'), singleton())
@@ -866,19 +856,20 @@ Sometimes you want to bind some arguments to provider. This is what `ArgsProvide
 - NOTICE: args from this provider has higher priority than args from `resolve` method.
 
 ```typescript
-import 'reflect-metadata';
 import {
   args,
   argsFn,
   asKey,
+  by,
   Container,
-  type DependencyKey,
+  depKey,
   inject,
   MultiCache,
   register,
   Registration as R,
   singleton,
 } from 'ts-ioc-container';
+import { resolveByArgs } from '../lib/provider/IProvider';
 
 @register(asKey('logger'))
 class Logger {
@@ -894,7 +885,7 @@ describe('ArgsProvider', function () {
   }
 
   it('can assign argument function to provider', function () {
-    const root = createContainer().addRegistration(R.fromClass(Logger).pipe(argsFn((container, ...args) => ['name'])));
+    const root = createContainer().addRegistration(R.fromClass(Logger).pipe(argsFn(() => ['name'])));
 
     const logger = root.createScope().resolveOne<Logger>('logger');
     expect(logger.name).toBe('name');
@@ -921,25 +912,34 @@ describe('ArgsProvider', function () {
       name: string;
     }
 
-    @register(asKey('UserRepository'))
+    const IUserRepositoryKey = depKey<IRepository>('IUserRepository');
+    const ITodoRepositoryKey = depKey<IRepository>('ITodoRepository');
+
+    @register(IUserRepositoryKey.asKey)
     class UserRepository implements IRepository {
       name = 'UserRepository';
     }
 
-    @register(asKey('TodoRepository'))
+    @register(ITodoRepositoryKey.asKey)
     class TodoRepository implements IRepository {
       name = 'TodoRepository';
     }
 
-    @register(asKey('EntityManager'), argsFn((container, token) => [container.resolveOne(token as DependencyKey)]))
+    interface IEntityManager {
+      repository: IRepository;
+    }
+
+    const IEntityManagerKey = depKey<IEntityManager>('IEntityManager');
+
+    @register(IEntityManagerKey.asKey, argsFn(resolveByArgs))
     class EntityManager {
       constructor(public repository: IRepository) {}
     }
 
     class Main {
       constructor(
-        @inject((s) => s.resolveOne('EntityManager', { args: ['UserRepository'] })) public userEntities: EntityManager,
-        @inject((s) => s.resolveOne('EntityManager', { args: ['TodoRepository'] })) public todoEntities: EntityManager,
+        @inject(by.one(IEntityManagerKey).args(IUserRepositoryKey)) public userEntities: EntityManager,
+        @inject(by.one(IEntityManagerKey).args(ITodoRepositoryKey)) public todoEntities: EntityManager,
       ) {}
     }
 
@@ -958,29 +958,34 @@ describe('ArgsProvider', function () {
       name: string;
     }
 
-    @register(asKey('UserRepository'))
+    const IUserRepositoryKey = depKey<IRepository>('IUserRepository');
+    const ITodoRepositoryKey = depKey<IRepository>('ITodoRepository');
+
+    @register(IUserRepositoryKey.asKey)
     class UserRepository implements IRepository {
       name = 'UserRepository';
     }
 
-    @register(asKey('TodoRepository'))
+    @register(ITodoRepositoryKey.asKey)
     class TodoRepository implements IRepository {
       name = 'TodoRepository';
     }
 
-    @register(
-      asKey('EntityManager'),
-      argsFn((container, token) => [container.resolveOne(token as DependencyKey)]),
-      singleton(() => new MultiCache((...args: unknown[]) => args[0] as DependencyKey)),
-    )
+    interface IEntityManager {
+      repository: IRepository;
+    }
+
+    const IEntityManagerKey = depKey<IEntityManager>('IEntityManager');
+
+    @register(IEntityManagerKey.asKey, argsFn(resolveByArgs), singleton(MultiCache.fromFirstArg))
     class EntityManager {
       constructor(public repository: IRepository) {}
     }
 
     class Main {
       constructor(
-        @inject((s) => s.resolveOne('EntityManager', { args: ['UserRepository'] })) public userEntities: EntityManager,
-        @inject((s) => s.resolveOne('EntityManager', { args: ['TodoRepository'] })) public todoEntities: EntityManager,
+        @inject(by.one(IEntityManagerKey).args(IUserRepositoryKey)) public userEntities: EntityManager,
+        @inject(by.one(IEntityManagerKey).args(ITodoRepositoryKey)) public todoEntities: EntityManager,
       ) {}
     }
 
@@ -990,11 +995,11 @@ describe('ArgsProvider', function () {
       .addRegistration(R.fromClass(TodoRepository));
     const main = root.resolveOne(Main);
 
-    const userRepository = root.resolveOne<EntityManager>('EntityManager', { args: ['UserRepository'] }).repository;
+    const userRepository = IEntityManagerKey.resolve(root, { args: [IUserRepositoryKey] }).repository;
     expect(userRepository).toBeInstanceOf(UserRepository);
     expect(main.userEntities.repository).toBe(userRepository);
 
-    const todoRepository = root.resolveOne<EntityManager>('EntityManager', { args: ['TodoRepository'] }).repository;
+    const todoRepository = IEntityManagerKey.resolve(root, { args: [ITodoRepositoryKey] }).repository;
     expect(todoRepository).toBeInstanceOf(TodoRepository);
     expect(main.todoEntities.repository).toBe(todoRepository);
   });
@@ -1008,7 +1013,6 @@ Sometimes you want to hide dependency if somebody wants to resolve it from certa
 - `Provider.fromClass(Logger).pipe(visible(({ isParent, child }) => isParent || child.hasTag('root')))`
 
 ```typescript
-import 'reflect-metadata';
 import {
   asKey,
   Container,
@@ -1048,7 +1052,6 @@ Alias is needed to group keys
 - `Provider.fromClass(Logger).pipe(alias('logger'))`
 
 ```typescript
-import 'reflect-metadata';
 import { asAlias, by, Container, DependencyNotFoundError, inject, register, Registration as R, scope } from 'ts-ioc-container';
 
 describe('alias', () => {
@@ -1272,7 +1275,6 @@ Sometimes you want to register provider with certain key. This is what `key` is
 - you can assign the same key to different registrations
 
 ```typescript
-import 'reflect-metadata';
 import { asAlias, asKey, Container, register, Registration as R, scope, singleton } from 'ts-ioc-container';
 import { DependencyMissingKeyError } from '../../lib/errors/DependencyMissingKeyError';
 
@@ -1333,7 +1335,6 @@ Sometimes you need to register provider only in scope which matches to certain c
 - `Registration.fromClass(Logger).when((container) => container.hasTag('root'))`
 
 ```typescript
-import 'reflect-metadata';
 import { singleton, Container, Registration as R, scope, register, asKey } from 'ts-ioc-container';
 
 @register(asKey('ILogger'), scope((s) => s.hasTag('root')), singleton())
@@ -1352,7 +1353,6 @@ describe('ScopeProvider', function () {
 Sometimes you want to encapsulate registration logic in separate module. This is what `IContainerModule` is for.
 
 ```typescript
-import 'reflect-metadata';
 import { asKey, Container, type IContainer, type IContainerModule, register, Registration as R } from 'ts-ioc-container';
 
 @register(asKey('ILogger'))
@@ -1398,7 +1398,6 @@ Sometimes you need to invoke methods after construct or dispose of class. This i
 
 ### OnConstruct
 ```typescript
-import 'reflect-metadata';
 import {
   asKey,
   type constructor,
@@ -1453,7 +1452,6 @@ describe('onConstruct', function () {
 
 ### OnDispose
 ```typescript
-import 'reflect-metadata';
 import { asKey, by, Container, hook, inject, register, Registration as R, runHooks, singleton } from 'ts-ioc-container';
 
 @register(asKey('logsRepo'), singleton())
@@ -1552,7 +1550,7 @@ export class MoqContainer extends AutoMockedContainer {
     return this.mocks.get(key) as IMock<T>;
   }
 
-  resolveByClass<T>(target: any, options?: { args?: unknown[] }): T {
+  resolveClass<T>(target: any, options?: { args?: unknown[] }): T {
     throw new Error('Method not implemented.');
   }
 

package/cjm/DepKey.js

@@ -26,7 +26,7 @@ const depKey = (key) => {
             }
             return registration;
         },
-        resolve: (s) => s.resolveOne(key),
+        resolve: (s, options) => s.resolveOne(key, options),
         pipe(...values) {
             mappers.push(...values);
             return this;

package/cjm/container/Container.js

@@ -20,12 +20,14 @@ class Container {
     onConstruct;
     onDispose;
     injector;
+    resolveOneStrategy;
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector_1.MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer_1.EmptyContainer();
         this.tags = new Set(options.tags ?? []);
         this.onConstruct = options.onConstruct ?? (() => { });
         this.onDispose = options.onDispose ?? (() => { });
+        this.resolveOneStrategy = options.resolveOneStrategy ?? IContainer_1.DEFAULT_CONTAINER_RESOLVER;
     }
     register(key, provider, { aliases = [] } = {}) {
         this.validateContainer();
@@ -42,7 +44,7 @@ class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
-    resolveByClass(token, { args = [] } = {}) {
+    resolveClass(token, { args = [] } = {}) {
         this.validateContainer();
         const instance = this.injector.resolve(this, token, { args });
         this.instances.add(instance);
@@ -50,7 +52,7 @@ class Container {
         return instance;
     }
     resolveOne(keyOrAlias, options) {
-        return (0, IContainer_1.DEFAULT_CONTAINER_RESOLVER)(this, keyOrAlias, options);
+        return this.resolveOneStrategy(this, keyOrAlias, options);
     }
     resolveOneByKey(keyOrAlias, { args = [], child = this, lazy } = {}) {
         this.validateContainer();

package/cjm/container/EmptyContainer.js

@@ -10,7 +10,7 @@ class EmptyContainer {
     getParent() {
         return undefined;
     }
-    resolveByClass(token, options) {
+    resolveClass(token, options) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
     getScopes() {

package/cjm/container/IContainer.js

@@ -9,7 +9,7 @@ function isDependencyKey(token) {
 }
 const DEFAULT_CONTAINER_RESOLVER = (scope, keyOrAlias, options) => {
     if ((0, utils_1.isConstructor)(keyOrAlias)) {
-        return scope.resolveByClass(keyOrAlias, options);
+        return scope.resolveClass(keyOrAlias, options);
     }
     try {
         return scope.resolveOneByKey(keyOrAlias, options);

package/cjm/injector/inject.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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");
@@ -17,7 +18,7 @@ const toInjectFn = (target) => {
         return (s) => target.resolve(s);
     }
     if ((0, utils_1.isConstructor)(target)) {
-        return (scope) => scope.resolveByClass(target);
+        return (scope) => scope.resolveClass(target);
     }
     if ((0, IContainer_1.isDependencyKey)(target)) {
         return (scope) => scope.resolveOne(target);

package/cjm/provider/Cache.js

@@ -4,6 +4,9 @@ exports.SingleCache = exports.multiCache = exports.MultiCache = void 0;
 class MultiCache {
     getKey;
     instances = new Map();
+    static fromFirstArg() {
+        return new MultiCache((key) => key);
+    }
     constructor(getKey = () => '1') {
         this.getKey = getKey;
     }

package/cjm/provider/IProvider.js

@@ -1,11 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderDecorator = exports.lazy = exports.scopeAccess = exports.argsFn = exports.args = void 0;
+exports.ProviderDecorator = exports.lazy = exports.scopeAccess = exports.resolveByArgs = exports.argsFn = exports.args = void 0;
+const utils_1 = require("../utils");
 const ProviderPipe_1 = require("./ProviderPipe");
 const args = (...extraArgs) => (0, ProviderPipe_1.registerPipe)((p) => p.setArgs(() => extraArgs));
 exports.args = args;
 const argsFn = (fn) => (0, ProviderPipe_1.registerPipe)((p) => p.setArgs(fn));
 exports.argsFn = argsFn;
+const resolveByArgs = (s, ...deps) => deps.map((d) => {
+    if (utils_1.Is.injectBuilder(d)) {
+        return d.resolve(s);
+    }
+    if (utils_1.Is.constructor(d)) {
+        return s.resolveClass(d);
+    }
+    return d;
+});
+exports.resolveByArgs = resolveByArgs;
 const scopeAccess = (predicate) => (0, ProviderPipe_1.registerPipe)((p) => p.setAccessPredicate(predicate));
 exports.scopeAccess = scopeAccess;
 const lazy = () => (0, ProviderPipe_1.registerPipe)((p) => p.lazy());

package/cjm/provider/Provider.js

@@ -6,7 +6,7 @@ const ProviderPipe_1 = require("./ProviderPipe");
 class Provider {
     resolveDependency;
     static fromClass(Target) {
-        return new Provider((container, options) => container.resolveByClass(Target, options));
+        return new Provider((container, options) => container.resolveClass(Target, options));
     }
     static fromValue(value) {
         return new Provider(() => value);

package/cjm/utils.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Filter = exports.List = exports.promisify = exports.constant = exports.pipe = exports.isConstructor = void 0;
+exports.Is = exports.Filter = exports.List = exports.promisify = exports.constant = exports.pipe = exports.isConstructor = void 0;
 exports.isInstance = isInstance;
 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');
 }
@@ -44,3 +50,10 @@ exports.Filter = {
         return (v) => !excludeSet.has(v);
     },
 };
+exports.Is = {
+    object: (target) => target !== null && typeof target === 'object',
+    instance: (target) => Object.prototype.hasOwnProperty.call(target, 'constructor'),
+    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',
+};

package/esm/DepKey.js

@@ -22,7 +22,7 @@ export const depKey = (key) => {
             }
             return registration;
         },
-        resolve: (s) => s.resolveOne(key),
+        resolve: (s, options) => s.resolveOne(key, options),
         pipe(...values) {
             mappers.push(...values);
             return this;

package/esm/container/Container.js

@@ -1,4 +1,4 @@
-import { DEFAULT_CONTAINER_RESOLVER as resolveOne, } from './IContainer';
+import { DEFAULT_CONTAINER_RESOLVER, } from './IContainer';
 import { EmptyContainer } from './EmptyContainer';
 import { ContainerDisposedError } from '../errors/ContainerDisposedError';
 import { MetadataInjector } from '../injector/MetadataInjector';
@@ -17,12 +17,14 @@ export class Container {
     onConstruct;
     onDispose;
     injector;
+    resolveOneStrategy;
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer();
         this.tags = new Set(options.tags ?? []);
         this.onConstruct = options.onConstruct ?? (() => { });
         this.onDispose = options.onDispose ?? (() => { });
+        this.resolveOneStrategy = options.resolveOneStrategy ?? DEFAULT_CONTAINER_RESOLVER;
     }
     register(key, provider, { aliases = [] } = {}) {
         this.validateContainer();
@@ -39,7 +41,7 @@ export class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
-    resolveByClass(token, { args = [] } = {}) {
+    resolveClass(token, { args = [] } = {}) {
         this.validateContainer();
         const instance = this.injector.resolve(this, token, { args });
         this.instances.add(instance);
@@ -47,7 +49,7 @@ export class Container {
         return instance;
     }
     resolveOne(keyOrAlias, options) {
-        return resolveOne(this, keyOrAlias, options);
+        return this.resolveOneStrategy(this, keyOrAlias, options);
     }
     resolveOneByKey(keyOrAlias, { args = [], child = this, lazy } = {}) {
         this.validateContainer();

package/esm/container/EmptyContainer.js

@@ -7,7 +7,7 @@ export class EmptyContainer {
     getParent() {
         return undefined;
     }
-    resolveByClass(token, options) {
+    resolveClass(token, options) {
         throw new MethodNotImplementedError();
     }
     getScopes() {

package/esm/container/IContainer.js

@@ -5,7 +5,7 @@ export function isDependencyKey(token) {
 }
 export const DEFAULT_CONTAINER_RESOLVER = (scope, keyOrAlias, options) => {
     if (isConstructor(keyOrAlias)) {
-        return scope.resolveByClass(keyOrAlias, options);
+        return scope.resolveClass(keyOrAlias, options);
     }
     try {
         return scope.resolveOneByKey(keyOrAlias, options);

package/esm/injector/inject.js

@@ -5,7 +5,7 @@ import { hookMetaKey } from '../hooks/HookContext';
 export const inject = (fn) => (target, propertyKey, parameterIndex) => {
     setParameterMetadata(hookMetaKey(propertyKey), toInjectFn(fn))(isInstance(target) ? target.constructor : target, propertyKey, parameterIndex);
 };
-function isInjectBuilder(fn) {
+export function isInjectBuilder(fn) {
     return 'resolve' in fn && typeof fn['resolve'] === 'function';
 }
 export const toInjectFn = (target) => {
@@ -13,7 +13,7 @@ export const toInjectFn = (target) => {
         return (s) => target.resolve(s);
     }
     if (isConstructor(target)) {
-        return (scope) => scope.resolveByClass(target);
+        return (scope) => scope.resolveClass(target);
     }
     if (isDependencyKey(target)) {
         return (scope) => scope.resolveOne(target);

package/esm/provider/Cache.js

@@ -1,6 +1,9 @@
 export class MultiCache {
     getKey;
     instances = new Map();
+    static fromFirstArg() {
+        return new MultiCache((key) => key);
+    }
     constructor(getKey = () => '1') {
         this.getKey = getKey;
     }

package/esm/provider/IProvider.js

@@ -1,6 +1,16 @@
+import { Is } from '../utils';
 import { isProviderPipe, registerPipe } from './ProviderPipe';
 export const args = (...extraArgs) => registerPipe((p) => p.setArgs(() => extraArgs));
 export const argsFn = (fn) => registerPipe((p) => p.setArgs(fn));
+export const resolveByArgs = (s, ...deps) => deps.map((d) => {
+    if (Is.injectBuilder(d)) {
+        return d.resolve(s);
+    }
+    if (Is.constructor(d)) {
+        return s.resolveClass(d);
+    }
+    return d;
+});
 export const scopeAccess = (predicate) => registerPipe((p) => p.setAccessPredicate(predicate));
 export const lazy = () => registerPipe((p) => p.lazy());
 export class ProviderDecorator {

package/esm/provider/Provider.js

@@ -3,7 +3,7 @@ import { isProviderPipe } from './ProviderPipe';
 export class Provider {
     resolveDependency;
     static fromClass(Target) {
-        return new Provider((container, options) => container.resolveByClass(Target, options));
+        return new Provider((container, options) => container.resolveClass(Target, options));
     }
     static fromValue(value) {
         return new Provider(() => value);

package/esm/utils.js

@@ -1,4 +1,10 @@
+/**
+ * @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');
 }
@@ -34,3 +40,10 @@ export const Filter = {
         return (v) => !excludeSet.has(v);
     },
 };
+export const Is = {
+    object: (target) => target !== null && typeof target === 'object',
+    instance: (target) => Object.prototype.hasOwnProperty.call(target, 'constructor'),
+    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',
+};

package/package.json

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

package/typings/container/AutoMockedContainer.d.ts

@@ -15,7 +15,7 @@ export declare abstract class AutoMockedContainer implements IContainer {
     getRegistrations(): never[];
     addRegistration(registration: IRegistration): this;
     abstract resolveMany<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
-    abstract resolveByClass<T>(target: constructor<T>, options?: {
+    abstract resolveClass<T>(target: constructor<T>, options?: {
         args?: unknown[];
     }): T;
     abstract resolveOneByKey<T>(keyOrAlias: DependencyKey, options?: ResolveOneOptions): T;

package/typings/container/Container.d.ts

@@ -3,6 +3,7 @@ import { type IInjector } from '../injector/IInjector';
 import { type IProvider } 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;
 export declare class Container implements IContainer {
     isDisposed: boolean;
     private parent;
@@ -15,17 +16,19 @@ export declare class Container implements IContainer {
     private readonly onConstruct;
     private readonly onDispose;
     private readonly injector;
+    private readonly resolveOneStrategy;
     constructor(options?: {
         injector?: IInjector;
         parent?: IContainer;
         tags?: Tag[];
         onConstruct?: (instance: Instance, scope: IContainer) => void;
         onDispose?: (scope: IContainer) => void;
+        resolveOneStrategy?: ResolveOneStrategy;
     });
     register(key: DependencyKey, provider: IProvider, { aliases }?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
-    resolveByClass<T>(token: constructor<T>, { args }?: {
+    resolveClass<T>(token: constructor<T>, { args }?: {
         args?: unknown[];
     }): T;
     resolveOne<T>(keyOrAlias: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
@@ -47,3 +50,4 @@ export declare class Container implements IContainer {
     private validateContainer;
     private findProviderByKeyOrFail;
 }
+export {};

package/typings/container/EmptyContainer.d.ts

@@ -5,7 +5,7 @@ import { type constructor } from '../utils';
 export declare class EmptyContainer implements IContainer {
     get isDisposed(): boolean;
     getParent(): undefined;
-    resolveByClass<T>(token: constructor<T>, options?: {
+    resolveClass<T>(token: constructor<T>, options?: {
         args?: [];
     }): T;
     getScopes(): never[];

package/typings/container/IContainer.d.ts

@@ -36,10 +36,10 @@ export interface IContainer extends Tagged {
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
-    resolveByClass<T>(target: constructor<T>, options?: {
+    resolveClass<T>(target: constructor<T>, options?: {
         args?: unknown[];
     }): T;
-    resolveOne<T>(alias: constructor<T> | DependencyKey, options?: ResolveManyOptions): T;
+    resolveOne<T>(alias: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
     resolveOneByKey<T>(key: DependencyKey, options?: ResolveOneOptions): T;
     resolveOneByAlias<T>(key: DependencyKey, options?: ResolveOneOptions): T;
     resolveMany<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];

package/typings/injector/IInjector.d.ts

@@ -1,5 +1,5 @@
 import { type constructor } from '../utils';
-import { type IContainer } from '../container/IContainer';
+import { type IContainer, ResolveOneOptions } from '../container/IContainer';
 export type InjectOptions = {
     args: unknown[];
 };
@@ -7,5 +7,5 @@ export interface IInjector {
     resolve<T>(container: IContainer, value: constructor<T>, options: InjectOptions): T;
 }
 export interface IInjectFnResolver<T> {
-    resolve(s: IContainer): T;
+    resolve(s: IContainer, options?: ResolveOneOptions): T;
 }

package/typings/injector/inject.d.ts

@@ -3,5 +3,6 @@ import { DependencyKey, type IContainer } from '../container/IContainer';
 import { type InjectFn } from '../hooks/HookContext';
 import { type IInjectFnResolver } from './IInjector';
 export declare const inject: <T>(fn: InjectFn<T> | IInjectFnResolver<T> | DependencyKey | constructor<T>) => ParameterDecorator;
+export declare function isInjectBuilder<T>(fn: object): fn is IInjectFnResolver<T>;
 export declare const toInjectFn: <T>(target: InjectFn<T> | IInjectFnResolver<T> | DependencyKey | constructor<T>) => InjectFn<T>;
 export declare const resolveArgs: (Target: constructor<unknown>, methodName?: string) => (scope: IContainer, ...deps: unknown[]) => unknown[];

package/typings/provider/Cache.d.ts

@@ -1,3 +1,4 @@
+import type { DependencyKey } from '../container/IContainer';
 export interface Cache<K, V> {
     getKey(...args: unknown[]): K;
     hasValue(key: K): boolean;
@@ -7,6 +8,7 @@ export interface Cache<K, V> {
 export declare class MultiCache<K, V> implements Cache<K, V> {
     readonly getKey: (...args: unknown[]) => K;
     private instances;
+    static fromFirstArg(): MultiCache<DependencyKey, unknown>;
     constructor(getKey?: (...args: unknown[]) => K);
     hasValue(token: K): boolean;
     getValue(token: K): V;

package/typings/provider/IProvider.d.ts

@@ -1,5 +1,5 @@
-import type { IContainer, Tagged } from '../container/IContainer';
-import type { MapFn } from '../utils';
+import { IContainer, Tagged } from '../container/IContainer';
+import { MapFn } from '../utils';
 import { ProviderPipe } from './ProviderPipe';
 export type ProviderResolveOptions = {
     args: unknown[];
@@ -25,6 +25,7 @@ export interface IProvider<T = any> {
 }
 export declare const args: <T>(...extraArgs: unknown[]) => ProviderPipe<T>;
 export declare const argsFn: <T>(fn: ArgsFn) => ProviderPipe<T>;
+export declare const resolveByArgs: (s: IContainer, ...deps: unknown[]) => unknown[];
 export declare const scopeAccess: <T>(predicate: ScopeAccessFn) => ProviderPipe<T>;
 export declare const lazy: <T>() => ProviderPipe<T>;
 export declare abstract class ProviderDecorator<T> implements IProvider<T> {

package/typings/utils.d.ts

@@ -1,8 +1,16 @@
+import { DependencyKey } from './container/IContainer';
+import { IInjectFnResolver } from './injector/IInjector';
 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>;
@@ -16,3 +24,10 @@ export declare const List: {
 export declare const Filter: {
     exclude: <T>(arr: Set<T> | T[]) => (v: T) => boolean;
 };
+export declare const Is: {
+    object: (target: unknown) => target is object;
+    instance: (target: unknown) => target is InstanceOfClass;
+    constructor: (target: unknown) => target is constructor<unknown>;
+    dependencyKey: (target: unknown) => target is DependencyKey;
+    injectBuilder: (target: unknown) => target is IInjectFnResolver<unknown>;
+};