@tstdl/base 0.93.138 → 0.93.139

package/cancellation/tests/leak.test.d.ts

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

package/cancellation/tests/leak.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { CancellationToken } from '../token.js';
+describe('CancellationToken Memory Leak', () => {
+    it('should not leak subscriptions in connect', () => {
+        const parent = new CancellationToken();
+        // @ts-ignore
+        const initialParentSubscribers = parent._stateSubject.observers.length;
+        for (let i = 0; i < 1000; i++) {
+            const child = new CancellationToken();
+            parent.connect(child, { once: true });
+            child.set();
+        }
+        // @ts-ignore
+        expect(parent._stateSubject.observers.length).toBeLessThan(initialParentSubscribers + 10);
+    });
+    it('should not leak when child is completed', () => {
+        const parent = new CancellationToken();
+        const child = new CancellationToken();
+        parent.connect(child);
+        // @ts-ignore
+        expect(parent._stateSubject.observers.length).toBe(1);
+        child.complete();
+        // @ts-ignore
+        expect(parent._stateSubject.observers.length).toBe(0);
+    });
+    it('should not leak when parent is completed', () => {
+        const parent = new CancellationToken();
+        const child = new CancellationToken();
+        parent.connect(child);
+        // @ts-ignore
+        expect(parent._stateSubject.observers.length).toBeGreaterThan(0);
+        // @ts-ignore
+        expect(child._stateSubject.observers.length).toBeGreaterThan(0);
+        parent.complete();
+        // @ts-ignore
+        expect(parent._stateSubject.observers.length).toBe(0);
+        // @ts-ignore
+        expect(child._stateSubject.observers.length).toBe(0);
+    });
+});

package/cancellation/token.js

@@ -188,16 +188,23 @@ export class CancellationToken extends CancellationSignal {
         if (once) {
             stateObservable = stateObservable.pipe(take(1));
         }
+        const targetRef = new WeakRef(target);
         const subscription = stateObservable.subscribe({
-            next: (state) => target.setState(state),
-            error: error ? (errorValue) => target.error(errorValue) : noop,
-            complete: complete ? () => target.complete() : noop,
+            next: (state) => targetRef.deref()?.setState(state),
+            error: error ? (errorValue) => targetRef.deref()?.error(errorValue) : noop,
+            complete: complete ? () => targetRef.deref()?.complete() : noop,
         });
-        // Ensure the connection is torn down if the target is completed or errors.
-        target._stateSubject.subscribe({
+        const targetSubscription = target._stateSubject.subscribe({
+            next: (state) => {
+                if (state && once) {
+                    subscription.unsubscribe();
+                }
+            },
             error: () => subscription.unsubscribe(),
             complete: () => subscription.unsubscribe(),
         });
+        subscription.add(targetSubscription);
+        registerFinalization(target, (sub) => sub.unsubscribe(), subscription);
     }
     /**
      * Makes this token a child of a parent token.

package/injector/injector.d.ts

@@ -80,6 +80,7 @@ export declare class Injector implements AsyncDisposable {
     readonly name: string;
     readonly ownerToken?: InjectionToken;
     get parent(): Injector | null;
+    get children(): readonly Injector[];
     get accesses(): {
         chain: ResolveChain;
     }[];

package/injector/injector.js

@@ -38,6 +38,9 @@ export class Injector {
     get parent() {
         return this.#parent;
     }
+    get children() {
+        return this.#children;
+    }
     get accesses() {
         return this.#accesses;
     }
@@ -50,9 +53,12 @@ export class Injector {
         this.ownerToken = ownerToken;
         this.register(Injector, { useValue: this });
         this.register(CancellationSignal, { useValue: this.#disposeToken.signal });
-        this.#disposableStack.defer(() => this.#registrations.clear());
-        this.#disposableStack.defer(() => this.#injectorScopedResolutions.clear());
-        this.#disposableStack.defer(() => this.#disposableStackRegistrations.clear());
+        this.#disposableStack.defer(() => {
+            this.#registrations.clear();
+            this.#injectorScopedResolutions.clear();
+            this.#disposableStackRegistrations.clear();
+            this.#accesses.length = 0;
+        });
     }
     /**
      * Add a dispose handler to this injector. The handler can be a disposable, async disposable, or a simple function. If the handler is a disposable or async disposable, it will be disposed when the injector is disposed.
@@ -120,6 +126,12 @@ export class Injector {
         const child = new Injector(name, this, ownerToken);
         this.#children.push(child);
         this.#disposableStack.use(child);
+        child.addDisposeHandler(() => {
+            const index = this.#children.indexOf(child);
+            if (index != -1) {
+                this.#children.splice(index, 1);
+            }
+        });
         return child;
     }
     /**
@@ -395,8 +407,8 @@ export class Injector {
             context.recordAccess(chain.withMetadata({ isCached: true }));
             return registration.resolutions.get(argumentIdentity);
         }
-        // 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);
+        // A new scope is only needed if the registration explicitly defines scoped providers.
+        const needsNewScope = (providers.length > 0);
         const injector = needsNewScope ? this.fork(`${getTokenName(token)}Injector`, token) : this;
         for (const nestedProvider of providers) {
             injector.registerSingleton(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });

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

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

package/injector/tests/leak.test.js

@@ -0,0 +1,45 @@
+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/package.json

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

package/task-queue/task-queue.js

@@ -103,7 +103,7 @@ export class TaskQueue extends Transactional {
      */
     async processWorker(cancellationSignal, handler, options) {
         for await (const task of this.getConsumer(cancellationSignal, options)) {
-            const taskToken = cancellationSignal.createChild();
+            const taskToken = cancellationSignal.createChild({ once: true });
             const context = new TaskContext(this, task, taskToken, this.logger.with({ type: task.type }));
             let isTaskActive = true;
             context.logger.verbose(`Processing task`);
@@ -156,6 +156,7 @@ export class TaskQueue extends Transactional {
             }
             finally {
                 taskToken.set();
+                taskToken.complete();
             }
         }
     }