@anabranch/fs 0.1.0

package/esm/anabranch/streams/task.d.ts

@@ -0,0 +1,117 @@
+import type { Promisable, Result } from "./util.js";
+/**
+ * A single async task with error-aware utilities like retries and timeouts.
+ */
+export declare class Task<T, E> {
+    private runTask;
+    private constructor();
+    /**
+     * Creates a {@link Task} from an async function.
+     * The function receives an optional AbortSignal that is active when
+     * the task is run with a signal via {@link withSignal} or {@link run}.
+     *
+     * Note: the error type `E` is unchecked and represents the expected error
+     * shape rather than a runtime guarantee.
+     */
+    static of<R, E>(task: (signal?: AbortSignal) => Promise<R>): Task<R, E>;
+    /**
+     * Wraps the task with an external abort signal.
+     */
+    withSignal(signal: AbortSignal): Task<T, E>;
+    /**
+     * Executes the task and returns a tagged result instead of throwing.
+     */
+    result(): Promise<Result<T, E>>;
+    /**
+     * Executes the task and resolves the value or throws the error.
+     */
+    run(): Promise<T>;
+    /**
+     * Maps the successful value. Errors are passed through unchanged.
+     */
+    map<U>(fn: (value: T) => Promisable<U>): Task<U, E>;
+    /**
+     * Chains another task based on the successful value.
+     */
+    flatMap<U>(fn: (value: T) => Task<U, E>): Task<U, E>;
+    /**
+     * Maps the error value. Successful values are passed through unchanged.
+     */
+    mapErr<F>(fn: (error: E) => Promisable<F>): Task<T, F>;
+    /**
+     * Runs a side effect on the successful value.
+     */
+    tap(fn: (value: T) => Promisable<void>): Task<T, E>;
+    /**
+     * Runs a side effect on the error value.
+     */
+    tapErr(fn: (error: E) => Promisable<void>): Task<T, E>;
+    /**
+     * Recovers from errors by mapping them to a successful value.
+     */
+    recover<U>(fn: (error: E) => Promisable<U>): Task<T | U, never>;
+    /**
+     * Recovers from specific error types by mapping them to a successful value.
+     */
+    recoverWhen<E2 extends E, U>(guard: (error: E) => error is E2, fn: (error: E2) => Promisable<U>): Task<T | U, Exclude<E, E2>>;
+    /**
+     * Retries the task when the predicate returns true.
+     */
+    retry(options: {
+        attempts: number;
+        delay?: number | ((attempt: number, error: E) => number);
+        when?: (error: E) => boolean;
+    }): Task<T, E>;
+    /**
+     * Fails if the task does not complete within the specified time.
+     */
+    timeout(ms: number, error?: E): Task<T, E>;
+    /**
+     * Runs multiple tasks and collects results. Rejects on the first failure.
+     */
+    static all<T, E>(tasks: Task<T, E>[]): Task<T[], E>;
+    /**
+     * Runs multiple tasks and collects all results without throwing.
+     */
+    static allSettled<T, E>(tasks: Task<T, E>[]): Task<Result<T, E>[], never>;
+    /**
+     * Runs tasks concurrently and resolves with the first settled result.
+     *
+     * Note: If all tasks fail, the errors array is in completion order (the order
+     * tasks finished), not task order. This is nondeterministic due to
+     * concurrent execution.
+     */
+    static race<T, E>(tasks: Task<T, E>[]): Task<Result<T, E[]>, never>;
+    /**
+     * Acquires a resource, runs a task that uses it, and releases it regardless
+     * of success or failure. Useful for resource lifecycle management when the
+     * use computation is a composed Task chain.
+     *
+     * The `acquire` function receives an optional AbortSignal that is active when
+     * the task is run with a signal. The `release` function always runs and does
+     * not receive a signal — cleanup should not be cancellable.
+     *
+     * @example
+     * ```ts
+     * const task = Task.acquireRelease({
+     *   acquire: (signal) => db.connect(signal),
+     *   release: (conn) => conn.close(),
+     *   use: (conn) => Task.of(() => query(conn))
+     *     .retry({ attempts: 3 })
+     *     .timeout(5_000),
+     * });
+     *
+     * const result = await task.result();
+     * ```
+     */
+    static acquireRelease<R, T, E>({ acquire, release, use, }: {
+        acquire: (signal?: AbortSignal) => Promise<R>;
+        release: (resource: R) => Promise<void>;
+        use: (resource: R) => Task<T, E>;
+    }): Task<T, E>;
+    protected runWithSignal(signal?: AbortSignal): Promise<T>;
+    private delayWithSignal;
+    private mergeSignals;
+    private static mergeExternalSignals;
+}
+//# sourceMappingURL=task.d.ts.map

package/esm/anabranch/streams/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../../src/anabranch/streams/task.ts"],"names":[],"mappings":"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"}

package/esm/anabranch/streams/task.js

@@ -0,0 +1,416 @@
+/**
+ * A single async task with error-aware utilities like retries and timeouts.
+ */
+export class Task {
+    constructor(task) {
+        Object.defineProperty(this, "runTask", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.runTask = task;
+    }
+    /**
+     * Creates a {@link Task} from an async function.
+     * The function receives an optional AbortSignal that is active when
+     * the task is run with a signal via {@link withSignal} or {@link run}.
+     *
+     * Note: the error type `E` is unchecked and represents the expected error
+     * shape rather than a runtime guarantee.
+     */
+    static of(task) {
+        return new Task(task);
+    }
+    /**
+     * Wraps the task with an external abort signal.
+     */
+    withSignal(signal) {
+        return new Task((innerSignal) => {
+            const { signal: merged, cleanup } = this.mergeSignals(signal, innerSignal);
+            return this.runWithSignal(merged).finally(cleanup);
+        });
+    }
+    /**
+     * Executes the task and returns a tagged result instead of throwing.
+     */
+    async result() {
+        try {
+            const value = await this.run();
+            return { type: "success", value };
+        }
+        catch (error) {
+            return { type: "error", error: error };
+        }
+    }
+    /**
+     * Executes the task and resolves the value or throws the error.
+     */
+    run() {
+        return this.runWithSignal();
+    }
+    /**
+     * Maps the successful value. Errors are passed through unchanged.
+     */
+    map(fn) {
+        return new Task(async (signal) => {
+            const value = await this.runWithSignal(signal);
+            return await fn(value);
+        });
+    }
+    /**
+     * Chains another task based on the successful value.
+     */
+    flatMap(fn) {
+        return new Task(async (signal) => {
+            const value = await this.runWithSignal(signal);
+            const next = fn(value);
+            return await next.runWithSignal(signal);
+        });
+    }
+    /**
+     * Maps the error value. Successful values are passed through unchanged.
+     */
+    mapErr(fn) {
+        return new Task(async (signal) => {
+            try {
+                return await this.runWithSignal(signal);
+            }
+            catch (error) {
+                throw await fn(error);
+            }
+        });
+    }
+    /**
+     * Runs a side effect on the successful value.
+     */
+    tap(fn) {
+        return new Task(async (signal) => {
+            const value = await this.runWithSignal(signal);
+            await fn(value);
+            return value;
+        });
+    }
+    /**
+     * Runs a side effect on the error value.
+     */
+    tapErr(fn) {
+        return new Task(async (signal) => {
+            try {
+                return await this.runWithSignal(signal);
+            }
+            catch (error) {
+                await fn(error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Recovers from errors by mapping them to a successful value.
+     */
+    recover(fn) {
+        return new Task(async (signal) => {
+            try {
+                return await this.runWithSignal(signal);
+            }
+            catch (error) {
+                return await fn(error);
+            }
+        });
+    }
+    /**
+     * Recovers from specific error types by mapping them to a successful value.
+     */
+    recoverWhen(guard, fn) {
+        return new Task(async (signal) => {
+            try {
+                return await this.runWithSignal(signal);
+            }
+            catch (error) {
+                if (guard(error)) {
+                    return await fn(error);
+                }
+                throw error;
+            }
+        });
+    }
+    /**
+     * Retries the task when the predicate returns true.
+     */
+    retry(options) {
+        const { attempts, delay, when } = options;
+        return new Task(async (signal) => {
+            let lastError;
+            for (let attempt = 0; attempt < attempts; attempt += 1) {
+                try {
+                    return await this.runWithSignal(signal);
+                }
+                catch (error) {
+                    lastError = error;
+                    if (when && !when(lastError)) {
+                        throw lastError;
+                    }
+                    if (attempt + 1 < attempts) {
+                        const delayMs = typeof delay === "function"
+                            ? delay(attempt, lastError)
+                            : (delay ?? 0);
+                        if (delayMs > 0) {
+                            await this.delayWithSignal(delayMs, signal);
+                        }
+                    }
+                }
+            }
+            throw lastError;
+        });
+    }
+    /**
+     * Fails if the task does not complete within the specified time.
+     */
+    timeout(ms, error) {
+        return new Task(async (signal) => {
+            let timeoutId;
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    reject(error ?? new Error(`Timeout after ${ms}ms`));
+                }, ms);
+            });
+            try {
+                return await Promise.race([
+                    this.runWithSignal(signal),
+                    timeoutPromise,
+                ]);
+            }
+            finally {
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        });
+    }
+    /**
+     * Runs multiple tasks and collects results. Rejects on the first failure.
+     */
+    static all(tasks) {
+        return new Task(async (signal) => {
+            const runTask = signal
+                ? (task) => task.withSignal(signal).run()
+                : (task) => task.run();
+            const results = await Promise.all(tasks.map(runTask));
+            return results;
+        });
+    }
+    /**
+     * Runs multiple tasks and collects all results without throwing.
+     */
+    static allSettled(tasks) {
+        return new Task(async (signal) => {
+            const getResult = signal
+                ? (task) => task.withSignal(signal).result()
+                : (task) => task.result();
+            const results = await Promise.all(tasks.map(getResult));
+            return results;
+        });
+    }
+    /**
+     * Runs tasks concurrently and resolves with the first settled result.
+     *
+     * Note: If all tasks fail, the errors array is in completion order (the order
+     * tasks finished), not task order. This is nondeterministic due to
+     * concurrent execution.
+     */
+    static race(tasks) {
+        return new Task(async (signal) => {
+            if (tasks.length === 0) {
+                throw new Error("Task.race requires at least one task");
+            }
+            const errors = [];
+            const controllers = tasks.map(() => new AbortController());
+            const cleanup = new Map();
+            const merged = tasks.map((task, index) => {
+                if (!signal) {
+                    return task.withSignal(controllers[index].signal);
+                }
+                const mergedSignals = Task.mergeExternalSignals(signal, controllers[index].signal);
+                cleanup.set(index, mergedSignals.cleanup);
+                return task.withSignal(mergedSignals.signal);
+            });
+            return await new Promise((resolve, reject) => {
+                let remaining = merged.length;
+                let resolved = false;
+                const abortListener = signal
+                    ? () => reject(signal.reason ?? new Error("Task aborted"))
+                    : undefined;
+                if (abortListener && signal) {
+                    signal.addEventListener("abort", abortListener, { once: true });
+                }
+                merged.forEach((task, index) => {
+                    task.result().then((value) => {
+                        if (resolved) {
+                            return;
+                        }
+                        if (value.type === "success") {
+                            resolved = true;
+                            controllers.forEach((controller, controllerIndex) => {
+                                if (controllerIndex !== index) {
+                                    controller.abort();
+                                }
+                            });
+                            cleanup.forEach((cleanupFn) => cleanupFn());
+                            if (abortListener && signal) {
+                                signal.removeEventListener("abort", abortListener);
+                            }
+                            resolve({ type: "success", value: value.value });
+                            return;
+                        }
+                        errors.push(value.error);
+                        remaining -= 1;
+                        if (remaining === 0) {
+                            resolved = true;
+                            cleanup.forEach((cleanupFn) => cleanupFn());
+                            if (abortListener && signal) {
+                                signal.removeEventListener("abort", abortListener);
+                            }
+                            resolve({ type: "error", error: errors });
+                            controllers.forEach((controller) => controller.abort());
+                        }
+                    }).catch((error) => {
+                        if (resolved) {
+                            return;
+                        }
+                        resolved = true;
+                        cleanup.forEach((cleanupFn) => cleanupFn());
+                        if (abortListener && signal) {
+                            signal.removeEventListener("abort", abortListener);
+                        }
+                        controllers.forEach((controller) => controller.abort());
+                        reject(error);
+                    });
+                });
+            });
+        });
+    }
+    /**
+     * Acquires a resource, runs a task that uses it, and releases it regardless
+     * of success or failure. Useful for resource lifecycle management when the
+     * use computation is a composed Task chain.
+     *
+     * The `acquire` function receives an optional AbortSignal that is active when
+     * the task is run with a signal. The `release` function always runs and does
+     * not receive a signal — cleanup should not be cancellable.
+     *
+     * @example
+     * ```ts
+     * const task = Task.acquireRelease({
+     *   acquire: (signal) => db.connect(signal),
+     *   release: (conn) => conn.close(),
+     *   use: (conn) => Task.of(() => query(conn))
+     *     .retry({ attempts: 3 })
+     *     .timeout(5_000),
+     * });
+     *
+     * const result = await task.result();
+     * ```
+     */
+    static acquireRelease({ acquire, release, use, }) {
+        return new Task(async (signal) => {
+            const resource = await acquire(signal);
+            try {
+                const innerTask = use(resource);
+                return signal
+                    ? await innerTask.withSignal(signal).run()
+                    : await innerTask.run();
+            }
+            finally {
+                await release(resource);
+            }
+        });
+    }
+    runWithSignal(signal) {
+        if (!signal) {
+            return this.runTask();
+        }
+        if (signal.aborted) {
+            return Promise.reject(signal.reason ?? new Error("Task aborted"));
+        }
+        let onAbort;
+        const abortPromise = new Promise((_, reject) => {
+            onAbort = () => {
+                signal.removeEventListener("abort", onAbort);
+                reject(signal.reason ?? new Error("Task aborted"));
+            };
+            signal.addEventListener("abort", onAbort, {
+                once: true,
+            });
+        });
+        return Promise.race([this.runTask(signal), abortPromise]).finally(() => {
+            if (onAbort) {
+                signal.removeEventListener("abort", onAbort);
+            }
+        });
+    }
+    delayWithSignal(ms, signal) {
+        if (!signal) {
+            return new Promise((resolve) => setTimeout(resolve, ms));
+        }
+        if (signal.aborted) {
+            return Promise.reject(signal.reason ?? new Error("Task aborted"));
+        }
+        let timeoutId;
+        let onAbort;
+        const sleepPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(resolve, ms);
+        });
+        const abortPromise = new Promise((_, reject) => {
+            onAbort = () => {
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
+                signal.removeEventListener("abort", onAbort);
+                reject(signal.reason ?? new Error("Task aborted"));
+            };
+            signal.addEventListener("abort", onAbort, {
+                once: true,
+            });
+        });
+        return Promise.race([sleepPromise, abortPromise]).finally(() => {
+            if (onAbort) {
+                signal.removeEventListener("abort", onAbort);
+            }
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+        });
+    }
+    mergeSignals(outer, inner) {
+        if (!inner) {
+            return { signal: outer, cleanup: () => { } };
+        }
+        if (outer.aborted) {
+            return { signal: outer, cleanup: () => { } };
+        }
+        if (inner.aborted) {
+            return { signal: inner, cleanup: () => { } };
+        }
+        return Task.mergeExternalSignals(outer, inner);
+    }
+    static mergeExternalSignals(outer, inner) {
+        if (outer.aborted) {
+            return { signal: outer, cleanup: () => { } };
+        }
+        if (inner.aborted) {
+            return { signal: inner, cleanup: () => { } };
+        }
+        const controller = new AbortController();
+        const onOuterAbort = () => controller.abort(outer.reason);
+        const onInnerAbort = () => controller.abort(inner.reason);
+        outer.addEventListener("abort", onOuterAbort, { once: true });
+        inner.addEventListener("abort", onInnerAbort, { once: true });
+        return {
+            signal: controller.signal,
+            cleanup: () => {
+                outer.removeEventListener("abort", onOuterAbort);
+                inner.removeEventListener("abort", onInnerAbort);
+            },
+        };
+    }
+}

package/esm/anabranch/streams/util.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Thrown by {@link Stream.collect} and {@link Stream.fold} when one or more
+ * error results were collected during stream processing.
+ */
+export declare class AggregateError extends Error {
+    errors: unknown[];
+    /** The errors collected during stream processing. */
+    constructor(errors: unknown[]);
+}
+/**
+ * A result emitted by a {@link Stream}. Either a successful value or a
+ * collected error.
+ */
+export type Result<T, E> = E extends never ? SuccessResult<T, E> : T extends never ? ErrorResult<T, E> : SuccessResult<T, E> | ErrorResult<T, E>;
+/**
+ * A value that is either already resolved or a `Promise` that resolves to it. Used throughout the API to allow callbacks to be synchronous or asynchronous.
+ */
+export type Promisable<T> = T | Promise<T>;
+/**
+ * An error result emitted by a {@link Stream}.
+ */
+export type ErrorResult<_T, E> = {
+    type: "error";
+    error: E;
+};
+/**
+ * A successful result emitted by a {@link Stream}.
+ */
+export type SuccessResult<T, _E> = {
+    type: "success";
+    value: T;
+};
+//# sourceMappingURL=util.d.ts.map

package/esm/anabranch/streams/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/anabranch/streams/util.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,cAAe,SAAQ,KAAK;IAEpB,MAAM,EAAE,OAAO,EAAE;IADpC,qDAAqD;gBAClC,MAAM,EAAE,OAAO,EAAE;CAMrC;AAED;;;GAGG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,KAAK,GAAG,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5D,CAAC,SAAS,KAAK,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACnC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE3C;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,EAAE,CAAC,IAAI;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,EAAE,IAAI;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC"}

package/esm/anabranch/streams/util.js

@@ -0,0 +1,18 @@
+/**
+ * Thrown by {@link Stream.collect} and {@link Stream.fold} when one or more
+ * error results were collected during stream processing.
+ */
+export class AggregateError extends Error {
+    /** The errors collected during stream processing. */
+    constructor(errors) {
+        super(`AggregateError: ${errors.length} errors`);
+        Object.defineProperty(this, "errors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: errors
+        });
+        this.name = "AggregateError";
+        this.errors = errors;
+    }
+}

package/esm/fs/dir.d.ts

@@ -0,0 +1,17 @@
+import { Source } from "../anabranch/index.js";
+import type { DirEntry, GlobOptions, WalkEntry, WalkOptions } from "./types.js";
+import { type NotDirectory, type NotFound, type PermissionDenied, type Unknown } from "./errors.js";
+/**
+ * Lists the immediate children of a directory.
+ */
+export declare function readDir(path: string | URL): Source<DirEntry, DirError>;
+/**
+ * Recursively walks a directory tree, yielding each entry.
+ */
+export declare function walk(root: string | URL, options?: WalkOptions): Source<WalkEntry, DirError>;
+/**
+ * Finds all entries under `root` whose relative path matches the glob `pattern`.
+ */
+export declare function glob(root: string | URL, pattern: string, options?: GlobOptions): Source<WalkEntry, DirError>;
+export type DirError = NotFound | NotDirectory | PermissionDenied | Unknown;
+//# sourceMappingURL=dir.d.ts.map

package/esm/fs/dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dir.d.ts","sourceRoot":"","sources":["../../src/fs/dir.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE/C,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,OAAO,EACb,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAgBtE;AAED;;GAEG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CA6D7B;AAED;;GAEG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAG7B;AAED,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,YAAY,GAAG,gBAAgB,GAAG,OAAO,CAAC"}