ts-ioc-container 32.0.3 → 32.0.4

package/README.md

@@ -766,7 +766,8 @@ Alias is needed to group keys
 import 'reflect-metadata';
 import {
   alias,
-  by,
+  byAlias,
+  byAliases,
   Container,
   DependencyNotFoundError,
   IMemo,
@@ -811,7 +812,7 @@ describe('alias', () => {
   it('should resolve by some alias', () => {
     class App implements IApplication {
       private appliedMiddleware: Set<string> = new Set();
-      constructor(@inject(by.aliases((it) => it.has(IMiddlewareKey))) public middleware: IMiddleware[]) {}
+      constructor(@inject(byAliases((it) => it.has(IMiddlewareKey))) public middleware: IMiddleware[]) {}
 
       markMiddlewareAsApplied(name: string): void {
         this.appliedMiddleware.add(name);
@@ -849,8 +850,8 @@ describe('alias', () => {
 
     const container = new Container(new MetadataInjector()).add(R.fromClass(FileLogger));
 
-    expect(by.alias((aliases) => aliases.has('ILogger'))(container)).toBeInstanceOf(FileLogger);
-    expect(() => by.alias((aliases) => aliases.has('logger'))(container)).toThrowError(DependencyNotFoundError);
+    expect(byAlias((aliases) => aliases.has('ILogger'))(container)).toBeInstanceOf(FileLogger);
+    expect(() => byAlias((aliases) => aliases.has('logger'))(container)).toThrowError(DependencyNotFoundError);
   });
 
   it('should resolve by memoized alias', () => {
@@ -867,10 +868,10 @@ describe('alias', () => {
       .add(R.fromClass(FileLogger))
       .add(R.fromClass(DbLogger));
 
-    const result1 = by.alias((aliases) => aliases.has('ILogger'), { memoize: constant('ILogger') })(container);
+    const result1 = byAlias((aliases) => aliases.has('ILogger'), { memoize: constant('ILogger') })(container);
     const child = container.createScope('child');
-    const result2 = by.alias((aliases) => aliases.has('ILogger'), { memoize: constant('ILogger') })(child);
-    const result3 = by.alias((aliases) => aliases.has('ILogger'))(child);
+    const result2 = byAlias((aliases) => aliases.has('ILogger'), { memoize: constant('ILogger') })(child);
+    const result3 = byAlias((aliases) => aliases.has('ILogger'))(child);
 
     expect(result1).toBeInstanceOf(FileLogger);
     expect(result2).toBeInstanceOf(FileLogger);
@@ -889,7 +890,7 @@ describe('alias', () => {
 
     class App {
       constructor(
-        @inject(by.aliases((it) => it.has('ILogger'), { memoize: constant('ILogger') })) public loggers: ILogger[],
+        @inject(byAliases((it) => it.has('ILogger'), { memoize: constant('ILogger') })) public loggers: ILogger[],
       ) {}
     }
 

package/cjm/by.js

@@ -1,72 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.by = exports.IMemoKey = exports.all = void 0;
+exports.by = exports.byAlias = exports.byAliases = exports.IMemoKey = exports.all = void 0;
 const all = () => true;
 exports.all = all;
 exports.IMemoKey = Symbol('IMemo');
+const byAliases = (predicate, { memoize, lazy } = {}) => (c) => {
+    const predicateFn = (aliases) => predicate(aliases, c);
+    const memoKey = memoize?.(c);
+    if (memoKey === undefined) {
+        return Array.from(c.resolveManyByAlias(predicateFn, { lazy }).values());
+    }
+    const memo = c.resolve(exports.IMemoKey);
+    const memoized = memo.get(memoKey);
+    if (memoized) {
+        return memoized.map((key) => c.resolve(key, { lazy }));
+    }
+    const result = c.resolveManyByAlias(predicateFn, { lazy });
+    memo.set(memoKey, Array.from(result.keys()));
+    return Array.from(result.values());
+};
+exports.byAliases = byAliases;
+const byAlias = (predicate, { memoize, lazy } = {}) => (c) => {
+    const predicateFn = (aliases) => predicate(aliases, c);
+    const memoKey = memoize?.(c);
+    if (memoKey === undefined) {
+        return c.resolveOneByAlias(predicateFn, { lazy })[1];
+    }
+    const memo = c.resolve(exports.IMemoKey);
+    const memoized = memo.get(memoKey);
+    if (memoized) {
+        return c.resolve(memoized[0], { lazy });
+    }
+    const [key, result] = c.resolveOneByAlias(predicateFn, { lazy });
+    memo.set(memoKey, [key]);
+    return result;
+};
+exports.byAlias = byAlias;
 exports.by = {
-    aliases: (predicate, { memoize, lazy } = {}) => (c, ...args) => {
-        const predicateFn = (aliases) => predicate(aliases, c);
-        const memoKey = memoize?.(c);
-        if (memoKey === undefined) {
-            return Array.from(c.resolveManyByAlias(predicateFn, { args, lazy }).values());
-        }
-        const memo = c.resolve(exports.IMemoKey);
-        const memoized = memo.get(memoKey);
-        if (memoized) {
-            return memoized.map((key) => c.resolve(key, { args, lazy }));
-        }
-        const result = c.resolveManyByAlias(predicateFn, { args, lazy });
-        memo.set(memoKey, Array.from(result.keys()));
-        return Array.from(result.values());
-    },
-    /**
-     * Get the instance that matches the given alias or fail
-     * @param predicate
-     * @param memoize
-     */
-    alias: (predicate, { memoize, lazy } = {}) => (c, ...args) => {
-        const predicateFn = (aliases) => predicate(aliases, c);
-        const memoKey = memoize?.(c);
-        if (memoKey === undefined) {
-            return c.resolveOneByAlias(predicateFn, { args, lazy })[1];
-        }
-        const memo = c.resolve(exports.IMemoKey);
-        const memoized = memo.get(memoKey);
-        if (memoized) {
-            return c.resolve(memoized[0], { args, lazy });
-        }
-        const [key, result] = c.resolveOneByAlias(predicateFn, { args, lazy });
-        memo.set(memoKey, [key]);
-        return result;
-    },
-    /**
-     * Get all instances that match the given keys
-     * @param keys
-     * @param lazy
-     */
     keys: (keys, { lazy } = {}) => (с, ...args) => keys.map((t) => с.resolve(t, { args, lazy })),
-    /**
-     * Get the instance that matches the given key
-     * @param key
-     * @param deps
-     * @param lazy
-     */
     key: (key, { args: deps = [], lazy } = {}) => (c, ...args) => c.resolve(key, { args: [...deps, ...args], lazy }),
-    /**
-     * Get all instances that match the given predicate
-     * @param predicate
-     */
     instances: (predicate = exports.all) => (l) => l.getInstances().filter(predicate),
     scope: {
-        /**
-         * Get the current scope
-         */
         current: (container) => container,
-        /**
-         * Create a new scope with the given tags
-         * @param tags
-         */
         create: (...tags) => (l) => l.createScope(...tags),
     },
 };

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.IMemoKey = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.key = exports.decorate = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.byAliases = exports.byAlias = exports.IMemoKey = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.key = exports.decorate = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -57,6 +57,8 @@ Object.defineProperty(exports, "hasHooks", { enumerable: true, get: function ()
 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; } });
+Object.defineProperty(exports, "byAlias", { enumerable: true, get: function () { return by_1.byAlias; } });
+Object.defineProperty(exports, "byAliases", { enumerable: true, get: function () { return by_1.byAliases; } });
 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/esm/by.js

@@ -1,68 +1,41 @@
 export const all = () => true;
 export const IMemoKey = Symbol('IMemo');
+export const byAliases = (predicate, { memoize, lazy } = {}) => (c) => {
+    const predicateFn = (aliases) => predicate(aliases, c);
+    const memoKey = memoize?.(c);
+    if (memoKey === undefined) {
+        return Array.from(c.resolveManyByAlias(predicateFn, { lazy }).values());
+    }
+    const memo = c.resolve(IMemoKey);
+    const memoized = memo.get(memoKey);
+    if (memoized) {
+        return memoized.map((key) => c.resolve(key, { lazy }));
+    }
+    const result = c.resolveManyByAlias(predicateFn, { lazy });
+    memo.set(memoKey, Array.from(result.keys()));
+    return Array.from(result.values());
+};
+export const byAlias = (predicate, { memoize, lazy } = {}) => (c) => {
+    const predicateFn = (aliases) => predicate(aliases, c);
+    const memoKey = memoize?.(c);
+    if (memoKey === undefined) {
+        return c.resolveOneByAlias(predicateFn, { lazy })[1];
+    }
+    const memo = c.resolve(IMemoKey);
+    const memoized = memo.get(memoKey);
+    if (memoized) {
+        return c.resolve(memoized[0], { lazy });
+    }
+    const [key, result] = c.resolveOneByAlias(predicateFn, { lazy });
+    memo.set(memoKey, [key]);
+    return result;
+};
 export const by = {
-    aliases: (predicate, { memoize, lazy } = {}) => (c, ...args) => {
-        const predicateFn = (aliases) => predicate(aliases, c);
-        const memoKey = memoize?.(c);
-        if (memoKey === undefined) {
-            return Array.from(c.resolveManyByAlias(predicateFn, { args, lazy }).values());
-        }
-        const memo = c.resolve(IMemoKey);
-        const memoized = memo.get(memoKey);
-        if (memoized) {
-            return memoized.map((key) => c.resolve(key, { args, lazy }));
-        }
-        const result = c.resolveManyByAlias(predicateFn, { args, lazy });
-        memo.set(memoKey, Array.from(result.keys()));
-        return Array.from(result.values());
-    },
-    /**
-     * Get the instance that matches the given alias or fail
-     * @param predicate
-     * @param memoize
-     */
-    alias: (predicate, { memoize, lazy } = {}) => (c, ...args) => {
-        const predicateFn = (aliases) => predicate(aliases, c);
-        const memoKey = memoize?.(c);
-        if (memoKey === undefined) {
-            return c.resolveOneByAlias(predicateFn, { args, lazy })[1];
-        }
-        const memo = c.resolve(IMemoKey);
-        const memoized = memo.get(memoKey);
-        if (memoized) {
-            return c.resolve(memoized[0], { args, lazy });
-        }
-        const [key, result] = c.resolveOneByAlias(predicateFn, { args, lazy });
-        memo.set(memoKey, [key]);
-        return result;
-    },
-    /**
-     * Get all instances that match the given keys
-     * @param keys
-     * @param lazy
-     */
     keys: (keys, { lazy } = {}) => (с, ...args) => keys.map((t) => с.resolve(t, { args, lazy })),
-    /**
-     * Get the instance that matches the given key
-     * @param key
-     * @param deps
-     * @param lazy
-     */
     key: (key, { args: deps = [], lazy } = {}) => (c, ...args) => c.resolve(key, { args: [...deps, ...args], lazy }),
-    /**
-     * Get all instances that match the given predicate
-     * @param predicate
-     */
     instances: (predicate = all) => (l) => l.getInstances().filter(predicate),
     scope: {
-        /**
-         * Get the current scope
-         */
         current: (container) => container,
-        /**
-         * Create a new scope with the given tags
-         * @param tags
-         */
         create: (...tags) => (l) => l.createScope(...tags),
     },
 };

package/esm/index.js

@@ -21,5 +21,5 @@ export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
 // Others
 export { getHooks, hook, hasHooks } from './hook';
-export { by, IMemoKey } from './by';
+export { by, IMemoKey, byAlias, byAliases } from './by';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "32.0.3",
+  "version": "32.0.4",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "589ba5dc812a341de949b39a397518db5820d26a"
+  "gitHead": "7ce3cbc445034c3408afa7b467bdd64810e5bb92"
 }

package/typings/by.d.ts

@@ -1,53 +1,27 @@
 import { DependencyKey, IContainer, InjectionToken } from './container/IContainer';
 import { ProviderResolveOptions } from './provider/IProvider';
+import { InjectFn } from './injector/MetadataInjector';
 export type InstancePredicate = (dep: unknown) => boolean;
 export declare const all: InstancePredicate;
 export type IMemo = Map<string, DependencyKey[]>;
 export declare const IMemoKey: unique symbol;
+type AliasOptions = {
+    memoize?: (c: IContainer) => string;
+    lazy?: boolean;
+};
+type AliasPredicate = (aliases: Set<string>, container: IContainer) => boolean;
+export declare const byAliases: (predicate: AliasPredicate, { memoize, lazy }?: AliasOptions) => InjectFn<unknown[]>;
+export declare const byAlias: (predicate: AliasPredicate, { memoize, lazy }?: AliasOptions) => InjectFn;
 export declare const by: {
-    aliases: (predicate: (it: Set<string>, s: IContainer) => boolean, { memoize, lazy }?: {
-        memoize?: ((c: IContainer) => string) | undefined;
-        lazy?: boolean | undefined;
-    }) => (c: IContainer, ...args: unknown[]) => unknown[];
-    /**
-     * Get the instance that matches the given alias or fail
-     * @param predicate
-     * @param memoize
-     */
-    alias: (predicate: (it: Set<string>, s: IContainer) => boolean, { memoize, lazy }?: {
-        memoize?: ((c: IContainer) => string) | undefined;
-        lazy?: boolean | undefined;
-    }) => (c: IContainer, ...args: unknown[]) => unknown;
-    /**
-     * Get all instances that match the given keys
-     * @param keys
-     * @param lazy
-     */
     keys: (keys: InjectionToken[], { lazy }?: Pick<ProviderResolveOptions, 'lazy'>) => (с: IContainer, ...args: unknown[]) => unknown[];
-    /**
-     * Get the instance that matches the given key
-     * @param key
-     * @param deps
-     * @param lazy
-     */
     key: <T>(key: InjectionToken<T>, { args: deps, lazy }?: {
         args?: unknown[] | undefined;
         lazy?: boolean | undefined;
     }) => (c: IContainer, ...args: unknown[]) => T;
-    /**
-     * Get all instances that match the given predicate
-     * @param predicate
-     */
     instances: (predicate?: InstancePredicate) => (l: IContainer) => unknown[];
     scope: {
-        /**
-         * Get the current scope
-         */
         current: (container: IContainer) => IContainer;
-        /**
-         * Create a new scope with the given tags
-         * @param tags
-         */
         create: (...tags: string[]) => (l: IContainer) => IContainer;
     };
 };
+export {};

package/typings/index.d.ts

@@ -18,6 +18,6 @@ export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
 export { getHooks, hook, hasHooks } from './hook';
-export { by, InstancePredicate, IMemo, IMemoKey } from './by';
+export { by, InstancePredicate, IMemo, IMemoKey, byAlias, byAliases } from './by';
 export { constructor } from './utils';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/typings/injector/MetadataInjector.d.ts

@@ -1,9 +1,8 @@
 import { IInjector, InjectOptions } from './IInjector';
 import { IContainer } from '../container/IContainer';
 import { constructor } from '../utils';
-type InjectFn<T = unknown> = (l: IContainer, ...args: unknown[]) => T;
+export type InjectFn<T = unknown> = (l: IContainer) => T;
 export declare const inject: (fn: InjectFn) => ParameterDecorator;
 export declare class MetadataInjector implements IInjector {
     resolve<T>(container: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
 }
-export {};