ts-ioc-container 55.4.0 → 55.5.0

package/README.md

@@ -1542,7 +1542,7 @@ Constructor parameters that should pick up positional args from `ProviderOptions
 - `@inject(args(0))` — resolves the first element of the `args` array passed at resolution time
 - Works together with `token.args(...)` to pass typed dependencies through the args context
 
-`args(index)` and `argsFn(fn)` are thin shortcuts for an `InjectFn`. Every `InjectFn` receives `(scope, options)`, where `options.args` is the runtime args array — so `args(0)` is just `(scope, { args = [] }) => args[0]`, and `argsFn(fn)` is `(scope, { args = [] }) => fn(...args)` (the runtime args are spread into your callback as positional parameters).
+`argsFn(predicate)` is the general form: it iterates the runtime `args` array and returns the **first argument matching** `predicate(value, index)` — think `args.find(predicate)`. `args(index)` is just a shortcut for matching by position: `args(0)` is `argsFn((value, index) => index === 0)`. Every `InjectFn` receives `(scope, options)`, where `options.args` is the runtime args array.
 
 ### Immutable token chaining
 

package/cjm/container/Container.js

@@ -6,7 +6,6 @@ const ContainerDisposedError_1 = require("../errors/ContainerDisposedError");
 const MetadataInjector_1 = require("../injector/MetadataInjector");
 const AliasMap_1 = require("./AliasMap");
 const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
-const ContainerNotFoundError_1 = require("../errors/ContainerNotFoundError");
 const basic_1 = require("../utils/basic");
 const array_1 = require("../utils/array");
 class Container {
@@ -137,15 +136,10 @@ class Container {
     }
     getScopeByInstanceOrFail(instance) {
         this.validateContainer();
-        const queue = [this];
-        while (queue.length > 0) {
-            const scope = queue.shift();
-            if (scope.hasInstance(instance)) {
-                return scope;
-            }
-            queue.push(...scope.getScopes());
+        if (this.hasInstance(instance)) {
+            return this;
         }
-        throw new ContainerNotFoundError_1.ContainerNotFoundError('Cannot find scope for the given instance');
+        return this.parent.getScopeByInstanceOrFail(instance);
     }
     removeScope(child) {
         this.scopes = this.scopes.filter((s) => s !== child);

package/cjm/injector/MetadataInjector.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveArgs = exports.argsFn = exports.args = exports.inject = exports.MetadataInjector = void 0;
+exports.resolveArgs = exports.args = exports.argsFn = exports.inject = exports.MetadataInjector = void 0;
 const IInjector_1 = require("./IInjector");
 const basic_1 = require("../utils/basic");
 const parameter_1 = require("../metadata/parameter");
@@ -17,12 +17,10 @@ const inject = (fn) => (target, propertyKey, parameterIndex) => {
     (0, parameter_1.addParamMeta)(hookMetaKey(propertyKey), () => (0, toToken_1.toToken)(fn))(basic_1.Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
 };
 exports.inject = inject;
-const args = (index) => (c, { args = [] }) => {
-    return args[index];
-};
-exports.args = args;
-const argsFn = (fn) => (c, options) => fn(...(options.args ?? []));
+const argsFn = (predicate) => (c, { args = [] }) => args.find((value, index) => predicate(value, index));
 exports.argsFn = argsFn;
+const args = (index) => (0, exports.argsFn)((value, i) => i === index);
+exports.args = args;
 const resolveArgs = (Target, methodName) => {
     const tokens = (0, parameter_1.getParamMeta)(hookMetaKey(methodName), Target);
     return (scope, { args = [], lazy }) => tokens.map((fn) => fn.resolve(scope, { args: args.map(toToken_1.argToToken).map((t) => t.resolve(scope)), lazy }));

package/esm/container/Container.js

@@ -3,7 +3,6 @@ import { ContainerDisposedError } from '../errors/ContainerDisposedError';
 import { MetadataInjector } from '../injector/MetadataInjector';
 import { AliasMap } from './AliasMap';
 import { DependencyNotFoundError } from '../errors/DependencyNotFoundError';
-import { ContainerNotFoundError } from '../errors/ContainerNotFoundError';
 import { Is } from '../utils/basic';
 import { Filter as F } from '../utils/array';
 export class Container {
@@ -134,15 +133,10 @@ export class Container {
     }
     getScopeByInstanceOrFail(instance) {
         this.validateContainer();
-        const queue = [this];
-        while (queue.length > 0) {
-            const scope = queue.shift();
-            if (scope.hasInstance(instance)) {
-                return scope;
-            }
-            queue.push(...scope.getScopes());
+        if (this.hasInstance(instance)) {
+            return this;
         }
-        throw new ContainerNotFoundError('Cannot find scope for the given instance');
+        return this.parent.getScopeByInstanceOrFail(instance);
     }
     removeScope(child) {
         this.scopes = this.scopes.filter((s) => s !== child);

package/esm/injector/MetadataInjector.js

@@ -12,10 +12,8 @@ const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
 export const inject = (fn) => (target, propertyKey, parameterIndex) => {
     addParamMeta(hookMetaKey(propertyKey), () => toToken(fn))(Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
 };
-export const args = (index) => (c, { args = [] }) => {
-    return args[index];
-};
-export const argsFn = (fn) => (c, options) => fn(...(options.args ?? []));
+export const argsFn = (predicate) => (c, { args = [] }) => args.find((value, index) => predicate(value, index));
+export const args = (index) => argsFn((value, i) => i === index);
 export const resolveArgs = (Target, methodName) => {
     const tokens = getParamMeta(hookMetaKey(methodName), Target);
     return (scope, { args = [], lazy }) => tokens.map((fn) => fn.resolve(scope, { args: args.map(argToToken).map((t) => t.resolve(scope)), lazy }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "55.4.0",
+  "version": "55.5.0",
   "description": "Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.",
   "workspaces": [
     "docs"

package/typings/injector/MetadataInjector.d.ts

@@ -8,6 +8,6 @@ export declare class MetadataInjector extends Injector implements IInjector {
     protected createInstance<T>(scope: IContainer, Target: constructor<T>, { args: deps }?: InjectOptions): T;
 }
 export declare const inject: <T>(fn: InjectionToken<T> | InjectFn<T> | symbol | string | constructor<T>) => ParameterDecorator;
+export declare const argsFn: <T = unknown>(predicate: (value: unknown, index: number) => boolean) => InjectFn<T>;
 export declare const args: (index: number) => InjectFn;
-export declare const argsFn: <T>(fn: (...args: unknown[]) => T) => InjectFn<T>;
 export declare const resolveArgs: (Target: constructor<unknown>, methodName?: string) => (scope: IContainer, { args, lazy }: ProviderOptions) => unknown[];