ts-ioc-container 31.2.2 → 31.4.0

package/README.md

@@ -29,7 +29,7 @@
     - [Metadata](#metadata) `@inject`
     - [Simple](#simple)
     - [Proxy](#proxy)
-- [Provider](#provider)
+- [Provider](#provider) `@provider`
     - [Singleton](#singleton) `singleton`
     - [Arguments](#arguments) `args`
     - [Visibility](#visibility) `visible`
@@ -138,6 +138,7 @@ import {
   Container,
   DependencyNotFoundError,
   key,
+  provider,
   MetadataInjector,
   Registration as R,
   by,
@@ -145,7 +146,8 @@ import {
   register,
 } from 'ts-ioc-container';
 
-@register(key('ILogger'), scope((s) => s.hasTag('child')), singleton())
+@register(key('ILogger'), scope((s) => s.hasTag('child')))
+@provider(singleton())
 class Logger {}
 
 describe('Scopes', function () {
@@ -330,7 +332,7 @@ This type of injector injects dependencies as dictionary `Record<string, unknown
 
 ```typescript
 import 'reflect-metadata';
-import { args, Container, ProxyInjector, Registration as R } from 'ts-ioc-container';
+import { Container, ProxyInjector, args, Registration as R } from 'ts-ioc-container';
 
 describe('ProxyInjector', function () {
   it('should pass dependency to constructor as dictionary', function () {
@@ -387,6 +389,7 @@ describe('ProxyInjector', function () {
 ## Provider
 Provider is dependency factory which creates dependency.
 
+- `@provider()`
 - `Provider.fromClass(Logger)`
 - `Provider.fromValue(logger)`
 - `new Provider((container, ...args) => container.resolve(Logger, {args}))`
@@ -436,9 +439,10 @@ Sometimes you need to create only one instance of dependency per scope. For exam
 
 ```typescript
 import 'reflect-metadata';
-import { singleton, Container, key, MetadataInjector, Registration as R, register } from 'ts-ioc-container';
+import { singleton, Container, key, provider, MetadataInjector, Registration as R, register } from 'ts-ioc-container';
 
-@register(key('logger'), singleton())
+@register(key('logger'))
+@provider(singleton())
 class Logger {}
 
 describe('Singleton', function () {
@@ -471,14 +475,27 @@ describe('Singleton', function () {
 
 ### Arguments
 Sometimes you want to bind some arguments to provider. This is what `ArgsProvider` is for.
-- `args('someArgument')`
-- `argsFn((container) => [container.resolve(Logger), 'someValue'])`
+- `@provider(args('someArgument'))`
+- `@provider(argsFn((container) => [container.resolve(Logger), 'someValue']))`
 - `Provider.fromClass(Logger).pipe(args('someArgument'))`
 - NOTICE: args from this provider has higher priority than args from `resolve` method.
 
 ```typescript
 import 'reflect-metadata';
-import { args, argsFn, Container, key, MetadataInjector, register, Registration as R } from 'ts-ioc-container';
+import {
+  args,
+  argsFn,
+  Container,
+  DependencyKey,
+  inject,
+  key,
+  MetadataInjector,
+  MultiCache,
+  provider,
+  register,
+  Registration as R,
+  singleton,
+} from 'ts-ioc-container';
 
 @register(key('logger'))
 class Logger {
@@ -515,13 +532,97 @@ describe('ArgsProvider', function () {
     expect(logger.name).toBe('name');
     expect(logger.type).toBe('file');
   });
+
+  it('should resolve dependency by passing arguments resolve from container by another argument', function () {
+    interface IRepository {
+      name: string;
+    }
+
+    @register(key('UserRepository'))
+    class UserRepository implements IRepository {
+      name = 'UserRepository';
+    }
+
+    @register(key('TodoRepository'))
+    class TodoRepository implements IRepository {
+      name = 'TodoRepository';
+    }
+
+    @register(key('EntityManager'))
+    @provider(argsFn((container, token) => [container.resolve(token as DependencyKey)]))
+    class EntityManager {
+      constructor(public repository: IRepository) {}
+    }
+
+    class Main {
+      constructor(
+        @inject((s) => s.resolve('EntityManager', { args: ['UserRepository'] })) public userEntities: EntityManager,
+        @inject((s) => s.resolve('EntityManager', { args: ['TodoRepository'] })) public todoEntities: EntityManager,
+      ) {}
+    }
+
+    const root = createContainer()
+      .add(R.fromClass(EntityManager))
+      .add(R.fromClass(UserRepository))
+      .add(R.fromClass(TodoRepository));
+    const main = root.resolve(Main);
+
+    expect(main.userEntities.repository).toBeInstanceOf(UserRepository);
+    expect(main.todoEntities.repository).toBeInstanceOf(TodoRepository);
+  });
+
+  it('should resolve memoized dependency by passing arguments resolve from container by another argument', function () {
+    interface IRepository {
+      name: string;
+    }
+
+    @register(key('UserRepository'))
+    class UserRepository implements IRepository {
+      name = 'UserRepository';
+    }
+
+    @register(key('TodoRepository'))
+    class TodoRepository implements IRepository {
+      name = 'TodoRepository';
+    }
+
+    @register(key('EntityManager'))
+    @provider(
+      argsFn((container, token) => [container.resolve(token as DependencyKey)]),
+      singleton(() => new MultiCache((...args: unknown[]) => args[0] as DependencyKey)),
+    )
+    class EntityManager {
+      constructor(public repository: IRepository) {}
+    }
+
+    class Main {
+      constructor(
+        @inject((s) => s.resolve('EntityManager', { args: ['UserRepository'] })) public userEntities: EntityManager,
+        @inject((s) => s.resolve('EntityManager', { args: ['TodoRepository'] })) public todoEntities: EntityManager,
+      ) {}
+    }
+
+    const root = createContainer()
+      .add(R.fromClass(EntityManager))
+      .add(R.fromClass(UserRepository))
+      .add(R.fromClass(TodoRepository));
+    const main = root.resolve(Main);
+
+    const userRepository = root.resolve<EntityManager>('EntityManager', { args: ['UserRepository'] }).repository;
+    expect(userRepository).toBeInstanceOf(UserRepository);
+    expect(main.userEntities.repository).toBe(userRepository);
+
+    const todoRepository = root.resolve<EntityManager>('EntityManager', { args: ['TodoRepository'] }).repository;
+    expect(todoRepository).toBeInstanceOf(TodoRepository);
+    expect(main.todoEntities.repository).toBe(todoRepository);
+  });
 });
 
 ```
 
 ### Visibility
 Sometimes you want to hide dependency if somebody wants to resolve it from certain scope
-- `visible(({ isParent, child }) => isParent || child.hasTag('root'))` - dependency will be accessible from scope `root` or from scope where it's registered
+- `@provider(visible(({ isParent, child }) => isParent || child.hasTag('root')))` - dependency will be accessible from scope `root` or from scope where it's registered
 - `Provider.fromClass(Logger).pipe(visible(({ isParent, child }) => isParent || child.hasTag('root')))`
 
 ```typescript
@@ -531,6 +632,7 @@ import {
   DependencyNotFoundError,
   key,
   MetadataInjector,
+  provider,
   register,
   Registration as R,
   scope,
@@ -540,7 +642,8 @@ import {
 
 describe('Visibility', function () {
   it('should hide from children', () => {
-    @register(key('logger'), scope((s) => s.hasTag('root')), singleton(), visible(({ isParent }) => isParent))
+    @register(key('logger'), scope((s) => s.hasTag('root')))
+    @provider(singleton(), visible(({ isParent }) => isParent))
     class FileLogger {}
 
     const parent = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(FileLogger));
@@ -564,14 +667,15 @@ Registration is provider factory which registers provider in container.
 
 ```typescript
 import 'reflect-metadata';
-import { Container, key, MetadataInjector, register, Registration as R, scope, singleton } from 'ts-ioc-container';
+import { Container, key, MetadataInjector, provider, register, Registration as R, scope, singleton } from 'ts-ioc-container';
 import { DependencyMissingKeyError } from '../../lib/errors/DependencyMissingKeyError';
 
 describe('Registration module', function () {
   const createContainer = () => new Container(new MetadataInjector(), { tags: ['root'] });
 
   it('should register class', function () {
-    @register(key('ILogger'), scope((s) => s.hasTag('root')), singleton())
+    @register(key('ILogger'), scope((s) => s.hasTag('root')))
+    @provider(singleton())
     class Logger {}
 
     const root = createContainer().add(R.fromClass(Logger));
@@ -615,9 +719,10 @@ Sometimes you need to register provider only in scope which matches to certain c
 
 ```typescript
 import 'reflect-metadata';
-import { singleton, Container, key, MetadataInjector, Registration as R, scope, register } from 'ts-ioc-container';
+import { singleton, Container, key, provider, MetadataInjector, Registration as R, scope, register } from 'ts-ioc-container';
 
-@register(key('ILogger'), scope((s) => s.hasTag('root')), singleton()) // the same as .pipe(singleton(), scope((s) => s.hasTag('root')))
+@register(key('ILogger'), scope((s) => s.hasTag('root')))
+@provider(singleton()) // the same as .pipe(singleton(), scope((s) => s.hasTag('root')))
 class Logger {}
 describe('ScopeProvider', function () {
   it('should return the same instance', function () {
@@ -832,19 +937,22 @@ describe('onConstruct', function () {
 ```typescript
 import 'reflect-metadata';
 import {
+  singleton,
   by,
   Container,
+  key,
   getHooks,
   hook,
   inject,
-  key,
+  provider,
+  Registration as R,
   MetadataInjector,
   register,
-  Registration as R,
-  singleton,
 } from 'ts-ioc-container';
+import * as console from 'node:console';
 
-@register(key('logsRepo'), singleton())
+@register(key('logsRepo'))
+@provider(singleton())
 class LogsRepo {
   savedLogs: string[] = [];
 

package/cjm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.register = exports.scope = exports.alias = exports.key = exports.Registration = exports.AutoMockedContainer = exports.SingletonProvider = exports.singleton = exports.ArgsProvider = exports.args = exports.argsFn = exports.ProviderDecorator = exports.Provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.markAsProvider = exports.provider = exports.visible = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.register = exports.scope = exports.alias = exports.key = exports.Registration = exports.AutoMockedContainer = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.ArgsProvider = exports.args = exports.argsFn = exports.ProviderDecorator = exports.Provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.visible = exports.provider = exports.EmptyContainer = exports.Container = exports.isDependencyKey = 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");
@@ -8,9 +8,8 @@ Object.defineProperty(exports, "Container", { enumerable: true, get: function ()
 var EmptyContainer_1 = require("./container/EmptyContainer");
 Object.defineProperty(exports, "EmptyContainer", { enumerable: true, get: function () { return EmptyContainer_1.EmptyContainer; } });
 var IProvider_1 = require("./provider/IProvider");
-Object.defineProperty(exports, "visible", { enumerable: true, get: function () { return IProvider_1.visible; } });
 Object.defineProperty(exports, "provider", { enumerable: true, get: function () { return IProvider_1.provider; } });
-Object.defineProperty(exports, "markAsProvider", { enumerable: true, get: function () { return IProvider_1.markAsProvider; } });
+Object.defineProperty(exports, "visible", { enumerable: true, get: function () { return IProvider_1.visible; } });
 var DependencyNotFoundError_1 = require("./errors/DependencyNotFoundError");
 Object.defineProperty(exports, "DependencyNotFoundError", { enumerable: true, get: function () { return DependencyNotFoundError_1.DependencyNotFoundError; } });
 var MethodNotImplementedError_1 = require("./errors/MethodNotImplementedError");
@@ -25,9 +24,11 @@ var ArgsProvider_1 = require("./provider/ArgsProvider");
 Object.defineProperty(exports, "argsFn", { enumerable: true, get: function () { return ArgsProvider_1.argsFn; } });
 Object.defineProperty(exports, "args", { enumerable: true, get: function () { return ArgsProvider_1.args; } });
 Object.defineProperty(exports, "ArgsProvider", { enumerable: true, get: function () { return ArgsProvider_1.ArgsProvider; } });
-var SingletonProvider_1 = require("./provider/SingletonProvider");
+var SingletonProvider_1 = require("./provider/singleton/SingletonProvider");
 Object.defineProperty(exports, "singleton", { enumerable: true, get: function () { return SingletonProvider_1.singleton; } });
 Object.defineProperty(exports, "SingletonProvider", { enumerable: true, get: function () { return SingletonProvider_1.SingletonProvider; } });
+var MultiCache_1 = require("./provider/singleton/MultiCache");
+Object.defineProperty(exports, "MultiCache", { enumerable: true, get: function () { return MultiCache_1.MultiCache; } });
 var AutoMockedContainer_1 = require("./container/AutoMockedContainer");
 Object.defineProperty(exports, "AutoMockedContainer", { enumerable: true, get: function () { return AutoMockedContainer_1.AutoMockedContainer; } });
 var Registration_1 = require("./registration/Registration");

package/cjm/provider/ArgsProvider.js

@@ -2,13 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArgsProvider = exports.argsFn = exports.args = void 0;
 const ProviderDecorator_1 = require("./ProviderDecorator");
-const IProvider_1 = require("./IProvider");
 function args(...extraArgs) {
-    return (0, IProvider_1.markAsProvider)((provider) => new ArgsProvider(provider, () => extraArgs));
+    return (provider) => new ArgsProvider(provider, () => extraArgs);
 }
 exports.args = args;
 function argsFn(value) {
-    return (0, IProvider_1.markAsProvider)((provider) => new ArgsProvider(provider, value));
+    return (provider) => new ArgsProvider(provider, value);
 }
 exports.argsFn = argsFn;
 class ArgsProvider extends ProviderDecorator_1.ProviderDecorator {
@@ -18,7 +17,7 @@ class ArgsProvider extends ProviderDecorator_1.ProviderDecorator {
         this.argsFn = argsFn;
     }
     resolve(container, ...args) {
-        return this.provider.resolve(container, ...this.argsFn(container), ...args);
+        return this.provider.resolve(container, ...this.argsFn(container, ...args), ...args);
     }
 }
 exports.ArgsProvider = ArgsProvider;

package/cjm/provider/IProvider.js

@@ -1,22 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.visible = exports.isProviderMapper = exports.markAsProvider = exports.getTransformers = exports.provider = void 0;
+exports.visible = exports.getTransformers = exports.provider = void 0;
 const metadata_1 = require("../metadata");
 const METADATA_KEY = 'provider';
 const provider = (...mappers) => (0, metadata_1.setMetadata)(METADATA_KEY, mappers);
 exports.provider = provider;
 const getTransformers = (Target) => (0, metadata_1.getMetadata)(Target, METADATA_KEY) ?? [];
 exports.getTransformers = getTransformers;
-const markAsProvider = (fn) => {
-    // @ts-ignore
-    fn.__provider = true;
-    return fn;
-};
-exports.markAsProvider = markAsProvider;
-const isProviderMapper = (fn) => {
-    // @ts-ignore
-    return fn.__provider === true;
-};
-exports.isProviderMapper = isProviderMapper;
-const visible = (isVisibleWhen) => (0, exports.markAsProvider)((p) => p.setVisibility(isVisibleWhen));
+const visible = (isVisibleWhen) => (p) => p.setVisibility(isVisibleWhen);
 exports.visible = visible;

package/cjm/provider/Provider.js

@@ -9,7 +9,8 @@ class Provider {
         return new Provider((container, ...args) => container.resolve(Target, { args })).pipe(...transformers);
     }
     static fromValue(value) {
-        return new Provider(() => value);
+        const mappers = (0, utils_1.isConstructor)(value) ? (0, IProvider_1.getTransformers)(value) ?? [] : [];
+        return new Provider(() => value).pipe(...mappers);
     }
     constructor(resolveDependency, isVisibleWhen = () => true) {
         this.resolveDependency = resolveDependency;

package/cjm/provider/singleton/Cache.js

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

package/cjm/provider/singleton/MultiCache.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiCache = exports.MultiCache = void 0;
+class MultiCache {
+    constructor(getKey = () => '1') {
+        this.getKey = getKey;
+        this.instances = new Map();
+    }
+    hasValue(token) {
+        return this.instances.has(token);
+    }
+    getValue(token) {
+        return this.instances.get(token);
+    }
+    setValue(token, value) {
+        this.instances.set(token, value);
+    }
+}
+exports.MultiCache = MultiCache;
+const multiCache = (getKey) => new MultiCache(getKey);
+exports.multiCache = multiCache;

package/cjm/provider/singleton/SingleCache.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleCache = void 0;
+class SingleCache {
+    getKey(...args) {
+        return '1';
+    }
+    getValue(key) {
+        return this.instance.value;
+    }
+    hasValue(key) {
+        return this.instance !== undefined;
+    }
+    setValue(key, value) {
+        this.instance = { value };
+    }
+}
+exports.SingleCache = SingleCache;

package/cjm/provider/singleton/SingletonProvider.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonProvider = exports.singleton = void 0;
+const ProviderDecorator_1 = require("../ProviderDecorator");
+const SingleCache_1 = require("./SingleCache");
+function singleton(cacheProvider) {
+    return (provider) => new SingletonProvider(provider, cacheProvider ? cacheProvider() : new SingleCache_1.SingleCache());
+}
+exports.singleton = singleton;
+class SingletonProvider extends ProviderDecorator_1.ProviderDecorator {
+    constructor(provider, cache) {
+        super(provider);
+        this.provider = provider;
+        this.cache = cache;
+    }
+    resolve(container, ...args) {
+        const key = this.cache.getKey(...args);
+        if (!this.cache.hasValue(key)) {
+            this.cache.setValue(key, this.provider.resolve(container, ...args));
+        }
+        return this.cache.getValue(key);
+    }
+}
+exports.SingletonProvider = SingletonProvider;

package/cjm/registration/IRegistration.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.provider = exports.register = exports.getTransformers = exports.scope = exports.alias = exports.key = void 0;
+exports.register = exports.getTransformers = exports.scope = exports.alias = exports.key = void 0;
 const metadata_1 = require("../metadata");
 const key = (key) => (r) => r.to(key);
 exports.key = key;
@@ -13,5 +13,3 @@ const getTransformers = (Target) => (0, metadata_1.getMetadata)(Target, METADATA
 exports.getTransformers = getTransformers;
 const register = (...mappers) => (0, metadata_1.setMetadata)(METADATA_KEY, mappers);
 exports.register = register;
-const provider = (...mappers) => (r) => r.provider(...mappers);
-exports.provider = provider;

package/cjm/registration/Registration.js

@@ -3,25 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Registration = void 0;
 const utils_1 = require("../utils");
 const Provider_1 = require("../provider/Provider");
-const IProvider_1 = require("../provider/IProvider");
 const DependencyMissingKeyError_1 = require("../errors/DependencyMissingKeyError");
 const IRegistration_1 = require("./IRegistration");
 class Registration {
     static fromClass(Target) {
-        return new Registration(() => Provider_1.Provider.fromClass(Target), Target.name).pipe(...(0, IRegistration_1.getTransformers)(Target));
+        const transform = (0, utils_1.pipe)(...(0, IRegistration_1.getTransformers)(Target));
+        return transform(new Registration(() => Provider_1.Provider.fromClass(Target), Target.name));
     }
     static fromValue(value) {
+        if ((0, utils_1.isConstructor)(value)) {
+            const transform = (0, utils_1.pipe)(...(0, IRegistration_1.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));
     }
-    constructor(createProvider, key) {
+    constructor(createProvider, key, matchScope = () => true) {
         this.createProvider = createProvider;
         this.key = key;
+        this.matchScope = matchScope;
         this.aliases = [];
         this.mappers = [];
-        this.matchScope = () => true;
     }
     to(key) {
         this.key = key;
@@ -34,11 +38,6 @@ class Registration {
         return this;
     }
     pipe(...mappers) {
-        const [providerMappers, registrationMappers] = (0, utils_1.groupBy)(mappers, IProvider_1.isProviderMapper);
-        this.mappers.push(...providerMappers);
-        return (0, utils_1.pipe)(...registrationMappers)(this);
-    }
-    provider(...mappers) {
         this.mappers.push(...mappers);
         return this;
     }

package/cjm/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupBy = exports.isConstructor = exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
+exports.isConstructor = exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
 const pipe = (...mappers) => (value) => mappers.reduce((acc, current) => current(acc), value);
 exports.pipe = pipe;
 function fillEmptyIndexes(baseArr, insertArr) {
@@ -18,13 +18,3 @@ const constant = (value) => () => value;
 exports.constant = constant;
 const isConstructor = (T) => typeof T === 'function' && !!T.prototype;
 exports.isConstructor = isConstructor;
-function groupBy(items, predicate) {
-    const [a, b] = items.reduce(([a, b], item) => {
-        if (predicate(item)) {
-            return [a.concat(item), b];
-        }
-        return [a, b.concat(item)];
-    }, [[], []]);
-    return [a, b];
-}
-exports.groupBy = groupBy;

package/esm/index.js

@@ -1,14 +1,15 @@
 export { isDependencyKey, } from './container/IContainer';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
-export { visible, provider, markAsProvider } from './provider/IProvider';
+export { provider, visible } from './provider/IProvider';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
 export { Provider } from './provider/Provider';
 export { ProviderDecorator } from './provider/ProviderDecorator';
 export { argsFn, args, ArgsProvider } from './provider/ArgsProvider';
-export { singleton, SingletonProvider } from './provider/SingletonProvider';
+export { singleton, SingletonProvider } from './provider/singleton/SingletonProvider';
+export { MultiCache } from './provider/singleton/MultiCache';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
 export { Registration } from './registration/Registration';
 export { key, alias, scope, register } from './registration/IRegistration';

package/esm/provider/ArgsProvider.js

@@ -1,10 +1,9 @@
 import { ProviderDecorator } from './ProviderDecorator';
-import { markAsProvider } from './IProvider';
 export function args(...extraArgs) {
-    return markAsProvider((provider) => new ArgsProvider(provider, () => extraArgs));
+    return (provider) => new ArgsProvider(provider, () => extraArgs);
 }
 export function argsFn(value) {
-    return markAsProvider((provider) => new ArgsProvider(provider, value));
+    return (provider) => new ArgsProvider(provider, value);
 }
 export class ArgsProvider extends ProviderDecorator {
     constructor(provider, argsFn) {
@@ -13,6 +12,6 @@ export class ArgsProvider extends ProviderDecorator {
         this.argsFn = argsFn;
     }
     resolve(container, ...args) {
-        return this.provider.resolve(container, ...this.argsFn(container), ...args);
+        return this.provider.resolve(container, ...this.argsFn(container, ...args), ...args);
     }
 }

package/esm/provider/IProvider.js

@@ -2,13 +2,4 @@ import { getMetadata, setMetadata } from '../metadata';
 const METADATA_KEY = 'provider';
 export const provider = (...mappers) => setMetadata(METADATA_KEY, mappers);
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];
-export const markAsProvider = (fn) => {
-    // @ts-ignore
-    fn.__provider = true;
-    return fn;
-};
-export const isProviderMapper = (fn) => {
-    // @ts-ignore
-    return fn.__provider === true;
-};
-export const visible = (isVisibleWhen) => markAsProvider((p) => p.setVisibility(isVisibleWhen));
+export const visible = (isVisibleWhen) => (p) => p.setVisibility(isVisibleWhen);

package/esm/provider/Provider.js

@@ -1,12 +1,13 @@
 import { getTransformers } from './IProvider';
-import { pipe } from '../utils';
+import { isConstructor, pipe } from '../utils';
 export class Provider {
     static fromClass(Target) {
         const transformers = getTransformers(Target);
         return new Provider((container, ...args) => container.resolve(Target, { args })).pipe(...transformers);
     }
     static fromValue(value) {
-        return new Provider(() => value);
+        const mappers = isConstructor(value) ? getTransformers(value) ?? [] : [];
+        return new Provider(() => value).pipe(...mappers);
     }
     constructor(resolveDependency, isVisibleWhen = () => true) {
         this.resolveDependency = resolveDependency;

package/esm/provider/singleton/Cache.js

@@ -0,0 +1 @@
+export {};

package/esm/provider/singleton/MultiCache.js

@@ -0,0 +1,16 @@
+export class MultiCache {
+    constructor(getKey = () => '1') {
+        this.getKey = getKey;
+        this.instances = new Map();
+    }
+    hasValue(token) {
+        return this.instances.has(token);
+    }
+    getValue(token) {
+        return this.instances.get(token);
+    }
+    setValue(token, value) {
+        this.instances.set(token, value);
+    }
+}
+export const multiCache = (getKey) => new MultiCache(getKey);

package/esm/provider/singleton/SingleCache.js

@@ -0,0 +1,14 @@
+export class SingleCache {
+    getKey(...args) {
+        return '1';
+    }
+    getValue(key) {
+        return this.instance.value;
+    }
+    hasValue(key) {
+        return this.instance !== undefined;
+    }
+    setValue(key, value) {
+        this.instance = { value };
+    }
+}

package/esm/provider/singleton/SingletonProvider.js

@@ -0,0 +1,19 @@
+import { ProviderDecorator } from '../ProviderDecorator';
+import { SingleCache } from './SingleCache';
+export function singleton(cacheProvider) {
+    return (provider) => new SingletonProvider(provider, cacheProvider ? cacheProvider() : new SingleCache());
+}
+export class SingletonProvider extends ProviderDecorator {
+    constructor(provider, cache) {
+        super(provider);
+        this.provider = provider;
+        this.cache = cache;
+    }
+    resolve(container, ...args) {
+        const key = this.cache.getKey(...args);
+        if (!this.cache.hasValue(key)) {
+            this.cache.setValue(key, this.provider.resolve(container, ...args));
+        }
+        return this.cache.getValue(key);
+    }
+}

package/esm/registration/IRegistration.js

@@ -5,4 +5,3 @@ export const scope = (predicate) => (r) => r.when(predicate);
 const METADATA_KEY = 'registration';
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];
 export const register = (...mappers) => setMetadata(METADATA_KEY, mappers);
-export const provider = (...mappers) => (r) => r.provider(...mappers);

package/esm/registration/Registration.js

@@ -1,24 +1,28 @@
-import { groupBy, pipe } from '../utils';
+import { isConstructor, pipe } from '../utils';
 import { Provider } from '../provider/Provider';
-import { isProviderMapper } from '../provider/IProvider';
 import { DependencyMissingKeyError } from '../errors/DependencyMissingKeyError';
 import { getTransformers } from './IRegistration';
 export class Registration {
     static fromClass(Target) {
-        return new Registration(() => Provider.fromClass(Target), Target.name).pipe(...getTransformers(Target));
+        const transform = pipe(...getTransformers(Target));
+        return transform(new Registration(() => Provider.fromClass(Target), Target.name));
     }
     static fromValue(value) {
+        if (isConstructor(value)) {
+            const transform = pipe(...getTransformers(value));
+            return transform(new Registration(() => Provider.fromValue(value), value.name));
+        }
         return new Registration(() => Provider.fromValue(value));
     }
     static fromFn(fn) {
         return new Registration(() => new Provider(fn));
     }
-    constructor(createProvider, key) {
+    constructor(createProvider, key, matchScope = () => true) {
         this.createProvider = createProvider;
         this.key = key;
+        this.matchScope = matchScope;
         this.aliases = [];
         this.mappers = [];
-        this.matchScope = () => true;
     }
     to(key) {
         this.key = key;
@@ -31,11 +35,6 @@ export class Registration {
         return this;
     }
     pipe(...mappers) {
-        const [providerMappers, registrationMappers] = groupBy(mappers, isProviderMapper);
-        this.mappers.push(...providerMappers);
-        return pipe(...registrationMappers)(this);
-    }
-    provider(...mappers) {
         this.mappers.push(...mappers);
         return this;
     }

package/esm/utils.js

@@ -11,12 +11,3 @@ export function fillEmptyIndexes(baseArr, insertArr) {
 }
 export const constant = (value) => () => value;
 export const isConstructor = (T) => typeof T === 'function' && !!T.prototype;
-export function groupBy(items, predicate) {
-    const [a, b] = items.reduce(([a, b], item) => {
-        if (predicate(item)) {
-            return [a.concat(item), b];
-        }
-        return [a, b.concat(item)];
-    }, [[], []]);
-    return [a, b];
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "31.2.2",
+  "version": "31.4.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "c20921fb252b08d764f03504b01d54889c873324"
+  "gitHead": "1374fb632851b79d7f7e119f7ea854037894d72f"
 }

package/typings/container/Container.d.ts

@@ -16,7 +16,7 @@ export declare class Container implements IContainer {
         parent?: IContainer;
         tags?: Tag[];
     });
-    add(registration: IRegistration<any>): this;
+    add(registration: IRegistration): this;
     register(key: DependencyKey, provider: IProvider, aliases?: Alias[]): this;
     resolve<T>(token: InjectionToken<T>, { args, child }?: ResolveOptions): T;
     createScope(...tags: Tag[]): Container;

package/typings/container/IContainer.d.ts

@@ -25,7 +25,7 @@ export interface IContainer extends Resolvable, Tagged {
     readonly isDisposed: boolean;
     createScope(...tags: Tag[]): IContainer;
     register(key: DependencyKey, value: IProvider, aliases?: Alias[]): this;
-    add(registration: IRegistration<any>): this;
+    add(registration: IRegistration): this;
     removeScope(child: IContainer): void;
     getInstances(): unknown[];
     dispose(): void;

package/typings/index.d.ts

@@ -2,7 +2,7 @@ export { IContainer, Resolvable, IContainerModule, isDependencyKey, DependencyKe
 export { constructor } from './utils';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
-export { ResolveDependency, IProvider, visible, provider, markAsProvider } from './provider/IProvider';
+export { ResolveDependency, IProvider, provider, visible } from './provider/IProvider';
 export { IInjector } from './injector/IInjector';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
@@ -10,7 +10,9 @@ export { ContainerDisposedError } from './errors/ContainerDisposedError';
 export { Provider } from './provider/Provider';
 export { ProviderDecorator } from './provider/ProviderDecorator';
 export { ArgsFn, argsFn, args, ArgsProvider } from './provider/ArgsProvider';
-export { singleton, SingletonProvider } from './provider/SingletonProvider';
+export { singleton, SingletonProvider } from './provider/singleton/SingletonProvider';
+export { MultiCache } from './provider/singleton/MultiCache';
+export { Cache } from './provider/singleton/Cache';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
 export { Registration } from './registration/Registration';
 export { key, alias, IRegistration, scope, register } from './registration/IRegistration';

package/typings/provider/ArgsProvider.d.ts

@@ -2,7 +2,7 @@ import { ProviderDecorator } from './ProviderDecorator';
 import { IContainer } from '../container/IContainer';
 import { IProvider } from './IProvider';
 import { MapFn } from '../utils';
-export type ArgsFn = (l: IContainer) => unknown[];
+export type ArgsFn = (l: IContainer, ...args: unknown[]) => unknown[];
 export declare function args<T = unknown>(...extraArgs: unknown[]): MapFn<IProvider<T>>;
 export declare function argsFn<T = unknown>(value: ArgsFn): MapFn<IProvider<T>>;
 export declare class ArgsProvider<T> extends ProviderDecorator<T> {

package/typings/provider/IProvider.d.ts

@@ -13,6 +13,4 @@ export interface IProvider<T = unknown> {
 }
 export declare const provider: (...mappers: MapFn<IProvider>[]) => ClassDecorator;
 export declare const getTransformers: <T>(Target: constructor<T>) => MapFn<IProvider<T>>[];
-export declare const markAsProvider: <T>(fn: MapFn<IProvider<T>>) => MapFn<IProvider<T>>;
-export declare const isProviderMapper: <T>(fn: unknown) => fn is MapFn<IProvider<T>>;
 export declare const visible: (isVisibleWhen: ChildrenVisibilityPredicate) => MapFn<IProvider>;

package/typings/provider/singleton/Cache.d.ts

@@ -0,0 +1,6 @@
+export interface Cache<K, V> {
+    getKey(...args: unknown[]): K;
+    hasValue(key: K): boolean;
+    getValue(key: K): V;
+    setValue(key: K, value: V): void;
+}

package/typings/provider/singleton/MultiCache.d.ts

@@ -0,0 +1,10 @@
+import { Cache } from './Cache';
+export declare class MultiCache<K, V> implements Cache<K, V> {
+    readonly getKey: (...args: unknown[]) => K;
+    private instances;
+    constructor(getKey?: (...args: unknown[]) => K);
+    hasValue(token: K): boolean;
+    getValue(token: K): V;
+    setValue(token: K, value: V): void;
+}
+export declare const multiCache: <K, V>(getKey: (...args: unknown[]) => K) => MultiCache<K, V>;

package/typings/provider/singleton/SingleCache.d.ts

@@ -0,0 +1,8 @@
+import { Cache } from './Cache';
+export declare class SingleCache<V> implements Cache<string, V> {
+    private instance?;
+    getKey(...args: unknown[]): string;
+    getValue(key: string): V;
+    hasValue(key: string): boolean;
+    setValue(key: string, value: V): void;
+}

package/typings/provider/singleton/SingletonProvider.d.ts

@@ -0,0 +1,12 @@
+import { IContainer } from '../../container/IContainer';
+import { ProviderDecorator } from '../ProviderDecorator';
+import { IProvider } from '../IProvider';
+import { MapFn } from '../../utils';
+import { Cache } from './Cache';
+export declare function singleton<T = unknown>(cacheProvider?: () => Cache<unknown, T>): MapFn<IProvider<T>>;
+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, ...args: unknown[]): T;
+}

package/typings/registration/IRegistration.d.ts

@@ -6,12 +6,10 @@ export interface IRegistration<T = unknown> extends IContainerModule {
     addAliases(...aliases: Alias[]): this;
     when(isValidWhen: ScopePredicate): this;
     to(key: DependencyKey): this;
-    pipe(...mappers: (MapFn<IRegistration<T>> | MapFn<IProvider<T>>)[]): IRegistration<T>;
-    provider(...mappers: MapFn<IProvider<T>>[]): this;
+    pipe(...mappers: MapFn<IProvider<T>>[]): this;
 }
 export declare const key: (key: DependencyKey) => MapFn<IRegistration>;
 export declare const alias: (...aliases: Alias[]) => MapFn<IRegistration>;
 export declare const scope: (predicate: ScopePredicate) => MapFn<IRegistration>;
-export declare const getTransformers: <T>(Target: constructor<T>) => MapFn<IRegistration<T>>[];
-export declare const register: (...mappers: (MapFn<IRegistration> | MapFn<IProvider>)[]) => ClassDecorator;
-export declare const provider: (...mappers: MapFn<IProvider>[]) => MapFn<IRegistration>;
+export declare const getTransformers: (Target: constructor<unknown>) => MapFn<IRegistration<unknown>>[];
+export declare const register: (...mappers: MapFn<IRegistration>[]) => ClassDecorator;

package/typings/registration/Registration.d.ts

@@ -5,17 +5,16 @@ import { IRegistration, ScopePredicate } from './IRegistration';
 export declare class Registration<T = unknown> implements IRegistration<T> {
     private createProvider;
     private key?;
-    static fromClass<T>(Target: constructor<T>): IRegistration<T>;
-    static fromValue<T>(value: T): Registration<T>;
+    private matchScope;
+    static fromClass<T>(Target: constructor<T>): IRegistration<unknown>;
+    static fromValue<T>(value: T): IRegistration<unknown>;
     static fromFn<T>(fn: ResolveDependency<T>): Registration<T>;
     private aliases;
     private mappers;
-    private matchScope;
-    constructor(createProvider: () => IProvider<T>, key?: DependencyKey | undefined);
+    constructor(createProvider: () => IProvider<T>, key?: DependencyKey | undefined, matchScope?: ScopePredicate);
     to(key: DependencyKey): this;
     addAliases(...aliases: Alias[]): this;
-    pipe(...mappers: (MapFn<IRegistration<T>> | MapFn<IProvider<T>>)[]): IRegistration<T>;
-    provider(...mappers: MapFn<IProvider<T>>[]): this;
+    pipe(...mappers: MapFn<IProvider<T>>[]): this;
     applyTo(container: IContainer): void;
     when(isValidWhen: ScopePredicate): this;
 }

package/typings/utils.d.ts

@@ -4,4 +4,3 @@ 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 const isConstructor: (T: unknown) => T is constructor<unknown>;
-export declare function groupBy<T>(items: T[], predicate: (value: T) => boolean): T[][];

package/cjm/provider/SingletonProvider.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingletonProvider = exports.singleton = void 0;
-const ProviderDecorator_1 = require("./ProviderDecorator");
-const IProvider_1 = require("./IProvider");
-function singleton() {
-    return (0, IProvider_1.markAsProvider)((provider) => new SingletonProvider(provider));
-}
-exports.singleton = singleton;
-class SingletonProvider extends ProviderDecorator_1.ProviderDecorator {
-    constructor(provider) {
-        super(provider);
-        this.provider = provider;
-    }
-    resolve(container, ...args) {
-        this.instance = this.instance ?? { value: this.provider.resolve(container, ...args) };
-        return this.instance.value;
-    }
-}
-exports.SingletonProvider = SingletonProvider;

package/esm/provider/SingletonProvider.js

@@ -1,15 +0,0 @@
-import { ProviderDecorator } from './ProviderDecorator';
-import { markAsProvider } from './IProvider';
-export function singleton() {
-    return markAsProvider((provider) => new SingletonProvider(provider));
-}
-export class SingletonProvider extends ProviderDecorator {
-    constructor(provider) {
-        super(provider);
-        this.provider = provider;
-    }
-    resolve(container, ...args) {
-        this.instance = this.instance ?? { value: this.provider.resolve(container, ...args) };
-        return this.instance.value;
-    }
-}

package/typings/provider/SingletonProvider.d.ts

@@ -1,11 +0,0 @@
-import { IContainer } from '../container/IContainer';
-import { ProviderDecorator } from './ProviderDecorator';
-import { IProvider } from './IProvider';
-import { MapFn } from '../utils';
-export declare function singleton<T = unknown>(): MapFn<IProvider<T>>;
-export declare class SingletonProvider<T> extends ProviderDecorator<T> {
-    private readonly provider;
-    private instance?;
-    constructor(provider: IProvider<T>);
-    resolve(container: IContainer, ...args: unknown[]): T;
-}