ts-ioc-container 31.6.1 → 31.8.0

package/README.md

@@ -670,11 +670,17 @@ import {
   by,
   Container,
   DependencyNotFoundError,
+  IMemo,
+  IMemoKey,
   inject,
   MetadataInjector,
+  Provider,
   provider,
+  register,
   Registration as R,
+  scope,
 } from 'ts-ioc-container';
+import { constant } from '../../lib/utils.ts';
 
 describe('alias', () => {
   const IMiddlewareKey = 'IMiddleware';
@@ -747,6 +753,55 @@ describe('alias', () => {
     expect(by.alias((aliases) => aliases.has('ILogger'))(container)).toBeInstanceOf(FileLogger);
     expect(() => by.alias((aliases) => aliases.has('logger'))(container)).toThrowError(DependencyNotFoundError);
   });
+
+  it('should resolve by memoized alias', () => {
+    @provider(alias('ILogger'))
+    @register(scope((s) => s.hasTag('root')))
+    class FileLogger {}
+
+    @provider(alias('ILogger'))
+    @register(scope((s) => s.hasTag('child')))
+    class DbLogger {}
+
+    const container = new Container(new MetadataInjector(), { tags: ['root'] })
+      .register(IMemoKey, Provider.fromValue<IMemo>(new Map()))
+      .add(R.fromClass(FileLogger))
+      .add(R.fromClass(DbLogger));
+
+    const result1 = by.alias((aliases) => aliases.has('ILogger'), constant('ILogger'))(container);
+    const child = container.createScope('child');
+    const result2 = by.alias((aliases) => aliases.has('ILogger'), constant('ILogger'))(child);
+    const result3 = by.alias((aliases) => aliases.has('ILogger'))(child);
+
+    expect(result1).toBeInstanceOf(FileLogger);
+    expect(result2).toBeInstanceOf(FileLogger);
+    expect(result3).toBeInstanceOf(DbLogger);
+  });
+
+  it('should resolve by memoized aliases', () => {
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface
+    interface ILogger {}
+
+    @provider(alias('ILogger'))
+    class FileLogger implements ILogger {}
+
+    @provider(alias('ILogger'))
+    class DbLogger implements ILogger {}
+
+    class App {
+      constructor(@inject(by.aliases((it) => it.has('ILogger'), constant('ILogger'))) public loggers: ILogger[]) {}
+    }
+
+    const container = new Container(new MetadataInjector())
+      .register(IMemoKey, Provider.fromValue<IMemo>(new Map()))
+      .add(R.fromClass(FileLogger));
+
+    const loggers = container.resolve(App).loggers;
+    container.add(R.fromClass(DbLogger));
+    const loggers2 = container.resolve(App).loggers;
+
+    expect(loggers).toEqual(loggers2);
+  });
 });
 
 ```

package/cjm/by.js

@@ -1,15 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.by = exports.all = void 0;
+exports.by = exports.IMemoKey = exports.all = void 0;
 const all = () => true;
 exports.all = all;
+exports.IMemoKey = Symbol('IMemo');
 exports.by = {
-    aliases: (predicate) => (c, ...args) => c.resolveManyByAlias(predicate, { args }).values(),
+    aliases: (predicate, memoize) => (c, ...args) => {
+        const predicateFn = (aliases) => predicate(aliases, c);
+        const memoKey = memoize?.(c);
+        if (memoKey) {
+            const memo = c.resolve(exports.IMemoKey);
+            const memoized = memo.get(memoKey);
+            if (memoized) {
+                return memoized.map((key) => c.resolve(key, { args }));
+            }
+            const result = c.resolveManyByAlias(predicateFn, { args });
+            memo.set(memoKey, Array.from(result.keys()));
+            return Array.from(result.values());
+        }
+        return Array.from(c.resolveManyByAlias(predicateFn, { args }).values());
+    },
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate
+     * @param memoize
      */
-    alias: (predicate) => (c, ...args) => c.resolveOneByAlias(predicate, { args }),
+    alias: (predicate, memoize) => (c, ...args) => {
+        const predicateFn = (aliases) => predicate(aliases, c);
+        const memoKey = memoize?.(c);
+        if (memoKey) {
+            const memo = c.resolve(exports.IMemoKey);
+            const memoized = memo.get(memoKey);
+            if (memoized) {
+                return c.resolve(memoized[0], { args });
+            }
+            const [key, result] = c.resolveOneByAlias(predicateFn, { args });
+            memo.set(memoKey, [key]);
+            return result;
+        }
+        return c.resolveOneByAlias(predicateFn, { args })[1];
+    },
     /**
      * Get all instances that match the given keys
      * @param keys

package/cjm/container/Container.js

@@ -82,9 +82,9 @@ class Container {
         return this.parent.resolveManyByAlias(predicate, { args, child }, result);
     }
     resolveOneByAlias(predicate, { args = [], child = this } = {}) {
-        for (const [, provider] of this.providers.entries()) {
+        for (const [key, provider] of this.providers.entries()) {
             if (provider.matchAliases(predicate) && provider.isVisible(this, child)) {
-                return provider.resolve(this, ...args);
+                return [key, provider.resolve(this, ...args)];
             }
         }
         return this.parent.resolveOneByAlias(predicate, { args, child });

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.Registration = exports.register = exports.scope = exports.key = exports.AutoMockedContainer = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.ProviderDecorator = exports.Provider = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.IMemoKey = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.Registration = exports.register = exports.scope = exports.key = exports.AutoMockedContainer = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = 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");
@@ -19,10 +19,9 @@ Object.defineProperty(exports, "visible", { enumerable: true, get: function () {
 Object.defineProperty(exports, "alias", { enumerable: true, get: function () { return IProvider_1.alias; } });
 Object.defineProperty(exports, "argsFn", { enumerable: true, get: function () { return IProvider_1.argsFn; } });
 Object.defineProperty(exports, "args", { enumerable: true, get: function () { return IProvider_1.args; } });
+Object.defineProperty(exports, "ProviderDecorator", { enumerable: true, get: function () { return IProvider_1.ProviderDecorator; } });
 var Provider_1 = require("./provider/Provider");
 Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return Provider_1.Provider; } });
-var ProviderDecorator_1 = require("./provider/ProviderDecorator");
-Object.defineProperty(exports, "ProviderDecorator", { enumerable: true, get: function () { return ProviderDecorator_1.ProviderDecorator; } });
 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; } });
@@ -50,6 +49,7 @@ Object.defineProperty(exports, "hook", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "hasHooks", { enumerable: true, get: function () { return hook_1.hasHooks; } });
 var by_1 = require("./by");
 Object.defineProperty(exports, "by", { enumerable: true, get: function () { return by_1.by; } });
+Object.defineProperty(exports, "IMemoKey", { enumerable: true, get: function () { return by_1.IMemoKey; } });
 var metadata_1 = require("./metadata");
 Object.defineProperty(exports, "setMetadata", { enumerable: true, get: function () { return metadata_1.setMetadata; } });
 Object.defineProperty(exports, "getMetadata", { enumerable: true, get: function () { return metadata_1.getMetadata; } });

package/cjm/provider/IProvider.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.visible = exports.alias = exports.getTransformers = exports.provider = exports.argsFn = exports.args = void 0;
+exports.ProviderDecorator = exports.visible = exports.alias = exports.getTransformers = exports.provider = exports.argsFn = exports.args = void 0;
+const utils_1 = require("../utils");
 const metadata_1 = require("../metadata");
 function args(...extraArgs) {
     return (provider) => provider.setArgs(() => extraArgs);
@@ -19,3 +20,33 @@ const alias = (...aliases) => (r) => r.addAliases(...aliases);
 exports.alias = alias;
 const visible = (isVisibleWhen) => (p) => p.setVisibility(isVisibleWhen);
 exports.visible = visible;
+class ProviderDecorator {
+    constructor(decorated) {
+        this.decorated = decorated;
+    }
+    setVisibility(predicate) {
+        this.decorated.setVisibility(predicate);
+        return this;
+    }
+    isVisible(parent, child) {
+        return this.decorated.isVisible(parent, child);
+    }
+    resolve(container, ...args) {
+        return this.decorated.resolve(container, ...args);
+    }
+    pipe(...mappers) {
+        return (0, utils_1.pipe)(...mappers)(this);
+    }
+    matchAliases(predicate) {
+        return this.decorated.matchAliases(predicate);
+    }
+    addAliases(...aliases) {
+        this.decorated.addAliases(...aliases);
+        return this;
+    }
+    setArgs(argsFn) {
+        this.decorated.setArgs(argsFn);
+        return this;
+    }
+}
+exports.ProviderDecorator = ProviderDecorator;

package/cjm/provider/singleton/SingletonProvider.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingletonProvider = exports.singleton = void 0;
-const ProviderDecorator_1 = require("../ProviderDecorator");
+const IProvider_1 = require("../IProvider");
 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 {
+class SingletonProvider extends IProvider_1.ProviderDecorator {
     constructor(provider, cache) {
         super(provider);
         this.provider = provider;

package/esm/by.js

@@ -1,11 +1,41 @@
 export const all = () => true;
+export const IMemoKey = Symbol('IMemo');
 export const by = {
-    aliases: (predicate) => (c, ...args) => c.resolveManyByAlias(predicate, { args }).values(),
+    aliases: (predicate, memoize) => (c, ...args) => {
+        const predicateFn = (aliases) => predicate(aliases, c);
+        const memoKey = memoize?.(c);
+        if (memoKey) {
+            const memo = c.resolve(IMemoKey);
+            const memoized = memo.get(memoKey);
+            if (memoized) {
+                return memoized.map((key) => c.resolve(key, { args }));
+            }
+            const result = c.resolveManyByAlias(predicateFn, { args });
+            memo.set(memoKey, Array.from(result.keys()));
+            return Array.from(result.values());
+        }
+        return Array.from(c.resolveManyByAlias(predicateFn, { args }).values());
+    },
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate
+     * @param memoize
      */
-    alias: (predicate) => (c, ...args) => c.resolveOneByAlias(predicate, { args }),
+    alias: (predicate, memoize) => (c, ...args) => {
+        const predicateFn = (aliases) => predicate(aliases, c);
+        const memoKey = memoize?.(c);
+        if (memoKey) {
+            const memo = c.resolve(IMemoKey);
+            const memoized = memo.get(memoKey);
+            if (memoized) {
+                return c.resolve(memoized[0], { args });
+            }
+            const [key, result] = c.resolveOneByAlias(predicateFn, { args });
+            memo.set(memoKey, [key]);
+            return result;
+        }
+        return c.resolveOneByAlias(predicateFn, { args })[1];
+    },
     /**
      * Get all instances that match the given keys
      * @param keys

package/esm/container/Container.js

@@ -79,9 +79,9 @@ export class Container {
         return this.parent.resolveManyByAlias(predicate, { args, child }, result);
     }
     resolveOneByAlias(predicate, { args = [], child = this } = {}) {
-        for (const [, provider] of this.providers.entries()) {
+        for (const [key, provider] of this.providers.entries()) {
             if (provider.matchAliases(predicate) && provider.isVisible(this, child)) {
-                return provider.resolve(this, ...args);
+                return [key, provider.resolve(this, ...args)];
             }
         }
         return this.parent.resolveOneByAlias(predicate, { args, child });

package/esm/index.js

@@ -4,9 +4,8 @@ export { EmptyContainer } from './container/EmptyContainer';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
-export { provider, visible, alias, argsFn, args } from './provider/IProvider';
+export { provider, visible, alias, argsFn, args, ProviderDecorator, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
-export { ProviderDecorator } from './provider/ProviderDecorator';
 export { singleton, SingletonProvider } from './provider/singleton/SingletonProvider';
 export { MultiCache, multiCache } from './provider/singleton/MultiCache';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
@@ -16,5 +15,5 @@ export { MetadataInjector, inject } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 export { getHooks, hook, hasHooks } from './hook';
-export { by } from './by';
+export { by, IMemoKey } from './by';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/esm/provider/IProvider.js

@@ -1,3 +1,4 @@
+import { pipe } from '../utils';
 import { getMetadata, setMetadata } from '../metadata';
 export function args(...extraArgs) {
     return (provider) => provider.setArgs(() => extraArgs);
@@ -10,3 +11,32 @@ export const provider = (...mappers) => setMetadata(METADATA_KEY, mappers);
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];
 export const alias = (...aliases) => (r) => r.addAliases(...aliases);
 export const visible = (isVisibleWhen) => (p) => p.setVisibility(isVisibleWhen);
+export class ProviderDecorator {
+    constructor(decorated) {
+        this.decorated = decorated;
+    }
+    setVisibility(predicate) {
+        this.decorated.setVisibility(predicate);
+        return this;
+    }
+    isVisible(parent, child) {
+        return this.decorated.isVisible(parent, child);
+    }
+    resolve(container, ...args) {
+        return this.decorated.resolve(container, ...args);
+    }
+    pipe(...mappers) {
+        return pipe(...mappers)(this);
+    }
+    matchAliases(predicate) {
+        return this.decorated.matchAliases(predicate);
+    }
+    addAliases(...aliases) {
+        this.decorated.addAliases(...aliases);
+        return this;
+    }
+    setArgs(argsFn) {
+        this.decorated.setArgs(argsFn);
+        return this;
+    }
+}

package/esm/provider/singleton/SingletonProvider.js

@@ -1,4 +1,4 @@
-import { ProviderDecorator } from '../ProviderDecorator';
+import { ProviderDecorator } from '../IProvider';
 import { SingleCache } from './SingleCache';
 export function singleton(cacheProvider) {
     return (provider) => new SingletonProvider(provider, cacheProvider ? cacheProvider() : new SingleCache());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "31.6.1",
+  "version": "31.8.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "737c7b3dfb38d9c4950311f46d598ff61e2f70dc"
+  "gitHead": "fa737f07d8b3f1bf9ab0bd33bbdd00cdcc823293"
 }

package/typings/by.d.ts

@@ -1,13 +1,16 @@
-import { AliasPredicate, IContainer, InjectionToken } from './container/IContainer';
+import { DependencyKey, IContainer, InjectionToken } from './container/IContainer';
 export type InstancePredicate = (dep: unknown) => boolean;
 export declare const all: InstancePredicate;
+export type IMemo = Map<string, DependencyKey[]>;
+export declare const IMemoKey: unique symbol;
 export declare const by: {
-    aliases: (predicate: AliasPredicate) => (c: IContainer, ...args: unknown[]) => IterableIterator<unknown>;
+    aliases: (predicate: (it: Set<string>, s: IContainer) => boolean, memoize?: ((c: IContainer) => string) | undefined) => (c: IContainer, ...args: unknown[]) => unknown[];
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate
+     * @param memoize
      */
-    alias: (predicate: AliasPredicate) => (c: IContainer, ...args: unknown[]) => unknown;
+    alias: (predicate: (it: Set<string>, s: IContainer) => boolean, memoize?: ((c: IContainer) => string) | undefined) => (c: IContainer, ...args: unknown[]) => unknown;
     /**
      * Get all instances that match the given keys
      * @param keys

package/typings/container/AutoMockedContainer.d.ts

@@ -14,5 +14,5 @@ export declare abstract class AutoMockedContainer implements IContainer {
     hasTag(): boolean;
     add(registration: IRegistration): this;
     resolveManyByAlias(predicate: AliasPredicate, options?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
-    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): T;
+    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): [DependencyKey, T];
 }

package/typings/container/Container.d.ts

@@ -25,7 +25,7 @@ export declare class Container implements IContainer {
     use(module: IContainerModule): this;
     hasDependency(key: DependencyKey): boolean;
     resolveManyByAlias(predicate: AliasPredicate, { args, child }?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
-    resolveOneByAlias<T>(predicate: AliasPredicate, { args, child }?: ResolveOptions): T;
+    resolveOneByAlias<T>(predicate: AliasPredicate, { args, child }?: ResolveOptions): [DependencyKey, T];
     /**
      * @private
      */

package/typings/container/EmptyContainer.d.ts

@@ -15,5 +15,5 @@ export declare class EmptyContainer implements IContainer {
     use(module: IContainerModule): this;
     add(registration: IRegistration): this;
     resolveManyByAlias(predicate: AliasPredicate, options?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
-    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): T;
+    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): [DependencyKey, T];
 }

package/typings/container/IContainer.d.ts

@@ -33,5 +33,5 @@ export interface IContainer extends Resolvable, Tagged {
     getRegistrations(): IRegistration[];
     hasDependency(key: DependencyKey): boolean;
     resolveManyByAlias(predicate: AliasPredicate, options?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
-    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): T;
+    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): [DependencyKey, T];
 }

package/typings/index.d.ts

@@ -6,9 +6,8 @@ export { IInjector } from './injector/IInjector';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
-export { ResolveDependency, IProvider, provider, visible, alias, argsFn, args, ArgsFn } from './provider/IProvider';
+export { ResolveDependency, IProvider, provider, visible, alias, argsFn, args, ArgsFn, ProviderDecorator, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
-export { ProviderDecorator } from './provider/ProviderDecorator';
 export { singleton, SingletonProvider } from './provider/singleton/SingletonProvider';
 export { MultiCache, multiCache } from './provider/singleton/MultiCache';
 export { Cache } from './provider/singleton/Cache';
@@ -19,5 +18,5 @@ export { MetadataInjector, inject } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 export { getHooks, hook, hasHooks } from './hook';
-export { by, InstancePredicate } from './by';
+export { by, InstancePredicate, IMemo, IMemoKey } from './by';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/typings/provider/IProvider.d.ts

@@ -21,3 +21,14 @@ export declare const provider: (...mappers: MapFn<IProvider>[]) => ClassDecorato
 export declare const getTransformers: <T>(Target: constructor<T>) => MapFn<IProvider<T>>[];
 export declare const alias: (...aliases: Alias[]) => MapFn<IProvider>;
 export declare const visible: (isVisibleWhen: ChildrenVisibilityPredicate) => MapFn<IProvider>;
+export declare abstract class ProviderDecorator<T> implements IProvider<T> {
+    private decorated;
+    protected constructor(decorated: IProvider<T>);
+    setVisibility(predicate: ChildrenVisibilityPredicate): this;
+    isVisible(parent: IContainer, child: Tagged): boolean;
+    resolve(container: IContainer, ...args: unknown[]): T;
+    pipe(...mappers: MapFn<IProvider<T>>[]): IProvider<T>;
+    matchAliases(predicate: AliasPredicate): boolean;
+    addAliases(...aliases: Alias[]): this;
+    setArgs(argsFn: ArgsFn): this;
+}

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

@@ -1,6 +1,5 @@
 import { IContainer } from '../../container/IContainer';
-import { ProviderDecorator } from '../ProviderDecorator';
-import { IProvider } from '../IProvider';
+import { IProvider, ProviderDecorator } from '../IProvider';
 import { MapFn } from '../../utils';
 import { Cache } from './Cache';
 export declare function singleton<T = unknown>(cacheProvider?: () => Cache<unknown, T>): MapFn<IProvider<T>>;

package/cjm/provider/ProviderDecorator.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderDecorator = void 0;
-const utils_1 = require("../utils");
-class ProviderDecorator {
-    constructor(decorated) {
-        this.decorated = decorated;
-    }
-    setVisibility(predicate) {
-        this.decorated.setVisibility(predicate);
-        return this;
-    }
-    isVisible(parent, child) {
-        return this.decorated.isVisible(parent, child);
-    }
-    resolve(container, ...args) {
-        return this.decorated.resolve(container, ...args);
-    }
-    pipe(...mappers) {
-        return (0, utils_1.pipe)(...mappers)(this);
-    }
-    matchAliases(predicate) {
-        return this.decorated.matchAliases(predicate);
-    }
-    addAliases(...aliases) {
-        this.decorated.addAliases(...aliases);
-        return this;
-    }
-    setArgs(argsFn) {
-        this.decorated.setArgs(argsFn);
-        return this;
-    }
-}
-exports.ProviderDecorator = ProviderDecorator;

package/esm/provider/ProviderDecorator.js

@@ -1,30 +0,0 @@
-import { pipe } from '../utils';
-export class ProviderDecorator {
-    constructor(decorated) {
-        this.decorated = decorated;
-    }
-    setVisibility(predicate) {
-        this.decorated.setVisibility(predicate);
-        return this;
-    }
-    isVisible(parent, child) {
-        return this.decorated.isVisible(parent, child);
-    }
-    resolve(container, ...args) {
-        return this.decorated.resolve(container, ...args);
-    }
-    pipe(...mappers) {
-        return pipe(...mappers)(this);
-    }
-    matchAliases(predicate) {
-        return this.decorated.matchAliases(predicate);
-    }
-    addAliases(...aliases) {
-        this.decorated.addAliases(...aliases);
-        return this;
-    }
-    setArgs(argsFn) {
-        this.decorated.setArgs(argsFn);
-        return this;
-    }
-}

package/typings/provider/ProviderDecorator.d.ts

@@ -1,14 +0,0 @@
-import { Alias, AliasPredicate, IContainer, Tagged } from '../container/IContainer';
-import { ArgsFn, ChildrenVisibilityPredicate, IProvider } from './IProvider';
-import { MapFn } from '../utils';
-export declare abstract class ProviderDecorator<T> implements IProvider<T> {
-    private decorated;
-    protected constructor(decorated: IProvider<T>);
-    setVisibility(predicate: ChildrenVisibilityPredicate): this;
-    isVisible(parent: IContainer, child: Tagged): boolean;
-    resolve(container: IContainer, ...args: unknown[]): T;
-    pipe(...mappers: MapFn<IProvider<T>>[]): IProvider<T>;
-    matchAliases(predicate: AliasPredicate): boolean;
-    addAliases(...aliases: Alias[]): this;
-    setArgs(argsFn: ArgsFn): this;
-}