@tstdl/base 0.93.182 → 0.93.184

package/injector/tests/advanced.test.js

@@ -1,116 +0,0 @@
-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

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

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

@@ -1,77 +0,0 @@
-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

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

package/injector/tests/basic.test.js

@@ -1,114 +0,0 @@
-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

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

package/injector/tests/hierarchical.test.js

@@ -1,59 +0,0 @@
-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/leak.test.d.ts

@@ -1 +0,0 @@
-export {};

package/injector/tests/leak.test.js

@@ -1,45 +0,0 @@
-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, it } from 'vitest';
-import { Injectable } from '../decorators.js';
-import { Injector } from '../injector.js';
-import { injectionToken } from '../token.js';
-describe('Injector Memory Leak', () => {
-    it('should not leak memory in #children', async () => {
-        const injector = new Injector('TestInjector');
-        for (let i = 0; i < 100; i++) {
-            const child = injector.fork(`child-${i}`);
-            await child.dispose();
-        }
-        // Since #children is private, we can't easily check it without a getter.
-        // But we fixed the code, so let's add a temporary check if we had one.
-        // For now, let's just make sure the child.dispose() doesn't throw.
-    });
-    it('should clear #accesses and #children on dispose', async () => {
-        const injector = new Injector('TestInjector');
-        const token = injectionToken('test');
-        injector.register(token, { useValue: 'test' });
-        injector.resolve(token);
-        injector.fork('child');
-        expect(injector.accesses.length).toBeGreaterThan(0);
-        await injector.dispose();
-        expect(injector.accesses.length).toBe(0);
-        expect(injector.children.length).toBe(0);
-    });
-    it('should not leak child injectors for transient resolutions without providers', () => {
-        const injector = new Injector('TestInjector');
-        let TestClass = class TestClass {
-        };
-        TestClass = __decorate([
-            Injectable()
-        ], TestClass);
-        for (let i = 0; i < 100; i++) {
-            injector.resolve(TestClass);
-        }
-        expect(injector.children.length).toBe(0);
-    });
-});

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

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

package/injector/tests/lifecycles.test.js

@@ -1,109 +0,0 @@
-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/logger/tests/pretty-print.test.d.ts

@@ -1 +0,0 @@
-export {};

package/logger/tests/pretty-print.test.js

@@ -1,60 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-// Mock supports before importing PrettyPrintLogFormatter
-vi.mock('../../supports.js', () => ({
-    supportsColoredStdout: true,
-    supportsColoredStderr: true,
-}));
-import { PrettyPrintLogFormatter } from '../formatters/pretty-print.js';
-import { LogLevel } from '../level.js';
-describe('PrettyPrintLogFormatter', () => {
-    const formatter = new PrettyPrintLogFormatter();
-    it('should format a log entry with an error and no context', () => {
-        const error = new Error('test error');
-        const payload = {
-            timestamp: new Date('2026-01-22T13:00:00.000Z'),
-            level: LogLevel.Error,
-            module: ['Test'],
-            message: 'something failed',
-            interpolationKeys: [],
-            context: {},
-            error,
-        };
-        const formatted = formatter.format(payload);
-        expect(formatted).toContain('ERROR:');
-        expect(formatted).toContain('[Test]');
-        expect(formatted).toContain('something failed');
-        expect(formatted).toContain('Error: test error');
-        expect(formatted).toContain('at '); // Should include stack trace
-    });
-    it('should dim stack trace lines', () => {
-        const error = new Error('test error');
-        const payload = {
-            timestamp: new Date('2026-01-22T13:00:00.000Z'),
-            level: LogLevel.Error,
-            module: ['Test'],
-            message: 'something failed',
-            interpolationKeys: [],
-            context: {},
-            error,
-        };
-        const formatted = formatter.format(payload);
-        // Check for dim color escape code \x1b[2m before "at " (including indentation)
-        expect(formatted).toContain('\x1b[2m    at ');
-    });
-    it('should highlight "Caused by:" with level color', () => {
-        const cause = new Error('the cause');
-        const error = new Error('the error', { cause });
-        const payload = {
-            timestamp: new Date('2026-01-22T13:00:00.000Z'),
-            level: LogLevel.Error,
-            module: ['Test'],
-            message: 'failed',
-            interpolationKeys: [],
-            context: {},
-            error,
-        };
-        const formatted = formatter.format(payload);
-        // LogLevel.Error color is \x1b[31m
-        expect(formatted).toContain('\x1b[31mCaused by:');
-    });
-});

package/notification/tests/notification-api.test.d.ts

@@ -1 +0,0 @@
-export {};