@matter/general 0.16.0-alpha.0-20251004-92135c7df → 0.16.0-alpha.0-20251011-d8942d7d5

package/src/util/Abort.ts

@@ -4,6 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { TimeoutError } from "#MatterError.js";
+import { Duration } from "#time/Duration.js";
+import { Time, Timer } from "#time/Time.js";
+
 /**
  * Utilities for implementing abort logic.
  */
@@ -72,20 +76,40 @@ export namespace Abort {
      * aborts.
      *
      * Closing the returned controller unregisters with the input controller.  It does not perform an abort.
+     *
+     * {@link timeout} is a convenience for adding a timeout.
      */
-    export function subtask(signal: Signal | undefined): DisposableController {
+    export function subtask(signal: Signal | undefined, timeout?: Duration): DisposableController {
+        let timer: Timer | undefined;
+
         if (signal && "signal" in signal) {
             signal = signal.signal;
         }
 
         const controller = new AbortController() as DisposableController;
 
+        if (timeout) {
+            timer = Time.getPeriodicTimer("subtask timeout", timeout, () => {
+                if (controller.signal.aborted) {
+                    return;
+                }
+
+                controller.abort(new TimeoutError());
+            });
+            timer.start();
+        }
+
         if (signal) {
-            const outerHandler = () => controller.abort();
+            const outerHandler = () => controller.abort(signal.reason);
             signal.addEventListener("abort", outerHandler);
-            controller[Symbol.dispose] = () => signal.removeEventListener("abort", outerHandler);
+            controller[Symbol.dispose] = () => {
+                signal.removeEventListener("abort", outerHandler);
+                timer?.stop();
+            };
         } else {
-            controller[Symbol.dispose] = () => {};
+            controller[Symbol.dispose] = () => {
+                timer?.stop();
+            };
         }
 
         return controller;

package/src/util/Construction.ts

@@ -39,7 +39,7 @@ export async function asyncNew<const A extends any[], const C extends new (...ar
  * Construction happens in the initializer parameter of {@link Construction} or via {@link Construction.construct} on
  * the subject.  You invoke in your constructor and place in a property called "construction".
  *
- * Destruciton is optional and happens in the destructor parameter of {@link Construction#close} or via
+ * Destruction is optional and happens in the destructor parameter of {@link Construction#close} or via
  * {@link Construction.destruct} on the subject.  Typically you invoke in a "close" method of the subject.
  *
  * If construction or destruction is not asynchronous (does not return a Promise) then they complete synchronously,
@@ -430,7 +430,7 @@ export function Construction<const T extends Constructable>(
                   }
                 : invokeDestruct;
 
-            // Destruction phase 1 - move to destroyed state
+            // Destruction phase 1 - move to destroying state
             function beginDestruction() {
                 if (status === Lifecycle.Status.Destroying || status === Lifecycle.Status.Destroyed) {
                     return self.closed;

package/src/util/Multiplex.ts

@@ -43,7 +43,7 @@ export class BasicMultiplex implements PromiseLike<void> {
                     if (description) {
                         message = `${message} in ${description}`;
                     }
-                    logger.error(message, e);
+                    logger.error(`${message}:`, e);
                 })
                 .finally(() => this.#workers.delete(entry)),
             description,

package/src/util/String.ts

@@ -104,7 +104,7 @@ export function decamelize(name: string, separator = "-") {
 /**
  * Like JSON.stringify but targets well-formed JS and is slightly more readable.
  */
-export function serialize(value: any) {
+export function serialize(value: unknown) {
     const visited = new Set();
 
     function asValidKey(key: string) {
@@ -114,15 +114,15 @@ export function serialize(value: any) {
         return JSON.stringify(key);
     }
 
-    function serializeOne(value: any): string | undefined {
+    function serializeOne(value: unknown): string | undefined {
         if (value === undefined) {
             return;
         }
         if (value === null) {
             return "null";
         }
-        if (value[serialize.SERIALIZE]) {
-            return value[serialize.SERIALIZE]();
+        if ((value as { [serialize.SERIALIZE](): string })[serialize.SERIALIZE]) {
+            return (value as { [serialize.SERIALIZE](): string })[serialize.SERIALIZE]();
         }
         if (typeof value === "function") {
             return;
@@ -147,7 +147,7 @@ export function serialize(value: any) {
         if (visited.has(value)) {
             return;
         }
-        if (value.toJSON) {
+        if ((value as { toJSON(): string }).toJSON) {
             value = JSON.parse(JSON.stringify(value));
         }
 
@@ -161,7 +161,7 @@ export function serialize(value: any) {
                 return "[]";
             }
 
-            const entries = Object.entries(value)
+            const entries = Object.entries(value as {})
                 .map(([k, v]) => [k, serializeOne(v)])
                 .filter(([_k, v]) => v !== undefined)
                 .map(([k, v]) => `${asValidKey(k ?? "")}: ${v}`);
@@ -179,6 +179,25 @@ export function serialize(value: any) {
     return serializeOne(value);
 }
 
+/**
+ * Like {@link JSON.stringify} but with support for additional standard objects.
+ */
+export function asJson(value: unknown, space?: number) {
+    return JSON.stringify(
+        value,
+        (_key, value) => {
+            if (typeof value === "bigint") {
+                return value.toString();
+            }
+            if (Bytes.isBytes(value)) {
+                return Bytes.toHex(value);
+            }
+            return value;
+        },
+        space,
+    );
+}
+
 export namespace serialize {
     /**
      * Custom serialization function key.