@tstdl/base 0.93.22 → 0.93.23

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.js

@@ -171,7 +171,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 +187,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 +218,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 +234,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 +265,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 +416,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 +440,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 +460,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 +468,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 +477,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,6 +1,8 @@
 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;
 };
@@ -23,11 +25,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

@@ -10,24 +10,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 +41,18 @@ export class ResolveChain {
         if (chain.length < this.length) {
             chainString += '\n       [...]';
         }
+        const longestInjectorName = Math.max(...chain.nodes.map((node) => node.injector.name.length));
         for (const node of chain.nodes) {
+            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 +60,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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.22",
+  "version": "0.93.23",
   "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);