@tstdl/base 0.93.125 → 0.93.126

package/injector/resolve-chain.d.ts

@@ -1,10 +1,16 @@
 import type { AbstractConstructor } from '../types/index.js';
-import type { Injector } from './injector.js';
+import type { Injector, Registration } from './injector.js';
 import type { InjectionToken } from './token.js';
 export type ResolveChainNodeBase<Type extends string> = {
     injector: Injector;
+    resolvedBy?: Injector;
     type: Type;
     forwardRef?: true;
+    optional?: boolean;
+    multi?: boolean;
+    argument?: any;
+    registration?: Registration;
+    isCached?: boolean;
 };
 export type ResolveChainNode = {
     type: 'ellipsis';
@@ -22,17 +28,25 @@ export type ResolveChainNode = {
     property: PropertyKey;
     token: InjectionToken;
 };
+export type ResolveChainNodeOptions = {
+    optional?: boolean;
+    multi?: boolean;
+    argument?: any;
+};
 export declare class ResolveChain {
     readonly nodes: readonly ResolveChainNode[];
     get length(): number;
     /** @deprecated for internal use only */
     constructor(nodes: ResolveChainNode[]);
-    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;
+    static startWith(injector: Injector, token: InjectionToken, options?: ResolveChainNodeOptions): ResolveChain;
+    addToken(injector: Injector, token: InjectionToken, options?: ResolveChainNodeOptions): ResolveChain;
+    addInject(injector: Injector, token: InjectionToken, index: number, options?: ResolveChainNodeOptions): ResolveChain;
+    addParameter(injector: Injector, constructor: AbstractConstructor, index: number, token: InjectionToken, options?: ResolveChainNodeOptions): ResolveChain;
+    addProperty(injector: Injector, constructor: AbstractConstructor, property: PropertyKey, token: InjectionToken, options?: ResolveChainNodeOptions): ResolveChain;
     markAsForwardRef(forwardToken: InjectionToken): ResolveChain;
+    withArgument(argument: any): ResolveChain;
+    withResolvedBy(resolvedBy: Injector): ResolveChain;
+    withMetadata(metadata: Pick<ResolveChainNodeBase<any>, 'registration' | 'isCached'>): 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(injector, token) {
+    static startWith(injector, token, options) {
         const chain = new ResolveChain([]);
-        return chain.addToken(injector, token);
+        return chain.addToken(injector, token, options);
     }
-    addToken(injector, token) {
-        const node = { injector, type: 'token', token };
+    addToken(injector, token, options) {
+        const node = { injector, type: 'token', token, ...options };
         return new ResolveChain([...this.nodes, node]);
     }
-    addInject(injector, token, index) {
-        const node = { injector, type: 'inject', token, index };
+    addInject(injector, token, index, options) {
+        const node = { injector, type: 'inject', token, index, ...options };
         return new ResolveChain([...this.nodes, node]);
     }
-    addParameter(injector, constructor, index, token) {
-        const node = { injector, type: 'parameter', constructor, index, token };
+    addParameter(injector, constructor, index, token, options) {
+        const node = { injector, type: 'parameter', constructor, index, token, ...options };
         return new ResolveChain([...this.nodes, node]);
     }
-    addProperty(injector, constructor, property, token) {
-        const node = { injector, type: 'property', constructor, property, token };
+    addProperty(injector, constructor, property, token, options) {
+        const node = { injector, type: 'property', constructor, property, token, ...options };
         return new ResolveChain([...this.nodes, node]);
     }
     markAsForwardRef(forwardToken) {
@@ -35,6 +35,30 @@ export class ResolveChain {
         nodes.push({ ...nodes.pop(), token: forwardToken, forwardRef: true });
         return new ResolveChain(nodes);
     }
+    withArgument(argument) {
+        const nodes = [...this.nodes];
+        const lastNode = nodes.pop();
+        if (isDefined(lastNode) && (lastNode.type !== 'ellipsis')) {
+            nodes.push({ ...lastNode, argument });
+        }
+        return new ResolveChain(nodes);
+    }
+    withResolvedBy(resolvedBy) {
+        const nodes = [...this.nodes];
+        const lastNode = nodes.pop();
+        if (isDefined(lastNode) && (lastNode.type !== 'ellipsis')) {
+            nodes.push({ ...lastNode, resolvedBy });
+        }
+        return new ResolveChain(nodes);
+    }
+    withMetadata(metadata) {
+        const nodes = [...this.nodes];
+        const lastNode = nodes.pop();
+        if (isDefined(lastNode) && (lastNode.type !== 'ellipsis')) {
+            nodes.push({ ...lastNode, ...metadata });
+        }
+        return new ResolveChain(nodes);
+    }
     format(truncate) {
         let chainString = '';
         const chain = isDefined(truncate) ? this.truncate(truncate) : this;
@@ -50,26 +74,27 @@ export class ResolveChain {
             const paddedInjectorName = `${node.injector.name}#${node.injector.id}`.padStart(longestInjectorName);
             const tokenName = getTokenName(node.token);
             const forwardRefPrefix = node.forwardRef ? 'ForwardRef::' : '';
+            const resolvedBySuffix = isDefined(node.resolvedBy) && (node.resolvedBy.id != node.injector.id) ? ` (via ${node.resolvedBy.name}#${node.resolvedBy.id})` : '';
             switch (node.type) {
                 case 'token':
-                    chainString += `\n    ${paddedInjectorName} -> ${forwardRefPrefix}${tokenName}`;
+                    chainString += `\n    ${paddedInjectorName} -> ${forwardRefPrefix}${tokenName}${resolvedBySuffix}`;
                     break;
                 case 'inject':
-                    chainString += ` => inject(${forwardRefPrefix}${tokenName}) [${node.index + 1}]`;
+                    chainString += ` => inject(${forwardRefPrefix}${tokenName}) [${node.index + 1}]${resolvedBySuffix}`;
                     chainString += `\n    ${paddedInjectorName} -> ${tokenName}`;
                     break;
                 case 'parameter':
                     const metadata = reflectionRegistry.getMetadata(node.constructor);
                     const prefix = '_, '.repeat(node.index);
                     const suffix = ', _'.repeat(assertDefinedPass(metadata?.parameters, `missing parameters metadata for ${node.constructor.name}`).length - node.index - 1);
-                    chainString += `(${prefix}${forwardRefPrefix}${tokenName}${suffix})`;
+                    chainString += `(${prefix}${forwardRefPrefix}${tokenName}${suffix})${resolvedBySuffix}`;
                     // chainString += `\n       ${' '.repeat(1 + node.constructor.name.length + forwardRefPrefix.length + prefix.length + (tokenName.length / 2))}↓`;
                     chainString += `\n    ${paddedInjectorName} -> ${tokenName}`;
                     break;
                 case 'property':
                     const constructorName = getTokenName(node.constructor);
                     const key = getPropertyKeyString(node.property);
-                    chainString += `\n    ${paddedInjectorName} -> ${constructorName}[${key}]: ${forwardRefPrefix}${tokenName}`;
+                    chainString += `\n    ${paddedInjectorName} -> ${constructorName}[${key}]: ${forwardRefPrefix}${tokenName}${resolvedBySuffix}`;
                     break;
                 default:
                     throw new Error(`unknown chain node type ${node.type}`);

package/injector/tests/advanced.test.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/injector/tests/advanced.test.js

@@ -0,0 +1,116 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { describe, expect, test } from 'vitest';
+import '../../polyfills.js';
+import { afterResolve, forwardRef, inject, injectAll, injectArgument, Injectable, injectionToken, Injector, Singleton } from '../index.js';
+describe('Injector Advanced', () => {
+    test('forwardRef for circular dependencies', () => {
+        let ServiceB = class ServiceB {
+            a = inject(forwardRef(() => ServiceA));
+        };
+        ServiceB = __decorate([
+            Singleton()
+        ], ServiceB);
+        let ServiceA = class ServiceA {
+            b = inject(ServiceB);
+        };
+        ServiceA = __decorate([
+            Singleton()
+        ], ServiceA);
+        const injector = new Injector('test');
+        const a = injector.resolve(ServiceA);
+        const b = injector.resolve(ServiceB);
+        expect(a.b).toBe(b);
+        expect(b.a).toBe(a);
+    });
+    test('multi-providers and injectAll', () => {
+        const PLUGIN = injectionToken('PLUGIN');
+        const injector = new Injector('test');
+        injector.register(PLUGIN, { useValue: 'plugin1' }, { multi: true });
+        injector.register(PLUGIN, { useValue: 'plugin2' }, { multi: true });
+        let Consumer = class Consumer {
+            plugins = injectAll(PLUGIN);
+        };
+        Consumer = __decorate([
+            Injectable()
+        ], Consumer);
+        const consumer = injector.resolve(Consumer);
+        expect(consumer.plugins).toEqual(['plugin1', 'plugin2']);
+    });
+    test('resolution arguments and injectArgument', () => {
+        let Target = class Target {
+            arg = injectArgument();
+        };
+        Target = __decorate([
+            Injectable()
+        ], Target);
+        const injector = new Injector('test');
+        const instance = injector.resolve(Target, { value: 'test-arg' });
+        expect(instance.arg.value).toBe('test-arg');
+    });
+    test('optional dependencies', () => {
+        const MISSING = injectionToken('MISSING');
+        let Consumer = class Consumer {
+            missing = inject(MISSING, undefined, { optional: true });
+        };
+        Consumer = __decorate([
+            Injectable()
+        ], Consumer);
+        const injector = new Injector('test');
+        const consumer = injector.resolve(Consumer);
+        expect(consumer.missing).toBeUndefined();
+    });
+    test('automatic cleanup on injector disposal', async () => {
+        let disposed = false;
+        let DisposableService = class DisposableService {
+            async [Symbol.asyncDispose]() {
+                disposed = true;
+            }
+        };
+        DisposableService = __decorate([
+            Singleton()
+        ], DisposableService);
+        const injector = new Injector('test');
+        injector.resolve(DisposableService);
+        expect(disposed).toBe(false);
+        await injector.dispose();
+        expect(disposed).toBe(true);
+    });
+    test('addDisposeHandler in afterResolve', async () => {
+        let disposed = false;
+        let ManualService = class ManualService {
+            async [afterResolve](_arg, { addDisposeHandler }) {
+                addDisposeHandler(() => { disposed = true; });
+            }
+        };
+        ManualService = __decorate([
+            Singleton()
+        ], ManualService);
+        const injector = new Injector('test');
+        await injector.resolveAsync(ManualService);
+        expect(disposed).toBe(false);
+        await injector.dispose();
+        expect(disposed).toBe(true);
+    });
+    test('factory using inject', () => {
+        const VAL = injectionToken('VAL');
+        let Dep = class Dep {
+            value = 42;
+        };
+        Dep = __decorate([
+            Singleton()
+        ], Dep);
+        const injector = new Injector('test');
+        injector.register(VAL, {
+            useFactory: () => {
+                const dep = inject(Dep);
+                return dep.value * 2;
+            }
+        });
+        expect(injector.resolve(VAL)).toBe(84);
+    });
+});

package/injector/tests/async-init.test.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/injector/tests/async-init.test.js

@@ -0,0 +1,77 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { describe, expect, test } from 'vitest';
+import '../../polyfills.js';
+import { afterResolve, inject, Injector, runInInjectionContext, Singleton, injectAsync } from '../index.js';
+describe('Injector Async Initialization', () => {
+    test('should call [afterResolve] and wait for it with resolveAsync', async () => {
+        let AsyncService = class AsyncService {
+            initialized = false;
+            async [afterResolve]() {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                this.initialized = true;
+            }
+        };
+        AsyncService = __decorate([
+            Singleton()
+        ], AsyncService);
+        const injector = new Injector('test');
+        const instance = await injector.resolveAsync(AsyncService);
+        expect(instance.initialized).toBe(true);
+    });
+    test('should use injectAsync in [afterResolve] to await dependency', async () => {
+        let Dependency = class Dependency {
+            initialized = false;
+            async [afterResolve]() {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                this.initialized = true;
+            }
+        };
+        Dependency = __decorate([
+            Singleton()
+        ], Dependency);
+        let Consumer = class Consumer {
+            dependency;
+            async [afterResolve]() {
+                this.dependency = await injectAsync(Dependency);
+            }
+        };
+        Consumer = __decorate([
+            Singleton()
+        ], Consumer);
+        const injector = new Injector('test');
+        const consumer = await runInInjectionContext(injector, () => injector.resolveAsync(Consumer));
+        expect(consumer.dependency?.initialized).toBe(true);
+    });
+    test('should support multiple async dependencies', async () => {
+        let Dep1 = class Dep1 {
+            done = false;
+            async [afterResolve]() { this.done = true; }
+        };
+        Dep1 = __decorate([
+            Singleton()
+        ], Dep1);
+        let Dep2 = class Dep2 {
+            done = false;
+            async [afterResolve]() { this.done = true; }
+        };
+        Dep2 = __decorate([
+            Singleton()
+        ], Dep2);
+        let Consumer = class Consumer {
+            d1 = inject(Dep1);
+            d2 = inject(Dep2);
+        };
+        Consumer = __decorate([
+            Singleton()
+        ], Consumer);
+        const injector = new Injector('test');
+        const consumer = await injector.resolveAsync(Consumer);
+        expect(consumer.d1.done).toBe(true);
+        expect(consumer.d2.done).toBe(true);
+    });
+});

package/injector/tests/basic.test.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/injector/tests/basic.test.js

@@ -0,0 +1,114 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { describe, expect, test } from 'vitest';
+import '../../polyfills.js';
+import { inject, Inject, Injectable, injectionToken, Injector, Singleton } from '../index.js';
+describe('Injector Basic', () => {
+    test('should resolve a singleton class', () => {
+        let TestService = class TestService {
+            id = Math.random();
+        };
+        TestService = __decorate([
+            Singleton()
+        ], TestService);
+        const injector = new Injector('test');
+        const instance1 = injector.resolve(TestService);
+        const instance2 = injector.resolve(TestService);
+        expect(instance1).toBeInstanceOf(TestService);
+        expect(instance1.id).toBe(instance2.id);
+    });
+    test('should resolve a transient class', () => {
+        let TestService = class TestService {
+            id = Math.random();
+        };
+        TestService = __decorate([
+            Injectable()
+        ], TestService);
+        const injector = new Injector('test');
+        const instance1 = injector.resolve(TestService);
+        const instance2 = injector.resolve(TestService);
+        expect(instance1).toBeInstanceOf(TestService);
+        expect(instance1.id).not.toBe(instance2.id);
+    });
+    test('should use property injection with inject()', () => {
+        let Dependency = class Dependency {
+            value = 'dependency';
+        };
+        Dependency = __decorate([
+            Singleton()
+        ], Dependency);
+        let Consumer = class Consumer {
+            dependency = inject(Dependency);
+        };
+        Consumer = __decorate([
+            Singleton()
+        ], Consumer);
+        const injector = new Injector('test');
+        const consumer = injector.resolve(Consumer);
+        expect(consumer.dependency).toBeInstanceOf(Dependency);
+        expect(consumer.dependency.value).toBe('dependency');
+    });
+    test('should support manual registration with useValue', () => {
+        const TOKEN = injectionToken('TOKEN');
+        const injector = new Injector('test');
+        injector.register(TOKEN, { useValue: 'manual-value' });
+        const value = injector.resolve(TOKEN);
+        expect(value).toBe('manual-value');
+    });
+    test('should support manual registration with useClass', () => {
+        class AbstractService {
+        }
+        let Implementation = class Implementation extends AbstractService {
+            getValue() { return 'impl'; }
+        };
+        Implementation = __decorate([
+            Injectable()
+        ], Implementation);
+        const injector = new Injector('test');
+        injector.register(AbstractService, { useClass: Implementation });
+        const instance = injector.resolve(AbstractService);
+        expect(instance).toBeInstanceOf(Implementation);
+        expect(instance.getValue()).toBe('impl');
+    });
+    test('should support manual registration with useFactory', () => {
+        const TOKEN = injectionToken('TOKEN');
+        const injector = new Injector('test');
+        let counter = 0;
+        injector.register(TOKEN, { useFactory: () => ++counter });
+        expect(injector.resolve(TOKEN)).toBe(1);
+        expect(injector.resolve(TOKEN)).toBe(2);
+    });
+    test('should support global registration', () => {
+        const GLOBAL_TOKEN = injectionToken('GLOBAL_TOKEN');
+        Injector.register(GLOBAL_TOKEN, { useValue: 'global' });
+        const injector = new Injector('test');
+        expect(injector.resolve(GLOBAL_TOKEN)).toBe('global');
+    });
+    test('should support nested dependency injection', () => {
+        let Level3 = class Level3 {
+            value = 'l3';
+        };
+        Level3 = __decorate([
+            Singleton()
+        ], Level3);
+        let Level2 = class Level2 {
+            l3 = inject(Level3);
+        };
+        Level2 = __decorate([
+            Singleton()
+        ], Level2);
+        let Level1 = class Level1 {
+            l2 = inject(Level2);
+        };
+        Level1 = __decorate([
+            Singleton()
+        ], Level1);
+        const injector = new Injector('test');
+        const l1 = injector.resolve(Level1);
+        expect(l1.l2.l3.value).toBe('l3');
+    });
+});

package/injector/tests/hierarchical.test.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/injector/tests/hierarchical.test.js

@@ -0,0 +1,59 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { describe, expect, test } from 'vitest';
+import '../../polyfills.js';
+import { Injectable, injectionToken, Injector, Singleton } from '../index.js';
+describe('Injector Hierarchical', () => {
+    test('child should resolve from parent', () => {
+        const TOKEN = injectionToken('TOKEN');
+        const parent = new Injector('parent');
+        parent.register(TOKEN, { useValue: 'parent-value' });
+        const child = parent.fork('child');
+        expect(child.resolve(TOKEN)).toBe('parent-value');
+    });
+    test('child should override parent provider', () => {
+        const TOKEN = injectionToken('TOKEN');
+        const parent = new Injector('parent');
+        parent.register(TOKEN, { useValue: 'parent-value' });
+        const child = parent.fork('child');
+        child.register(TOKEN, { useValue: 'child-value' });
+        expect(child.resolve(TOKEN)).toBe('child-value');
+        expect(parent.resolve(TOKEN)).toBe('parent-value');
+    });
+    test('onlySelf should not resolve from parent', () => {
+        const TOKEN = injectionToken('TOKEN');
+        const parent = new Injector('parent');
+        parent.register(TOKEN, { useValue: 'parent-value' });
+        const child = parent.fork('child');
+        expect(() => child.resolve(TOKEN, undefined, { onlySelf: true })).toThrow(/No provider for .*TOKEN.* registered\./);
+    });
+    test('skipSelf should skip child and resolve from parent', () => {
+        const TOKEN = injectionToken('TOKEN');
+        const parent = new Injector('parent');
+        parent.register(TOKEN, { useValue: 'parent-value' });
+        const child = parent.fork('child');
+        child.register(TOKEN, { useValue: 'child-value' });
+        expect(child.resolve(TOKEN, undefined, { skipSelf: true })).toBe('parent-value');
+    });
+    test('injector scoped service should be unique per child', () => {
+        let ScopedService = class ScopedService {
+            id = Math.random();
+        };
+        ScopedService = __decorate([
+            Injectable()
+        ], ScopedService);
+        const parent = new Injector('parent');
+        parent.register(ScopedService, { useClass: ScopedService }, { lifecycle: 'injector' });
+        const child1 = parent.fork('child1');
+        const child2 = parent.fork('child2');
+        const s1 = child1.resolve(ScopedService);
+        const s2 = child1.resolve(ScopedService);
+        const s3 = child2.resolve(ScopedService);
+        expect(s1.id).toBe(s2.id);
+        expect(s1.id).not.toBe(s3.id);
+    });
+});

package/injector/tests/lifecycles.test.d.ts

@@ -0,0 +1 @@
+import '../../polyfills.js';

package/injector/tests/lifecycles.test.js

@@ -0,0 +1,109 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import '../../polyfills.js';
+import { describe, expect, test } from 'vitest';
+import { inject, Injectable, Injector, Scoped, Singleton } from '../index.js';
+describe('Injector Lifecycles', () => {
+    test('transient lifecycle', () => {
+        let TransientService = class TransientService {
+            id = Math.random();
+        };
+        TransientService = __decorate([
+            Injectable()
+        ], TransientService);
+        const injector = new Injector('test');
+        const instance1 = injector.resolve(TransientService);
+        const instance2 = injector.resolve(TransientService);
+        expect(instance1.id).not.toBe(instance2.id);
+    });
+    test('singleton lifecycle', () => {
+        let SingletonService = class SingletonService {
+            id = Math.random();
+        };
+        SingletonService = __decorate([
+            Singleton()
+        ], SingletonService);
+        const injector = new Injector('test');
+        const instance1 = injector.resolve(SingletonService);
+        const instance2 = injector.resolve(SingletonService);
+        expect(instance1.id).toBe(instance2.id);
+        const child = injector.fork('child');
+        const instance3 = child.resolve(SingletonService);
+        expect(instance3.id).toBe(instance1.id);
+    });
+    test('injector lifecycle', () => {
+        let InjectorScopedService = class InjectorScopedService {
+            id = Math.random();
+        };
+        InjectorScopedService = __decorate([
+            Scoped('injector')
+        ], InjectorScopedService);
+        const injector = new Injector('test');
+        const instance1 = injector.resolve(InjectorScopedService);
+        const instance2 = injector.resolve(InjectorScopedService);
+        expect(instance1.id).toBe(instance2.id);
+        const child = injector.fork('child');
+        const instance3 = child.resolve(InjectorScopedService);
+        expect(instance3.id).not.toBe(instance1.id);
+        const instance4 = child.resolve(InjectorScopedService);
+        expect(instance4.id).toBe(instance3.id);
+    });
+    test('resolution lifecycle', () => {
+        let ResolutionScopedService = class ResolutionScopedService {
+            id = Math.random();
+        };
+        ResolutionScopedService = __decorate([
+            Scoped('resolution')
+        ], ResolutionScopedService);
+        let Consumer = class Consumer {
+            service1 = inject(ResolutionScopedService);
+            service2 = inject(ResolutionScopedService);
+        };
+        Consumer = __decorate([
+            Injectable()
+        ], Consumer);
+        const injector = new Injector('test');
+        // Inside one .resolve() call, it should be the same instance
+        const consumer = injector.resolve(Consumer);
+        expect(consumer.service1.id).toBe(consumer.service2.id);
+        // Across different .resolve() calls, it should be different
+        const consumer2 = injector.resolve(Consumer);
+        expect(consumer2.service1.id).not.toBe(consumer.service1.id);
+    });
+    test('nested resolution lifecycle', () => {
+        let Shared = class Shared {
+            id = Math.random();
+        };
+        Shared = __decorate([
+            Scoped('resolution')
+        ], Shared);
+        let Dep1 = class Dep1 {
+            shared = inject(Shared);
+        };
+        Dep1 = __decorate([
+            Injectable()
+        ], Dep1);
+        let Dep2 = class Dep2 {
+            shared = inject(Shared);
+        };
+        Dep2 = __decorate([
+            Injectable()
+        ], Dep2);
+        let Root = class Root {
+            dep1 = inject(Dep1);
+            dep2 = inject(Dep2);
+            shared = inject(Shared);
+        };
+        Root = __decorate([
+            Injectable()
+        ], Root);
+        const injector = new Injector('test');
+        const root = injector.resolve(Root);
+        expect(root.shared.id).toBe(root.dep1.shared.id);
+        expect(root.shared.id).toBe(root.dep2.shared.id);
+    });
+});

package/injector/token.d.ts

@@ -1,11 +1,12 @@
 import type { AbstractConstructor } from '../types/index.js';
+import { ForwardRefToken } from './forward-ref.js';
 declare const type: unique symbol;
 declare const argument: unique symbol;
 export type SimpleInjectionToken<T> = AbstractConstructor<T>;
 export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
     [argument]: A;
 };
-export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
+export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A> | ForwardRefToken<T, A>;
 export type InjectionTokenArgument<T extends ArgumentedInjectionToken<any, any> | ReifyingInjectionToken> = T[typeof argument];
 export declare class ReifyingInjectionToken<T = any, A = any> {
     /**

package/injector/token.js

@@ -1,4 +1,5 @@
 import { isFunction } from '../utils/type-guards.js';
+import { ForwardRefToken } from './forward-ref.js';
 export class ReifyingInjectionToken {
     description;
     constructor(description) {
@@ -23,5 +24,7 @@ export function getTokenName(token) {
         ? token.name
         : token instanceof ReifyingInjectionToken
             ? token.toString()
-            : String(token);
+            : token instanceof ForwardRefToken
+                ? `ForwardRef[${getTokenName(token.tokenFactory())}]`
+                : String(token);
 }