@tstdl/base 0.93.22 → 0.93.24

package/application/application.js

@@ -110,7 +110,7 @@ let Application = Application_1 = class Application {
     async runModules(modules) {
         const promises = modules.map(async (module) => {
             try {
-                this.#logger.info(`Starting module ${module.name}`);
+                this.#logger.info(`Starting module ${module.name}.`);
                 await runInInjectionContext(this.#injector, async () => await module.run());
                 this.#logger.info(`Module ${module.name} stopped.`);
             }
@@ -126,7 +126,7 @@ let Application = Application_1 = class Application {
             if (module.state == ModuleState.Stopped) {
                 return;
             }
-            this.#logger.info(`Stopping module ${module.name}`);
+            this.#logger.info(`Stopping module ${module.name}.`);
             try {
                 await module.stop();
             }

package/injector/injector.d.ts

@@ -36,7 +36,9 @@ 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;
+    readonly nameWithId: 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,12 +29,15 @@ export class Injector {
     #registrations = new Map();
     #injectorScopedResolutions = new MultiKeyMap();
     #addDisposeHandler;
+    id = _id++;
     name;
+    nameWithId;
     get disposed() {
         return this.#disposableStack.disposed;
     }
     constructor(name, parent = null) {
         this.name = name;
+        this.nameWithId = `${name}#${this.id}`;
         this.#parent = parent;
         this.register(Injector, { useValue: this });
         this.register(CancellationSignal, { useValue: this.#disposeToken.signal });
@@ -171,7 +175,7 @@ export class Injector {
     }
     resolve(token, argument, options = {}) {
         const context = newInternalResolveContext();
-        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(token));
+        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(this, token));
         try {
             postProcess(context);
             context.$done.resolve();
@@ -187,7 +191,7 @@ export class Injector {
     }
     resolveAll(token, argument, options = {}) {
         const context = newInternalResolveContext();
-        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(token));
+        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(this, token));
         try {
             postProcess(context);
             context.$done.resolve();
@@ -218,7 +222,7 @@ export class Injector {
     }
     async resolveAsync(token, argument, options = {}) {
         const context = newInternalResolveContext();
-        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(token));
+        const value = this._resolve(token, argument, options, context, ResolveChain.startWith(this, token));
         try {
             await postProcessAsync(context);
             context.$done.resolve();
@@ -234,7 +238,7 @@ export class Injector {
     }
     async resolveAllAsync(token, argument, options = {}) {
         const context = newInternalResolveContext();
-        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(token));
+        const values = this._resolveAll(token, argument, options, context, ResolveChain.startWith(this, token));
         try {
             await postProcessAsync(context);
             context.$done.resolve();
@@ -265,8 +269,8 @@ export class Injector {
     }
     _resolveManyTokens(tokens, context) {
         return tokens.map((token) => (isArray(token)
-            ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(token[0]))
-            : this._resolve(token, undefined, {}, context, ResolveChain.startWith(token))));
+            ? this._resolve(token[0], token[1], token[2] ?? {}, context, ResolveChain.startWith(this, token[0]))
+            : this._resolve(token, undefined, {}, context, ResolveChain.startWith(this, token))));
     }
     _resolve(token, argument, options, context, chain) {
         this.assertNotDisposed();
@@ -416,9 +420,9 @@ export class Injector {
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
                 injectionContext.argument = arg;
                 if (provider.resolveAll == true) {
-                    return this._resolveAll(innerToken, arg, options, context, chain.addToken(innerToken));
+                    return this._resolveAll(innerToken, arg, options, context, chain.addToken(this, innerToken));
                 }
-                result = { value: this._resolve(innerToken, arg, options, context, chain.addToken(innerToken)) };
+                result = { value: this._resolve(innerToken, arg, options, context, chain.addToken(this, innerToken)) };
             }
             else if (isFactoryProvider(provider)) {
                 const arg = resolveArgument ?? provider.defaultArgument ?? provider.defaultArgumentProvider?.();
@@ -440,7 +444,7 @@ export class Injector {
         }
     }
     resolveClassInjection(resolutionTag, context, constructor, metadata, resolveArgument, chain) {
-        const getChain = (injectToken) => chain.addParameter(constructor, metadata.index, injectToken);
+        const getChain = (injectToken) => chain.addParameter(this, constructor, metadata.index, injectToken);
         const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
         const injectToken = (injectMetadata.injectToken ?? metadata.type);
         if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
@@ -460,7 +464,7 @@ export class Injector {
         return resolved;
     }
     resolveInjection(token, argument, options, context, injectIndex, chain) {
-        return this._resolve(token, argument, options, context, chain.addInject(token, injectIndex));
+        return this._resolve(token, argument, options, context, chain.addInject(this, token, injectIndex));
     }
     async resolveInjectionAsync(token, argument, options, context, injectIndex, chain) {
         const value = this.resolveInjection(token, argument, options, context, injectIndex, chain);
@@ -468,7 +472,7 @@ export class Injector {
         return value;
     }
     resolveInjectionAll(token, argument, options, context, injectIndex, chain) {
-        return this._resolveAll(token, argument, options, context, chain.addInject(token, injectIndex));
+        return this._resolveAll(token, argument, options, context, chain.addInject(this, token, injectIndex));
     }
     async resolveInjectionAllAsync(token, argument, options, context, injectIndex, chain) {
         const values = this.resolveInjectionAll(token, argument, options, context, injectIndex, chain);
@@ -477,8 +481,8 @@ export class Injector {
     }
     getResolveContext(resolutionTag, resolveContext, chain) {
         return {
-            resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
-            resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(token)),
+            resolve: (token, argument, options) => this._resolve(token, argument, options ?? {}, resolveContext, chain.addToken(this, token)),
+            resolveAll: (token, argument, options) => this._resolveAll(token, argument, options ?? {}, resolveContext, chain.addToken(this, token)),
             cancellationSignal: this.#disposeToken,
             addDisposeHandler: this.#addDisposeHandler,
             get data() {

package/injector/resolve-chain.d.ts

@@ -1,10 +1,14 @@
 import type { AbstractConstructor } from '../types/index.js';
+import type { Injector } from './injector.js';
 import type { InjectionToken } from './token.js';
 export type ResolveChainNodeBase<Type extends string> = {
+    injector: Injector;
     type: Type;
     forwardRef?: true;
 };
-export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
+export type ResolveChainNode = {
+    type: 'ellipsis';
+} | ResolveChainNodeBase<'token'> & {
     token: InjectionToken;
 } | ResolveChainNodeBase<'inject'> & {
     token: InjectionToken;
@@ -23,11 +27,11 @@ export declare class ResolveChain {
     get length(): number;
     /** @deprecated for internal use only */
     constructor(nodes: ResolveChainNode[]);
-    static startWith(token: InjectionToken): ResolveChain;
-    addToken(token: InjectionToken): ResolveChain;
-    addInject(token: InjectionToken, index: number): ResolveChain;
-    addParameter(constructor: AbstractConstructor, index: number, token: InjectionToken): ResolveChain;
-    addProperty(constructor: AbstractConstructor, property: PropertyKey, token: InjectionToken): ResolveChain;
+    static startWith(injector: Injector, token: InjectionToken): ResolveChain;
+    addToken(injector: Injector, token: InjectionToken): ResolveChain;
+    addInject(injector: Injector, token: InjectionToken, index: number): ResolveChain;
+    addParameter(injector: Injector, constructor: AbstractConstructor, index: number, token: InjectionToken): ResolveChain;
+    addProperty(injector: Injector, constructor: AbstractConstructor, property: PropertyKey, token: InjectionToken): ResolveChain;
     markAsForwardRef(forwardToken: InjectionToken): ResolveChain;
     format(truncate?: number): string;
     truncate(tokenCount: number): ResolveChain;

package/injector/resolve-chain.js

@@ -1,5 +1,6 @@
 import { reflectionRegistry } from '../reflection/index.js';
 import { assertDefinedPass, isDefined } from '../utils/type-guards.js';
+import { start } from 'repl';
 import { getTokenName } from './token.js';
 export class ResolveChain {
     nodes;
@@ -10,24 +11,24 @@ export class ResolveChain {
     constructor(nodes) {
         this.nodes = nodes;
     }
-    static startWith(token) {
+    static startWith(injector, token) {
         const chain = new ResolveChain([]);
-        return chain.addToken(token);
+        return chain.addToken(injector, token);
     }
-    addToken(token) {
-        const node = { type: 'token', token };
+    addToken(injector, token) {
+        const node = { injector, type: 'token', token };
         return new ResolveChain([...this.nodes, node]);
     }
-    addInject(token, index) {
-        const node = { type: 'inject', token, index };
+    addInject(injector, token, index) {
+        const node = { injector, type: 'inject', token, index };
         return new ResolveChain([...this.nodes, node]);
     }
-    addParameter(constructor, index, token) {
-        const node = { type: 'parameter', constructor, index, token };
+    addParameter(injector, constructor, index, token) {
+        const node = { injector, type: 'parameter', constructor, index, token };
         return new ResolveChain([...this.nodes, node]);
     }
-    addProperty(constructor, property, token) {
-        const node = { type: 'property', constructor, property, token };
+    addProperty(injector, constructor, property, token) {
+        const node = { injector, type: 'property', constructor, property, token };
         return new ResolveChain([...this.nodes, node]);
     }
     markAsForwardRef(forwardToken) {
@@ -41,16 +42,22 @@ export class ResolveChain {
         if (chain.length < this.length) {
             chainString += '\n       [...]';
         }
+        const longestInjectorName = Math.max(...chain.nodes.map((node) => (node.type == 'ellipsis') ? 0 : node.injector.nameWithId.length));
         for (const node of chain.nodes) {
+            if (node.type == 'ellipsis') {
+                chainString += `\n    ${'[...]'.padStart(longestInjectorName)}`;
+                continue;
+            }
+            const paddedInjectorName = node.injector.name.padStart(longestInjectorName);
             const tokenName = getTokenName(node.token);
             const forwardRefPrefix = node.forwardRef ? 'ForwardRef::' : '';
             switch (node.type) {
                 case 'token':
-                    chainString += `\n    -> ${forwardRefPrefix}${tokenName}`;
+                    chainString += `\n    ${paddedInjectorName} -> ${forwardRefPrefix}${tokenName}`;
                     break;
                 case 'inject':
                     chainString += ` => inject(${forwardRefPrefix}${tokenName}) [${node.index + 1}]`;
-                    chainString += `\n    -> ${tokenName}`;
+                    chainString += `\n    ${paddedInjectorName} -> ${tokenName}`;
                     break;
                 case 'parameter':
                     const metadata = reflectionRegistry.getMetadata(node.constructor);
@@ -58,12 +65,12 @@ export class ResolveChain {
                     const suffix = ', _'.repeat(assertDefinedPass(metadata?.parameters, `missing parameters metadata for ${node.constructor.name}`).length - node.index - 1);
                     chainString += `(${prefix}${forwardRefPrefix}${tokenName}${suffix})`;
                     // chainString += `\n       ${' '.repeat(1 + node.constructor.name.length + forwardRefPrefix.length + prefix.length + (tokenName.length / 2))}↓`;
-                    chainString += `\n    -> ${tokenName}`;
+                    chainString += `\n    ${paddedInjectorName} -> ${tokenName}`;
                     break;
                 case 'property':
                     const constructorName = getTokenName(node.constructor);
                     const key = getPropertyKeyString(node.property);
-                    chainString += `\n    -> ${constructorName}[${key}]: ${forwardRefPrefix}${tokenName}`;
+                    chainString += `\n    ${paddedInjectorName} -> ${constructorName}[${key}]: ${forwardRefPrefix}${tokenName}`;
                     break;
                 default:
                     throw new Error(`unknown chain node type ${node.type}`);
@@ -72,16 +79,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.22",
+  "version": "0.93.24",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/test6.js

@@ -6,10 +6,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Application } from './application/application.js';
 import { provideModule, provideSignalHandler } from './application/providers.js';
+import { NotImplementedError } from './errors/not-implemented.error.js';
 import { Singleton } from './injector/decorators.js';
 import { inject } from './injector/index.js';
 import { injectionToken } from './injector/token.js';
 import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.js';
+import { _throw } from './utils/throw.js';
 const MY_INTEGER = injectionToken('MyInteger');
 // current method
 let Foo = class Foo {
@@ -18,7 +20,7 @@ let Foo = class Foo {
 Foo = __decorate([
     Singleton({
         providers: [
-            { provide: MY_INTEGER, useValue: 42 },
+            { provide: MY_INTEGER, useFactory: () => _throw(new NotImplementedError()) },
         ],
     })
 ], Foo);