@tstdl/base 0.93.23 → 0.93.25

package/injector/injector.d.ts

@@ -36,6 +36,7 @@ export type ResolveManyReturnType<T extends ResolveManyItem<any, any>[]> = {
 export type AddDisposeHandler = (handler: Disposable | AsyncDisposable | (() => any)) => void;
 export declare class Injector implements AsyncDisposable {
     #private;
+    readonly id: number;
     readonly name: string;
     get disposed(): boolean;
     constructor(name: string, parent?: Injector | null);

package/injector/injector.js

@@ -18,6 +18,7 @@ import { ResolveChain } from './resolve-chain.js';
 import { ResolveError } from './resolve.error.js';
 import { injectMetadataSymbol, injectableMetadataSymbol } from './symbols.js';
 import { getTokenName } from './token.js';
+let _id = 1;
 export class Injector {
     static #globalRegistrations = new Map();
     #parent;
@@ -28,6 +29,7 @@ export class Injector {
     #registrations = new Map();
     #injectorScopedResolutions = new MultiKeyMap();
     #addDisposeHandler;
+    id = _id++;
     name;
     get disposed() {
         return this.#disposableStack.disposed;
@@ -318,22 +320,18 @@ export class Injector {
         if (isUndefined(token)) {
             throw new ResolveError('Token is undefined. This might be due to a circular dependency. Consider using an alias or forwardRef.', chain);
         }
-        const ownValues = [];
-        const parentValues = [];
-        const registration = this.tryGetRegistration(token, options);
+        const registration = this.tryGetRegistration(token);
         if (isDefined(registration)) {
             const registrations = isArray(registration) ? registration : [registration];
-            const resolved = registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
-            ownValues.push(...resolved);
+            return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
         }
         if ((options.onlySelf != true) && isNotNull(this.#parent)) {
-            parentValues.push(...this.#parent._resolveAll(token, argument, options, context, chain));
+            return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
         }
-        const allValues = [...ownValues, ...parentValues];
-        if ((allValues.length == 0) && (options.optional != true)) {
-            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        if (options.optional == true) {
+            return [];
         }
-        return allValues;
+        throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
     }
     _resolveRegistration(registration, argument, options, context, chain) {
         checkOverflow(chain, context);
@@ -358,7 +356,7 @@ export class Injector {
         }
         // A new scope is only needed if we are instantiating a class, running a factory, or if the registration explicitly defines scoped providers.
         const needsNewScope = isClassProvider(provider) || isFactoryProvider(provider) || (providers.length > 0);
-        const injector = needsNewScope ? this.fork(`[${getTokenName(token)}]ResolutionInjector`) : this;
+        const injector = needsNewScope ? this.fork(`[${getTokenName(token)}]Injector`) : this;
         for (const nestedProvider of providers) {
             injector.registerSingleton(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
         }

package/injector/resolve-chain.d.ts

@@ -6,7 +6,9 @@ export type ResolveChainNodeBase<Type extends string> = {
     type: Type;
     forwardRef?: true;
 };
-export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
+export type ResolveChainNode = {
+    type: 'ellipsis';
+} | ResolveChainNodeBase<'token'> & {
     token: InjectionToken;
 } | ResolveChainNodeBase<'inject'> & {
     token: InjectionToken;

package/injector/resolve-chain.js

@@ -41,9 +41,13 @@ export class ResolveChain {
         if (chain.length < this.length) {
             chainString += '\n       [...]';
         }
-        const longestInjectorName = Math.max(...chain.nodes.map((node) => node.injector.name.length));
+        const longestInjectorName = Math.max(...chain.nodes.map((node) => (node.type == 'ellipsis') ? 0 : `${node.injector.name}#${node.injector.id}`.length));
         for (const node of chain.nodes) {
-            const paddedInjectorName = node.injector.name.padStart(longestInjectorName);
+            if (node.type == 'ellipsis') {
+                chainString += `\n    ${'[...]'.padStart(longestInjectorName)}`;
+                continue;
+            }
+            const paddedInjectorName = `${node.injector.name}#${node.injector.id}`.padStart(longestInjectorName);
             const tokenName = getTokenName(node.token);
             const forwardRefPrefix = node.forwardRef ? 'ForwardRef::' : '';
             switch (node.type) {
@@ -74,16 +78,29 @@ export class ResolveChain {
         return chainString;
     }
     truncate(tokenCount) {
-        const truncatedChain = [];
-        let counter = 0;
-        for (let i = this.nodes.length - 1; (i >= 0) && (counter < tokenCount); i--) {
+        const startOfChain = [];
+        const endOfChain = [];
+        let startCounter = 0;
+        let index = 0;
+        for (index = 0; (index < this.nodes.length) && (startCounter < tokenCount); index++) {
+            const node = this.nodes[index];
+            startOfChain.push(node);
+            if (node.type == 'token') {
+                startCounter++;
+            }
+        }
+        let endCounter = 0;
+        for (let i = this.nodes.length - 1; (i > index) && (endCounter < tokenCount); i--) {
             const node = this.nodes[i];
-            truncatedChain.unshift(node);
+            endOfChain.unshift(node);
             if (node.type == 'token') {
-                counter++;
+                endCounter++;
             }
         }
-        return new ResolveChain(truncatedChain);
+        if (endOfChain.length > 0) {
+            startOfChain.push({ type: 'ellipsis' });
+        }
+        return new ResolveChain([...startOfChain, ...endOfChain]);
     }
 }
 function getPropertyKeyString(key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.23",
+  "version": "0.93.25",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"