@tstdl/base 0.93.139 → 0.93.140

package/utils/async-iterable-helpers/take-until.js

@@ -1,4 +1,4 @@
-import { firstValueFrom, map, race } from 'rxjs';
+import { firstValueFrom, from, map, race } from 'rxjs';
 import { isAsyncIterable } from './is-async-iterable.js';
 export function takeUntilAsync(iterable, cancellationSignal) {
     return isAsyncIterable(iterable)
@@ -20,7 +20,7 @@ async function* sync(iterable, cancellationSignal) {
 }
 async function* async(iterable, cancellationSignal) {
     const iterator = iterable[Symbol.asyncIterator]();
-    const cancel$ = cancellationSignal.set$.pipe(map(() => ({ done: true, value: undefined }))); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    const cancel$ = from(cancellationSignal).pipe(map(() => ({ done: true, value: undefined })));
     try {
         while (true) {
             const result = await firstValueFrom(race([iterator.next(), cancel$]));
@@ -31,10 +31,10 @@ async function* async(iterable, cancellationSignal) {
         }
     }
     catch (error) {
-        (iterator.throw ?? iterator.return)?.(error);
+        await (iterator.throw ?? iterator.return)?.(error);
     }
     finally {
-        iterator.return?.();
+        await iterator.return?.();
     }
     return undefined;
 }

package/utils/backoff.js

@@ -1,3 +1,55 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { CancellationToken } from '../cancellation/token.js';
 import { NEVER } from 'rxjs';
 import { randomFloat } from './math.js';
@@ -109,37 +161,44 @@ export async function autoBackoffLoop(loopFunction, options = {}) {
  * @param options Additional options for backoff configuration and cancellation.
  */
 export async function backoffLoop(loopFunction, options = {}) {
-    const { cancellationSignal, ...backoffOptions } = options;
-    const backoffHelper = new BackoffHelper(backoffOptions);
-    const loopToken = new CancellationToken();
-    let shouldBackoff = false;
-    let customBackoffDelay;
-    if (isDefined(cancellationSignal)) {
-        loopToken.inherit(cancellationSignal, { set: true, unset: false, complete: false, error: false });
-    }
-    const controller = {
-        backoff: (delay) => {
-            shouldBackoff = true;
-            customBackoffDelay = delay;
-        },
-        break: () => loopToken.set(),
-    };
-    while (loopToken.isUnset) {
-        await loopFunction(controller, loopToken.signal, backoffHelper.status);
-        // Exit immediately if the loop function requested a break.
-        if (loopToken.isSet) {
-            return;
-        }
-        if (shouldBackoff) {
-            shouldBackoff = false;
-            const delay = customBackoffDelay ?? backoffHelper.getNextDelay();
-            await cancelableTimeout(delay, loopToken.signal);
-        }
-        else {
-            // If an iteration completes successfully without a backoff request, reset the delay.
-            backoffHelper.reset();
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { cancellationSignal, ...backoffOptions } = options;
+        const backoffHelper = new BackoffHelper(backoffOptions);
+        const loopToken = __addDisposableResource(env_1, new CancellationToken(cancellationSignal), false);
+        let shouldBackoff = false;
+        let customBackoffDelay;
+        const controller = {
+            backoff: (delay) => {
+                shouldBackoff = true;
+                customBackoffDelay = delay;
+            },
+            break: () => loopToken.set(),
+        };
+        while (loopToken.isUnset) {
+            await loopFunction(controller, loopToken, backoffHelper.status);
+            // Exit immediately if the loop function requested a break.
+            if (loopToken.isSet) {
+                return;
+            }
+            if (shouldBackoff) {
+                shouldBackoff = false;
+                const delay = customBackoffDelay ?? backoffHelper.getNextDelay();
+                await cancelableTimeout(delay, loopToken);
+            }
+            else {
+                // If an iteration completes successfully without a backoff request, reset the delay.
+                backoffHelper.reset();
+            }
         }
     }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 }
 /**
  * Creates an async generator that yields a callback to trigger a backoff.
@@ -182,7 +241,7 @@ export async function* backoffGenerator(options = {}) {
             const continueToken = backoffOptions?.continueToken;
             if (isDefined(continueToken)) {
                 timeoutSignal = isDefined(cancellationSignal)
-                    ? cancellationSignal.createChild().inherit(continueToken)
+                    ? cancellationSignal.inherit(continueToken)
                     : continueToken;
             }
         };

package/utils/retry-with-backoff.js

@@ -15,7 +15,7 @@ export async function retryWithBackoff(func, options = {}) {
     await backoffLoop(async (controller, loopSignal, status) => {
         try {
             const attemptSignal = isDefined(signal)
-                ? signal.createChild().inherit(loopSignal)
+                ? signal.inherit(loopSignal)
                 : loopSignal;
             if (isDefined(timeout)) {
                 result = await withTimeout(timeout, async () => await func(attemptSignal));

package/utils/timer.d.ts

@@ -1,6 +1,6 @@
 export declare class Timer {
     private elapsedNanoseconds;
-    private begin?;
+    private begin;
     constructor(start?: boolean);
     static startNew(): Timer;
     static measure(func: () => any): number;

package/utils/timer.js

@@ -1,3 +1,4 @@
+import { isDefined, isUndefined } from './type-guards.js';
 const nsPerSec = 1e9;
 const nsPerMs = 1e6;
 const nsPerUs = 1e3;
@@ -41,12 +42,10 @@ export class Timer {
         return timer.milliseconds;
     }
     start() {
-        if (this.begin == undefined) {
-            this.begin = getBegin();
-        }
+        this.begin ??= getBegin();
     }
     stop() {
-        if (this.begin != undefined) {
+        if (isDefined(this.begin)) {
             const nanoseconds = this.read();
             this.elapsedNanoseconds += nanoseconds;
             this.begin = undefined;
@@ -61,8 +60,7 @@ export class Timer {
         this.elapsedNanoseconds = 0;
     }
     get nanoseconds() {
-        const result = this.elapsedNanoseconds + this.read();
-        return result;
+        return this.elapsedNanoseconds + this.read();
     }
     get microseconds() {
         return this.nanoseconds / nsPerUs;
@@ -74,7 +72,7 @@ export class Timer {
         return this.nanoseconds / nsPerSec;
     }
     read() {
-        if (this.begin == undefined) {
+        if (isUndefined(this.begin)) {
             return 0;
         }
         const result = getDuration(this.begin);

package/utils/timing.d.ts

@@ -1,5 +1,5 @@
 import { type Observable } from 'rxjs';
-import { CancellationSignal } from '../cancellation/token.js';
+import type { CancellationSignal } from '../cancellation/token.js';
 import { type ValueOrProvider } from './value-or-provider.js';
 /** Timeout for specified duration */
 export declare function timeout(milliseconds?: number, options?: {

package/utils/timing.js

@@ -1,5 +1,4 @@
-import { firstValueFrom, map, race, timer } from 'rxjs';
-import { CancellationSignal } from '../cancellation/token.js';
+import { firstValueFrom, from, map, race, timer } from 'rxjs';
 import { TimeoutError } from '../errors/timeout.error.js';
 import { _throw } from './throw.js';
 import { resolveValueOrProvider } from './value-or-provider.js';
@@ -21,10 +20,9 @@ export async function timeoutUntil(timestamp) {
 }
 /** Timeout for specified duration */
 export async function cancelableTimeout(milliseconds, cancelSignal) {
-    const observable = (cancelSignal instanceof CancellationSignal) ? cancelSignal.set$ : cancelSignal;
     return await firstValueFrom(race([
         timer(milliseconds).pipe(map(() => 'timeout')),
-        observable.pipe(map(() => 'canceled')),
+        from(cancelSignal).pipe(map(() => 'canceled')),
     ]));
 }
 /** Timeout until specified time */

package/utils/z-base32.d.ts

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/suspicious/noBitwiseOperators: ok */
 import type { BinaryData } from '../types/index.js';
 export declare function zBase32Encode(buffer: BinaryData): string;
 export declare function zBase32Decode(input: string): Uint8Array<ArrayBuffer>;

package/utils/z-base32.js

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/suspicious/noBitwiseOperators: ok */
 import { Alphabet } from './alphabet.js';
 import { toUint8Array } from './binary.js';
 import { assertDefined } from './type-guards.js';