@matter/general 0.16.7 → 0.16.8-alpha.0-20260123-dff2cae52

package/src/util/Abort.ts

@@ -23,13 +23,15 @@ import { SafePromise } from "./Promises.js";
  * Optionally will register for abort with an outer {@link AbortController} and/or add a timeout.  You must abort or
  * invoke {@link close} if you use either of these options.
  */
-export class Abort extends Callable<[reason?: Error]> implements AbortController, AbortSignal, PromiseLike<Error> {
+export class Abort
+    extends Callable<[reason?: string | Error]>
+    implements AbortController, AbortSignal, PromiseLike<Error>
+{
     // The native controller implementation
     #controller: AbortController;
 
     // Optional abort chaining
-    #dependents?: AbortSignal[];
-    #listener?: (reason: any) => void;
+    #unregisterDependencies?: () => void;
 
     // Optional PromiseLike behavior
     #aborted?: Promise<Error>;
@@ -38,49 +40,106 @@ export class Abort extends Callable<[reason?: Error]> implements AbortController
     // Optional timeout
     #timeout?: Timer;
 
-    constructor({ abort, timeout, handler }: Abort.Options = {}) {
-        super(() => this.abort());
+    constructor({ abort: aborts, timeout, handler, timeoutHandler }: Abort.Options = {}) {
+        const abort = (reason?: Error | string) => {
+            if (typeof reason === "string") {
+                reason = new AbortedError(reason);
+            }
+            this.abort(reason);
+        };
+
+        super(abort);
 
         this.#controller = new AbortController();
 
+        const throwIfAborted = this.#controller.signal.throwIfAborted.bind(this.#controller.signal);
+        this.#controller.signal.throwIfAborted = () => {
+            try {
+                throwIfAborted();
+            } catch (e) {
+                const error = new AbortedError();
+
+                // Remove stack lines for this abort logic
+                error.stack = error.stack
+                    ?.split("\n")
+                    .filter(line => !line.match(/\.throwIfAborted/))
+                    .join("\n");
+
+                error.cause = e;
+                throw error;
+            }
+        };
+
         const self = (reason?: any) => {
             this.abort(reason);
         };
         Object.setPrototypeOf(self, Object.getPrototypeOf(this));
 
-        if (abort && !Array.isArray(abort)) {
-            abort = [abort];
+        if (aborts && !Array.isArray(aborts)) {
+            aborts = [aborts];
         }
 
-        if (abort?.length) {
-            const dependents = abort.map(abort => ("signal" in abort ? abort.signal : abort));
-            this.#dependents = dependents;
+        if (aborts?.length) {
+            const dependencies = aborts.map(abort => abort && ("signal" in abort ? abort.signal : abort));
+
+            for (const dependency of dependencies) {
+                if (dependency === undefined) {
+                    continue;
+                }
 
-            this.#listener = (reason: any) => this.abort(reason);
-            for (const dependent of dependents) {
-                dependent.addEventListener("abort", this.#listener);
+                const listener = () => this.abort(asError(dependency.reason));
+                dependency.addEventListener("abort", listener);
+                const unregisterPrev = this.#unregisterDependencies;
+                this.#unregisterDependencies = () => {
+                    unregisterPrev?.();
+                    dependency.removeEventListener("abort", listener);
+                };
             }
         }
 
-        if (timeout) {
-            this.#timeout = Time.getPeriodicTimer("subtask timeout", timeout, () => {
-                if (this.aborted) {
-                    return;
-                }
+        if (timeout !== undefined) {
+            if (timeoutHandler) {
+                const original = timeoutHandler;
+                timeoutHandler = () => {
+                    try {
+                        original.call(this);
+                    } catch (e) {
+                        this.abort(asError(e));
+                    }
+                };
+            } else {
+                timeoutHandler = () => this.abort(new TimeoutError());
+            }
 
-                this.abort(new TimeoutError());
-            });
+            if (timeout <= 0) {
+                timeoutHandler.call(this);
+            } else {
+                this.#timeout = Time.getPeriodicTimer("subtask timeout", timeout, () => {
+                    if (this.aborted) {
+                        return;
+                    }
+
+                    timeoutHandler!.call(this);
+                });
 
-            this.#timeout.start();
+                this.#timeout.start();
+            }
         }
 
         if (handler) {
-            this.addEventListener("abort", () => handler(this.reason));
+            if (this.aborted) {
+                handler.call(this, this.reason);
+            } else {
+                this.addEventListener("abort", () => handler.call(this, this.reason));
+            }
         }
     }
 
-    abort(reason?: any) {
-        this.#controller.abort(reason ?? new AbortedError());
+    abort(reason?: Error | string) {
+        if (typeof reason === "string") {
+            reason = new AbortedError(reason);
+        }
+        this.#controller.abort(reason ?? new AbortedError("Operation aborted with no reason given"));
     }
 
     get signal() {
@@ -100,7 +159,7 @@ export class Abort extends Callable<[reason?: Error]> implements AbortController
      * Race with throw on abort.
      */
     async attempt<T>(...promises: Array<T | PromiseLike<T>>) {
-        return Abort.attempt(this, ...promises);
+        return await Abort.attempt(this, ...promises);
     }
 
     /**
@@ -111,11 +170,7 @@ export class Abort extends Callable<[reason?: Error]> implements AbortController
      */
     close() {
         this.#timeout?.stop();
-        if (this.#listener && this.#dependents) {
-            for (const dependent of this.#dependents) {
-                dependent.removeEventListener("abort", this.#listener);
-            }
-        }
+        this.#unregisterDependencies?.();
     }
 
     [Symbol.dispose]() {
@@ -208,7 +263,7 @@ export namespace Abort {
          *
          * This functions similarly to {@link AbortSignal.any} but has additional protection against memory leaks.
          */
-        abort?: Signal | Signal[];
+        abort?: Signal | (Signal | undefined)[];
 
         /**
          * An abort timeout.
@@ -220,7 +275,14 @@ export namespace Abort {
         /**
          * Adds a default abort handler.
          */
-        handler?: (reason?: Error) => void;
+        handler?: (this: Abort, reason?: Error) => void;
+
+        /**
+         * Replaces the default timeout handler.
+         *
+         * The default implementation aborts with {@link TimeoutError}.
+         */
+        timeoutHandler?: (this: Abort) => void;
     }
 
     /**

package/src/util/DataReadQueue.ts

@@ -8,8 +8,9 @@
 
 import { Duration } from "#time/Duration.js";
 import { Minutes } from "#time/TimeUnit.js";
-import { MatterFlowError } from "../MatterError.js";
+import { AbortedError, MatterFlowError } from "../MatterError.js";
 import { Time, Timer } from "../time/Time.js";
+import { Abort } from "./Abort.js";
 import { asError } from "./Error.js";
 import { createPromise } from "./Promises.js";
 import { EndOfStreamError, NoResponseTimeoutError } from "./Streams.js";
@@ -19,7 +20,7 @@ export class DataReadQueue<T> {
     #pendingRead?: { resolver: (data: T) => void; rejecter: (reason: any) => void; timeoutTimer?: Timer };
     #closed = false;
 
-    async read(timeout = Minutes.one): Promise<T> {
+    async read({ timeout = Minutes.one, abort }: { timeout?: Duration; abort?: AbortSignal } = {}): Promise<T> {
         const { promise, resolver, rejecter } = createPromise<T>();
         if (this.#closed) throw new EndOfStreamError();
         const data = this.#queue.shift();
@@ -39,22 +40,39 @@ export class DataReadQueue<T> {
             ).start(),
         };
 
+        let localAbort: Abort | undefined;
         try {
+            if (abort) {
+                localAbort = new Abort({
+                    abort,
+
+                    handler: reason => {
+                        this.#clearPendingRead();
+                        rejecter(reason);
+                    },
+                });
+            }
+
             return await promise;
         } catch (e) {
+            if (e instanceof AbortedError) {
+                throw e;
+            }
+
             // The stack trace where we created the error is useless (either a timer or close()) so replace here
             const error = asError(e);
             error.stack = new Error().stack;
             throw error;
+        } finally {
+            localAbort?.close();
         }
     }
 
     write(data: T) {
         if (this.#closed) throw new EndOfStreamError();
-        if (this.#pendingRead !== undefined) {
-            this.#pendingRead.timeoutTimer?.stop();
-            const pendingRead = this.#pendingRead;
-            this.#pendingRead = undefined;
+        const pendingRead = this.#pendingRead;
+        this.#clearPendingRead();
+        if (pendingRead) {
             pendingRead.resolver(data);
             return;
         }
@@ -72,4 +90,13 @@ export class DataReadQueue<T> {
         this.#pendingRead.timeoutTimer?.stop();
         this.#pendingRead.rejecter(new EndOfStreamError());
     }
+
+    #clearPendingRead() {
+        if (this.#pendingRead === undefined) {
+            return;
+        }
+
+        this.#pendingRead.timeoutTimer?.stop();
+        this.#pendingRead = undefined;
+    }
 }

package/src/util/Semaphore.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { AbortedError } from "#MatterError.js";
+import { AbortedError, ClosedError } from "#MatterError.js";
 import { Duration } from "#time/Duration.js";
 import { Time, Timer } from "#time/Time.js";
 import { Instant } from "#time/TimeUnit.js";
@@ -64,7 +64,7 @@ export class Semaphore {
     async obtainSlot(abort?: Abort.Signal): Promise<WorkSlot> {
         // Check if closed or already aborted before proceeding
         if (this.#closed) {
-            throw new AbortedError("Queue is closed");
+            throw new ClosedError("Queue is closed");
         }
         if (abort) {
             const signal = "signal" in abort ? abort.signal : abort;
@@ -110,9 +110,10 @@ export class Semaphore {
                     this.#queue.length,
                 );
             }
-            // Throw AbortedError (use reason if it's already an AbortedError)
-            const reason = combinedAbort.reason;
-            throw reason instanceof AbortedError ? reason : new AbortedError();
+            combinedAbort.throwIfAborted();
+
+            // Should not get here
+            throw new AbortedError("Aborted without reason");
         }
 
         return result;
@@ -201,7 +202,7 @@ export class Semaphore {
     clear(): void {
         if (this.#queue.length > 0) {
             // Abort current waiters and create fresh abort for future requests
-            this.#abort.abort(new AbortedError("Queue cleared"));
+            this.#abort.abort(new ClosedError("Queue cleared"));
             this.#abort = new Abort();
         }
         this.#queue.length = 0;
@@ -226,7 +227,7 @@ export class Semaphore {
      */
     close(): void {
         this.#closed = true;
-        this.#abort.abort(new AbortedError("Queue is closed"));
+        this.#abort.abort(new ClosedError("Queue is closed"));
         this.clear();
         this.#delayTimer.stop();
     }