@filen/utils 0.0.5 → 0.0.7

package/dist/checklistParser.js

@@ -22,7 +22,7 @@ export class ChecklistParser {
             }
             return checklist;
         }
-        catch (_a) {
+        catch {
             return [];
         }
     }

package/dist/misc.js

@@ -57,48 +57,53 @@ export function chunkArray(array, chunkSize) {
     }
     return chunks;
 }
+const ZERO_WIDTH_AND_CONTROL_RE = /[\u200B-\u200D\uFEFF\u00AD\u0000-\u001F\u007F-\u009F]/g;
+const NON_ASCII_RE = /[^\x00-\x7F]/g;
+const ILLEGAL_CHARS_WINDOWS_RE = /[<>:"/\\|?*]/g;
+const ILLEGAL_CHARS_UNIX_RE = /\//g;
+const TRAILING_DOTS_SPACES_RE = /[. ]+$/;
+const WHITESPACE_RE = /\s+/g;
+const RESERVED_NAMES_WINDOWS = new Set([
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9"
+]);
+const textEncoder = new TextEncoder();
 export function sanitizeFileName(filename, replacement = "_") {
     let sanitizedFilename = filename.normalize("NFC");
-    sanitizedFilename = sanitizedFilename.replace(/[\u200B-\u200D\uFEFF\u00AD\u0000-\u001F\u007F-\u009F]/g, "");
-    sanitizedFilename = sanitizedFilename.replace(/[^\x00-\x7F]/g, replacement);
-    const illegalCharsWindows = /[<>:"/\\|?*]/g;
-    const illegalCharsUnix = /\//g;
-    const reservedNamesWindows = new Set([
-        "CON",
-        "PRN",
-        "AUX",
-        "NUL",
-        "COM1",
-        "COM2",
-        "COM3",
-        "COM4",
-        "COM5",
-        "COM6",
-        "COM7",
-        "COM8",
-        "COM9",
-        "LPT1",
-        "LPT2",
-        "LPT3",
-        "LPT4",
-        "LPT5",
-        "LPT6",
-        "LPT7",
-        "LPT8",
-        "LPT9"
-    ]);
-    sanitizedFilename = sanitizedFilename.replace(illegalCharsWindows, replacement);
-    sanitizedFilename = sanitizedFilename.replace(illegalCharsUnix, replacement);
-    sanitizedFilename = sanitizedFilename.replace(/[. ]+$/, "");
-    sanitizedFilename = sanitizedFilename.replace(/\s+/g, replacement);
-    if (reservedNamesWindows.has(sanitizedFilename.toUpperCase())) {
+    sanitizedFilename = sanitizedFilename.replace(ZERO_WIDTH_AND_CONTROL_RE, "");
+    sanitizedFilename = sanitizedFilename.replace(NON_ASCII_RE, replacement);
+    sanitizedFilename = sanitizedFilename.replace(ILLEGAL_CHARS_WINDOWS_RE, replacement);
+    sanitizedFilename = sanitizedFilename.replace(ILLEGAL_CHARS_UNIX_RE, replacement);
+    sanitizedFilename = sanitizedFilename.replace(TRAILING_DOTS_SPACES_RE, "");
+    sanitizedFilename = sanitizedFilename.replace(WHITESPACE_RE, replacement);
+    if (RESERVED_NAMES_WINDOWS.has(sanitizedFilename.toUpperCase())) {
         sanitizedFilename += replacement;
     }
     const maxByteLength = 255;
-    let byteLength = new TextEncoder().encode(sanitizedFilename).length;
+    let byteLength = textEncoder.encode(sanitizedFilename).length;
     while (byteLength > maxByteLength && sanitizedFilename.length > 0) {
         sanitizedFilename = sanitizedFilename.slice(0, -1);
-        byteLength = new TextEncoder().encode(sanitizedFilename).length;
+        byteLength = textEncoder.encode(sanitizedFilename).length;
     }
     if (!sanitizedFilename) {
         return "file";
@@ -158,7 +163,7 @@ export function parseFilenPublicLink(url) {
         try {
             key = Buffer.from(key, "hex").toString("utf8");
         }
-        catch (_a) {
+        catch {
             return null;
         }
     }
@@ -222,7 +227,7 @@ export function jsonBigIntReplacer(_, value) {
 }
 export function jsonBigIntReviver(_, value) {
     if (typeof value === "string" && value.startsWith("$bigint:") && value.endsWith("n")) {
-        return BigInt(value.substring(8, -1));
+        return BigInt(value.slice(8, -1));
     }
     return value;
 }
@@ -314,20 +319,20 @@ export function bpsToReadable(bps) {
     if (!(bps > 0 && bps < 1099511627776)) {
         return "0.1 B/s";
     }
-    let i = 0;
+    let i = -1;
     let value = bps;
     if (value >= 1024) {
         value /= 1024;
-        i = 1;
+        i = 0;
         if (value >= 1024) {
             value /= 1024;
-            i = 2;
+            i = 1;
             if (value >= 1024) {
                 value /= 1024;
-                i = 3;
+                i = 2;
                 if (value >= 1024) {
                     value /= 1024;
-                    i = 4;
+                    i = 3;
                 }
             }
         }
@@ -335,6 +340,9 @@ export function bpsToReadable(bps) {
     if (value < 0.1) {
         value = 0.1;
     }
+    if (i < 0) {
+        return value.toFixed(1) + " B";
+    }
     return value.toFixed(1) + " " + BPS_TO_READABLE_UNITS[i];
 }
 export const FORMAT_BYTES_SIZES = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];

package/dist/notes.js

@@ -1,15 +1,14 @@
 import striptags from "striptags";
 export function createNotePreviewFromContentText(type, content) {
-    var _a, _b, _c;
     try {
         if (!content || content.length === 0) {
             return "";
         }
         if (type === "rich") {
             if (content.indexOf("<p><br></p>") === -1) {
-                return striptags((_a = content.split("\n")[0]) !== null && _a !== void 0 ? _a : "").slice(0, 128);
+                return striptags(content.split("\n")[0] ?? "").slice(0, 128);
             }
-            return striptags((_b = content.split("<p><br></p>")[0]) !== null && _b !== void 0 ? _b : "").slice(0, 128);
+            return striptags(content.split("<p><br></p>")[0] ?? "").slice(0, 128);
         }
         if (type === "checklist") {
             const ex = content
@@ -31,9 +30,9 @@ export function createNotePreviewFromContentText(type, content) {
             }
             return "";
         }
-        return striptags((_c = content.split("\n")[0]) !== null && _c !== void 0 ? _c : "").slice(0, 128);
+        return striptags(content.split("\n")[0] ?? "").slice(0, 128);
     }
-    catch (_d) {
+    catch {
         return "";
     }
 }

package/dist/run.js

@@ -1,50 +1,37 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export function run(fn, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const deferredFunctions = [];
-        const defer = deferFn => {
-            deferredFunctions.push(deferFn);
+export async function run(fn, options) {
+    const deferredFunctions = [];
+    const defer = deferFn => {
+        deferredFunctions.push(deferFn);
+    };
+    try {
+        const result = await fn(defer);
+        return {
+            success: true,
+            data: result,
+            error: null
         };
-        try {
-            const result = yield fn(defer);
-            return {
-                success: true,
-                data: result,
-                error: null
-            };
+    }
+    catch (e) {
+        options?.onError?.(e);
+        if (options?.throw) {
+            throw e;
         }
-        catch (e) {
-            const error = e instanceof Error ? e : new Error("Unknown error");
-            (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
-            if (options === null || options === void 0 ? void 0 : options.throw) {
-                throw error;
+        return {
+            success: false,
+            data: null,
+            error: e
+        };
+    }
+    finally {
+        for (let i = deferredFunctions.length - 1; i >= 0; i--) {
+            try {
+                await deferredFunctions[i]?.();
             }
-            return {
-                success: false,
-                data: null,
-                error: error
-            };
-        }
-        finally {
-            for (let i = deferredFunctions.length - 1; i >= 0; i--) {
-                try {
-                    yield ((_b = deferredFunctions[i]) === null || _b === void 0 ? void 0 : _b.call(deferredFunctions));
-                }
-                catch (e) {
-                    (_c = options === null || options === void 0 ? void 0 : options.onError) === null || _c === void 0 ? void 0 : _c.call(options, e instanceof Error ? e : new Error("Unknown error"));
-                }
+            catch (e) {
+                options?.onError?.(e);
             }
         }
-    });
+    }
 }
 export class AbortError extends Error {
     constructor(message = "Operation aborted") {
@@ -65,110 +52,103 @@ export function abortSignalReason(signal) {
         }
         return undefined;
     }
-    catch (_a) {
+    catch {
         return undefined;
     }
 }
-export function runAbortable(fn, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const deferredFunctions = [];
-        const controller = (_a = options === null || options === void 0 ? void 0 : options.controller) !== null && _a !== void 0 ? _a : new AbortController();
-        const signal = (_d = (_b = options === null || options === void 0 ? void 0 : options.signal) !== null && _b !== void 0 ? _b : (_c = options === null || options === void 0 ? void 0 : options.controller) === null || _c === void 0 ? void 0 : _c.signal) !== null && _d !== void 0 ? _d : controller.signal;
-        const defer = deferFn => {
-            deferredFunctions.push(deferFn);
-        };
-        const abortable = (abortableFn, opts) => __awaiter(this, void 0, void 0, function* () {
-            if (signal.aborted) {
-                throw new AbortError(abortSignalReason(signal));
-            }
-            return yield new Promise((resolve, reject) => {
-                ;
-                (() => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    const signal = (_a = opts === null || opts === void 0 ? void 0 : opts.signal) !== null && _a !== void 0 ? _a : controller.signal;
-                    const abortHandler = () => {
+export async function runAbortable(fn, options) {
+    const deferredFunctions = [];
+    const controller = options?.controller ?? new AbortController();
+    const signal = options?.signal ?? options?.controller?.signal ?? controller.signal;
+    const defer = deferFn => {
+        deferredFunctions.push(deferFn);
+    };
+    const abortable = async (abortableFn, opts) => {
+        if (signal.aborted) {
+            throw new AbortError(abortSignalReason(signal));
+        }
+        return await new Promise((resolve, reject) => {
+            ;
+            (async () => {
+                const signal = opts?.signal ?? controller.signal;
+                const abortHandler = () => {
+                    reject(new AbortError(abortSignalReason(signal)));
+                };
+                signal.addEventListener("abort", abortHandler);
+                try {
+                    if (signal.aborted) {
                         reject(new AbortError(abortSignalReason(signal)));
-                    };
-                    signal.addEventListener("abort", abortHandler);
-                    try {
-                        if (signal.aborted) {
-                            reject(new AbortError(abortSignalReason(signal)));
-                            return;
-                        }
-                        const result = yield abortableFn();
-                        if (signal.aborted) {
-                            reject(new AbortError(abortSignalReason(signal)));
-                            return;
-                        }
-                        resolve(result);
-                    }
-                    catch (error) {
-                        reject(error);
+                        return;
                     }
-                    finally {
-                        signal.removeEventListener("abort", abortHandler);
+                    const result = await abortableFn();
+                    if (signal.aborted) {
+                        reject(new AbortError(abortSignalReason(signal)));
+                        return;
                     }
-                }))();
-            });
-        });
-        try {
-            if (signal.aborted) {
-                throw new AbortError(abortSignalReason(signal));
-            }
-            const result = yield fn({
-                abortable,
-                defer,
-                signal,
-                controller
-            });
-            if (signal.aborted) {
-                throw new AbortError(abortSignalReason(signal));
-            }
-            return {
-                success: true,
-                data: result,
-                error: null
-            };
-        }
-        catch (e) {
-            const error = e instanceof Error ? e : new Error("Unknown error");
-            (_e = options === null || options === void 0 ? void 0 : options.onError) === null || _e === void 0 ? void 0 : _e.call(options, error);
-            if (options === null || options === void 0 ? void 0 : options.throw) {
-                throw error;
-            }
-            return {
-                success: false,
-                data: null,
-                error: error
-            };
-        }
-        finally {
-            for (let i = deferredFunctions.length - 1; i >= 0; i--) {
-                try {
-                    yield ((_f = deferredFunctions[i]) === null || _f === void 0 ? void 0 : _f.call(deferredFunctions));
+                    resolve(result);
                 }
                 catch (e) {
-                    (_g = options === null || options === void 0 ? void 0 : options.onError) === null || _g === void 0 ? void 0 : _g.call(options, e instanceof Error ? e : new Error("Unknown error"));
+                    reject(e);
+                }
+                finally {
+                    signal.removeEventListener("abort", abortHandler);
                 }
+            })();
+        });
+    };
+    try {
+        if (signal.aborted) {
+            throw new AbortError(abortSignalReason(signal));
+        }
+        const result = await fn({
+            abortable,
+            defer,
+            signal,
+            controller
+        });
+        if (signal.aborted) {
+            throw new AbortError(abortSignalReason(signal));
+        }
+        return {
+            success: true,
+            data: result,
+            error: null
+        };
+    }
+    catch (e) {
+        options?.onError?.(e);
+        if (options?.throw) {
+            throw e;
+        }
+        return {
+            success: false,
+            data: null,
+            error: e
+        };
+    }
+    finally {
+        for (let i = deferredFunctions.length - 1; i >= 0; i--) {
+            try {
+                await deferredFunctions[i]?.();
+            }
+            catch (e) {
+                options?.onError?.(e);
             }
         }
-    });
+    }
 }
 export function runEffect(fn, options) {
-    var _a;
     const deferredFunctions = [];
     const defer = deferFn => {
         deferredFunctions.push(deferFn);
     };
     const cleanup = () => {
-        var _a, _b;
         for (let i = deferredFunctions.length - 1; i >= 0; i--) {
             try {
-                (_a = deferredFunctions[i]) === null || _a === void 0 ? void 0 : _a.call(deferredFunctions);
+                deferredFunctions[i]?.();
             }
             catch (e) {
-                (_b = options === null || options === void 0 ? void 0 : options.onError) === null || _b === void 0 ? void 0 : _b.call(options, e instanceof Error ? e : new Error("Unknown error"));
+                options?.onError?.(e);
             }
         }
     };
@@ -182,57 +162,56 @@ export function runEffect(fn, options) {
         };
     }
     catch (e) {
-        const error = e instanceof Error ? e : new Error("Unknown error");
-        (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
-        if (options === null || options === void 0 ? void 0 : options.throw) {
-            throw error;
+        options?.onError?.(e);
+        if (options?.throw) {
+            throw e;
         }
         return {
             success: false,
             data: null,
-            error: error,
+            error: e,
             cleanup
         };
     }
     finally {
-        if (options === null || options === void 0 ? void 0 : options.automaticCleanup) {
+        if (options?.automaticCleanup) {
             cleanup();
         }
     }
 }
-export function runRetry(fn, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        const maxAttempts = (_a = options === null || options === void 0 ? void 0 : options.maxAttempts) !== null && _a !== void 0 ? _a : 3;
-        const delayMs = (_b = options === null || options === void 0 ? void 0 : options.delayMs) !== null && _b !== void 0 ? _b : 1000;
-        const backoff = (_c = options === null || options === void 0 ? void 0 : options.backoff) !== null && _c !== void 0 ? _c : "exponential";
-        let lastError = null;
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            const result = yield run(defer => fn(defer, attempt), Object.assign(Object.assign({}, options), { throw: false }));
-            if (result.success) {
-                return result;
-            }
-            lastError = result.error;
-            if (attempt < maxAttempts) {
-                const shouldRetry = typeof (options === null || options === void 0 ? void 0 : options.shouldRetry) === "boolean"
-                    ? options.shouldRetry
-                    : options && typeof options.shouldRetry === "function"
-                        ? options.shouldRetry(result.error, attempt)
-                        : true;
-                if (!shouldRetry) {
-                    break;
-                }
-                (_d = options === null || options === void 0 ? void 0 : options.onRetry) === null || _d === void 0 ? void 0 : _d.call(options, result.error, attempt);
-                const delay = backoff === "exponential" ? delayMs * Math.pow(2, attempt - 1) : delayMs * attempt;
-                yield new Promise(resolve => setTimeout(resolve, delay));
+export async function runRetry(fn, options) {
+    const maxAttempts = options?.maxAttempts ?? 3;
+    const delayMs = options?.delayMs ?? 1000;
+    const backoff = options?.backoff ?? "exponential";
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const result = await run(defer => fn(defer, attempt), {
+            ...options,
+            throw: false
+        });
+        if (result.success) {
+            return result;
+        }
+        lastError = result.error;
+        if (attempt < maxAttempts) {
+            const shouldRetry = typeof options?.shouldRetry === "boolean"
+                ? options.shouldRetry
+                : options && typeof options.shouldRetry === "function"
+                    ? options.shouldRetry(result.error, attempt)
+                    : true;
+            if (!shouldRetry) {
+                break;
             }
+            options?.onRetry?.(result.error, attempt);
+            const delay = backoff === "exponential" ? delayMs * Math.pow(2, attempt - 1) : delayMs * attempt;
+            await new Promise(resolve => setTimeout(resolve, delay));
         }
-        return {
-            success: false,
-            data: null,
-            error: lastError
-        };
-    });
+    }
+    return {
+        success: false,
+        data: null,
+        error: lastError
+    };
 }
 export class TimeoutError extends Error {
     constructor(message = "Operation timed out") {
@@ -240,39 +219,36 @@ export class TimeoutError extends Error {
         this.name = "TimeoutError";
     }
 }
-export function runTimeout(fn, timeoutMs, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const controller = new AbortController();
-        try {
-            const result = yield Promise.race([
-                run(fn, options),
-                new Promise((_, reject) => {
-                    const timeoutId = setTimeout(() => {
-                        controller.abort();
-                        reject(new TimeoutError(`Operation timed out after ${timeoutMs}ms`));
-                    }, timeoutMs);
-                    controller.signal.addEventListener("abort", () => clearTimeout(timeoutId));
-                })
-            ]);
-            return result;
-        }
-        catch (e) {
-            const error = e instanceof Error ? e : new Error("Unknown error");
-            (_a = options === null || options === void 0 ? void 0 : options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
-            if (options === null || options === void 0 ? void 0 : options.throw) {
-                throw error;
-            }
-            return {
-                success: false,
-                data: null,
-                error: error
-            };
+export async function runTimeout(fn, timeoutMs, options) {
+    const controller = new AbortController();
+    try {
+        const result = await Promise.race([
+            run(fn, options),
+            new Promise((_, reject) => {
+                const timeoutId = setTimeout(() => {
+                    controller.abort();
+                    reject(new TimeoutError(`Operation timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+                controller.signal.addEventListener("abort", () => clearTimeout(timeoutId));
+            })
+        ]);
+        return result;
+    }
+    catch (e) {
+        options?.onError?.(e);
+        if (options?.throw) {
+            throw e;
         }
-    });
+        return {
+            success: false,
+            data: null,
+            error: e
+        };
+    }
 }
 export function runDebounced(fn, delayMs, options) {
     let timeoutId = null;
+    let pendingResolve = null;
     let pendingPromise = null;
     return (...args) => {
         if (timeoutId) {
@@ -280,15 +256,122 @@ export function runDebounced(fn, delayMs, options) {
         }
         if (!pendingPromise) {
             pendingPromise = new Promise(resolve => {
-                timeoutId = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    const result = yield run(defer => fn(defer, ...args), options);
-                    resolve(result);
-                    pendingPromise = null;
-                    timeoutId = null;
-                }), delayMs);
+                pendingResolve = resolve;
             });
         }
+        timeoutId = setTimeout(async () => {
+            const result = await run(defer => fn(defer, ...args), options);
+            pendingResolve(result);
+            pendingPromise = null;
+            pendingResolve = null;
+            timeoutId = null;
+        }, delayMs);
         return pendingPromise;
     };
 }
+export function createAbortablePipeline(signal) {
+    const controller = new AbortController();
+    const controllerSignal = controller.signal;
+    if (signal) {
+        if (signal.aborted) {
+            controller.abort(signal.reason);
+        }
+        else {
+            signal.addEventListener("abort", () => controller.abort(signal.reason), {
+                once: true
+            });
+        }
+    }
+    let chain = Promise.resolve();
+    let halted = false;
+    const step = (fn) => {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        chain = chain.then(async () => {
+            if (halted || controllerSignal.aborted) {
+                reject(new AbortError(controllerSignal.aborted ? abortSignalReason(controllerSignal) : "Pipeline halted"));
+                return;
+            }
+            const stepDeferred = [];
+            const defer = deferFn => {
+                stepDeferred.push(deferFn);
+            };
+            const runCleanups = async () => {
+                for (let i = stepDeferred.length - 1; i >= 0; i--) {
+                    try {
+                        await stepDeferred[i]?.();
+                    }
+                    catch {
+                    }
+                }
+            };
+            let fnSucceeded = false;
+            let fnValue;
+            let fnError;
+            const fnPromise = (async () => {
+                try {
+                    fnValue = await fn(defer, controllerSignal);
+                    fnSucceeded = true;
+                }
+                catch (e) {
+                    fnError = e;
+                    fnSucceeded = false;
+                }
+            })();
+            if (controllerSignal.aborted) {
+                await fnPromise;
+                await runCleanups();
+                if (fnSucceeded) {
+                    resolve(fnValue);
+                }
+                else {
+                    halted = true;
+                    reject(fnError);
+                }
+                return;
+            }
+            try {
+                await new Promise((res, rej) => {
+                    const onAbort = () => {
+                        rej(new AbortError(abortSignalReason(controllerSignal)));
+                    };
+                    controllerSignal.addEventListener("abort", onAbort, {
+                        once: true
+                    });
+                    fnPromise.then(() => {
+                        controllerSignal.removeEventListener("abort", onAbort);
+                        res();
+                    });
+                });
+            }
+            catch (e) {
+                await runCleanups();
+                halted = true;
+                reject(e);
+                return;
+            }
+            await runCleanups();
+            if (fnSucceeded) {
+                resolve(fnValue);
+            }
+            else {
+                halted = true;
+                reject(fnError);
+            }
+        });
+        return {
+            then: promise.then.bind(promise),
+            catch: promise.catch.bind(promise),
+            finally: promise.finally.bind(promise)
+        };
+    };
+    return {
+        step,
+        signal: controllerSignal
+    };
+}
 export default run;

package/dist/semaphore.js

@@ -40,7 +40,7 @@ export class Semaphore {
         return unresolved;
     }
     processQueue() {
-        if (this.waiting.length > 0 && this.counter < this.maxCount) {
+        while (this.waiting.length > 0 && this.counter < this.maxCount) {
             this.counter++;
             const waiter = this.waiting.shift();
             if (waiter) {

package/dist/types/run.d.ts

@@ -3,21 +3,21 @@ export type Success<T> = {
     data: T;
     error: null;
 };
-export type Failure<E = Error> = {
+export type Failure<E = unknown> = {
     success: false;
     data: null;
     error: E;
 };
-export type Result<T, E = Error> = Success<T> | Failure<E>;
+export type Result<T, E = unknown> = Success<T> | Failure<E>;
 export type GenericFnResult = number | boolean | string | object | null | undefined | symbol | bigint | void | Promise<number | boolean | string | object | null | undefined | symbol | bigint | void> | Array<number | boolean | string | object | null | undefined | symbol | bigint | void>;
 export type DeferFn = (fn: () => GenericFnResult) => void;
 export type DeferredFunction = () => GenericFnResult;
 export type DeferredFunctions = Array<DeferredFunction>;
 export type Options = {
     throw?: boolean;
-    onError?: (err: Error) => void;
+    onError?: (err: unknown) => void;
 };
-export declare function run<TResult, E = Error>(fn: (deferFn: DeferFn) => Promise<TResult> | TResult, options?: Options): Promise<Result<TResult, E>>;
+export declare function run<TResult, E = unknown>(fn: (deferFn: DeferFn) => Promise<TResult> | TResult, options?: Options): Promise<Result<TResult, E>>;
 export type AbortableFn = (abortableFn: () => GenericFnResult, opts?: {
     signal?: AbortSignal;
 }) => GenericFnResult;
@@ -25,7 +25,7 @@ export declare class AbortError extends Error {
     constructor(message?: string);
 }
 export declare function abortSignalReason(signal: AbortSignal): string | undefined;
-export declare function runAbortable<TResult, E = Error>(fn: ({ abortable, defer, signal, controller }: {
+export declare function runAbortable<TResult, E = unknown>(fn: ({ abortable, defer, signal, controller }: {
     abortable: AbortableFn;
     defer: DeferFn;
     signal: AbortSignal;
@@ -34,12 +34,12 @@ export declare function runAbortable<TResult, E = Error>(fn: ({ abortable, defer
     controller?: AbortController;
     signal?: AbortSignal;
 }): Promise<Result<TResult, E>>;
-export declare function runEffect<TResult, E = Error>(fn: (deferFn: DeferFn) => TResult, options?: Options & {
+export declare function runEffect<TResult, E = unknown>(fn: (deferFn: DeferFn) => TResult, options?: Options & {
     automaticCleanup?: boolean;
 }): Result<TResult, E> & {
     cleanup: () => void;
 };
-export declare function runRetry<TResult, E = Error>(fn: (deferFn: DeferFn, attempt: number) => Promise<TResult> | TResult, options?: Options & {
+export declare function runRetry<TResult, E = unknown>(fn: (deferFn: DeferFn, attempt: number) => Promise<TResult> | TResult, options?: Options & {
     maxAttempts?: number;
     delayMs?: number;
     backoff?: "linear" | "exponential";
@@ -49,6 +49,16 @@ export declare function runRetry<TResult, E = Error>(fn: (deferFn: DeferFn, atte
 export declare class TimeoutError extends Error {
     constructor(message?: string);
 }
-export declare function runTimeout<TResult, E = Error>(fn: (deferFn: DeferFn) => Promise<TResult> | TResult, timeoutMs: number, options?: Options): Promise<Result<TResult, E>>;
-export declare function runDebounced<TResult, TArgs extends unknown[]>(fn: (defer: DeferFn, ...args: TArgs) => Promise<TResult> | TResult, delayMs: number, options?: Options): (...args: TArgs) => Promise<Result<TResult, Error>>;
+export declare function runTimeout<TResult, E = unknown>(fn: (deferFn: DeferFn) => Promise<TResult> | TResult, timeoutMs: number, options?: Options): Promise<Result<TResult, E>>;
+export declare function runDebounced<TResult, TArgs extends unknown[]>(fn: (defer: DeferFn, ...args: TArgs) => Promise<TResult> | TResult, delayMs: number, options?: Options): (...args: TArgs) => Promise<Result<TResult, unknown>>;
+export type StepFn<T> = (defer: DeferFn, signal: AbortSignal) => Promise<T> | T;
+export type StepHandle<T> = {
+    then: Promise<T>["then"];
+    catch: Promise<T>["catch"];
+    finally: Promise<T>["finally"];
+};
+export declare function createAbortablePipeline(signal?: AbortSignal): {
+    step: <T>(fn: StepFn<T>) => StepHandle<T>;
+    signal: AbortSignal;
+};
 export default run;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@filen/utils",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "A collection of utils for Filen",
 	"private": false,
 	"repository": {