@anabranch/fs 0.1.0

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

@@ -0,0 +1,431 @@
+import { type Promisable, type Result } from "./util.js";
+/**
+ * A TypeScript library that provides a powerful and flexible way to handle
+ * errors in asynchronous streams. It allows you to collect and manage errors
+ * alongside successful values in a stream, enabling you to process data while
+ * gracefully handling any issues that may arise.
+ *
+ * The core concept is the `Stream`, which is an asynchronous iterable that
+ * emits results as either successful values or errors. You can use various
+ * methods on the `Stream` to transform, filter, and reduce both successful
+ * values and errors in a way that suits your application's needs.
+ */
+export interface Stream<T, E> extends AsyncIterable<Result<T, E>> {
+    /**
+     * Similar to `Array.prototype.map`, but works on the stream of results. If the provided function throws an error or returns a rejected promise, the error will be collected and emitted as an error result in the stream.
+     *
+     * When concurrency is greater than 1, results may be emitted out of order.
+     *
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const mappedStream = stream.map(async (value) => {
+     *   if (value === 2) {
+     *     throw new Error("Value cannot be 2");
+     *   }
+     *   return value * 2;
+     * });
+     * ```
+     * @see {@link Stream.mapErr}
+     */
+    map<U>(fn: (value: T) => Promisable<U>): Stream<U, E>;
+    /**
+     * Maps successful values with `fn` and transforms errors with `errFn`. Both
+     * receive the original value so you can contextualize the mapping.
+     *
+     * @example
+     * ```ts
+     * import { Source } from "anabranch";
+     *
+     * const stream = Source.from<number, Error>(async function* () {
+     *   yield 1;
+     *   throw new Error("failed");
+     *   yield 3;
+     * });
+     *
+     * const result = stream.tryMap(
+     *   (value) => value * 2,
+     *   (err, value) => new Error(`Failed on ${value}: ${err.message}`),
+     * );
+     * ```
+     *
+     * @see {@link Stream.map}
+     * @see {@link Stream.mapErr}
+     */
+    tryMap<U, F = never>(fn: (value: T) => Promisable<U>, errFn: (error: unknown, value: T) => Promisable<F>): Stream<U, E | F>;
+    /**
+     * Similar to `Array.prototype.flatMap`, but works on the stream of results. If the provided function throws an error or returns a rejected promise, the error will be collected and emitted as an error result in the stream.
+     *
+     * When concurrency is greater than 1, results may be emitted out of order.
+     *
+     * @example
+     * ```ts
+     * import { Source } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const flattened = stream.flatMap((value) => [value, value * 10]);
+     * ```
+     */
+    flatMap<U>(fn: (value: T) => Promisable<AsyncIterable<U> | Iterable<U>>): Stream<U, E>;
+    /**
+     * Similar to `Array.prototype.filter`, but works on the stream of results. If the provided function throws an error or returns a rejected promise, the error will be collected and emitted as an error result in the stream.
+     *
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const filteredStream = stream.filter(async (value) => {
+     *   if (value === 2) {
+     *     throw new Error("Value cannot be 2");
+     *   }
+     *   return value % 2 === 1;
+     * });
+     * ```
+     *
+     * @see {@link Stream.filterErr}
+     */
+    filter<U extends T>(fn: (value: T) => value is U): Stream<U, E>;
+    filter(fn: (value: T) => Promisable<boolean>): Stream<T, E>;
+    /**
+     * Runs a side-effect function on each successful value without transforming it. If the provided function throws an error or returns a rejected promise, the error will be collected and emitted as an error result in place of the original value.
+     *
+     * @example
+     * ```ts
+     * const stream = source.tap((value) => console.log("Got:", value));
+     * ```
+     */
+    tap(fn: (value: T) => Promisable<void>): Stream<T, E>;
+    /**
+     * Runs a side-effect function on each error without transforming it. If the provided function throws an error or returns a rejected promise, the new error replaces the original.
+     *
+     * @example
+     * ```ts
+     * const stream = source.tapErr((error) => console.error("Error:", error));
+     * ```
+     */
+    tapErr(fn: (error: E) => Promisable<void>): Stream<T, E>;
+    /**
+     * Limits the stream to at most `n` successful values. Errors pass through
+     * without counting against the limit. After `n` successes are yielded, the
+     * stream stops immediately (any pending errors from earlier in the pipeline
+     * may still be yielded before stopping).
+     *
+     * @example
+     * ```ts
+     * const first3 = source.take(3);
+     * ```
+     */
+    take(n: number): Stream<T, E>;
+    /**
+     * Yields successful values while the predicate returns true. Once the predicate returns false, iteration stops. Errors pass through until the stream is stopped. If the predicate throws, an error result is emitted and iteration stops.
+     *
+     * @example
+     * ```ts
+     * const belowTen = source.takeWhile((value) => value < 10);
+     * ```
+     */
+    takeWhile(fn: (value: T) => Promisable<boolean>): Stream<T, E>;
+    /**
+     * Similar to `Array.prototype.reduce`, but works on the stream of results. If the provided function throws an error or returns a rejected promise, the error will be collected and emitted as an error result in the stream.
+     *
+     * If any error results are present in the stream, they will be thrown as an
+     * `AggregateError` after the stream is exhausted. Use `filterErr(() => false)`
+     * upstream to explicitly drop errors if you want to fold only the successes.
+     *
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const sum = await stream.fold(async (acc, value) => {
+     *   if (value === 2) {
+     *     throw new Error("Value cannot be 2");
+     *   }
+     *   return acc + value;
+     * }, 0);
+     *
+     * console.log("Sum:", sum);
+     * ```
+     *
+     * @throws {AggregateError} If any error results were present in the stream.
+     * @see {@link Stream.foldErr}
+     */
+    fold<U>(fn: (acc: U, value: T) => Promisable<U>, initialValue: U): Promise<U>;
+    /**
+     * Like `fold` but emits the running accumulator after each successful value,
+     * allowing downstream operations to react to intermediate states.
+     *
+     * @example
+     * ```ts
+     * import { Source } from "anabranch";
+     *
+     * const stream = Source.from<number, Error>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     *   yield 3;
+     * });
+     *
+     * const scanned = stream.scan((sum, n) => sum + n, 0);
+     * // Emits: { type: "success", value: 1 }, { type: "success", value: 3 }, { type: "success", value: 6 }
+     * ```
+     * @see {@link Stream.fold}
+     */
+    scan<U>(fn: (acc: U, value: T) => Promisable<U>, initialValue: U): Stream<U, E>;
+    /**
+     * Similar to `Array.prototype.map`, but works on the stream of errors. If the provided function throws an error or returns a rejected promise, the new error will be collected and emitted as an error result in the stream.
+     *
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const mappedErrorStream = stream.mapErr(async (error) => {
+     *   return `Mapped error: ${error}`;
+     * });
+     * ```
+     *
+     * @see {@link Stream.map}
+     */
+    mapErr<F>(fn: (error: E) => Promisable<F>): Stream<T, F>;
+    /**
+     * Similar to `Array.prototype.filter`, but works on the stream of errors. If the provided function throws an error or returns a rejected promise, the error will be collected and emitted as an error result in the stream.
+     *
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const filteredErrorStream = stream.filterErr(async (error) => {
+     *   return error.includes("Value cannot be 2");
+     * });
+     * ```
+     * @see {@link Stream.filter}
+     */
+    filterErr<F extends E>(fn: (error: E) => error is F): Stream<T, F>;
+    filterErr(fn: (error: E) => Promisable<boolean>): Stream<T, E>;
+    /**
+     * Similar to `Array.prototype.reduce`, but works on the stream of errors. If the provided function throws an error or returns a rejected promise, the new error will be collected and emitted as an error result in the stream.
+     *
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const concatenatedErrors = await stream.foldErr(async (acc, error) => {
+     *   return `${acc}; ${error}`;
+     * }, "");
+     *
+     * console.log("Concatenated Errors:", concatenatedErrors);
+     * ```
+     * @see {@link Stream.fold}
+     */
+    foldErr<F>(fn: (acc: F, error: E) => Promisable<F>, initialValue: F): Promise<F>;
+    /**
+     * Recovers from specific error types by applying the provided function to transform them into successful values. This allows you to handle specific errors gracefully while still collecting other errors in the stream.
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, "aaaah!" | "eeeek!">(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const recoveredStream = stream.recoverWhen(e => e === "aaaah!" as const, e => 42);
+     * ```
+     */
+    recoverWhen<E2 extends E, U>(guard: (error: E) => error is E2, fn: (error: E2) => Promisable<U>): Stream<T | U, Exclude<E, E2>>;
+    /**
+     * Recovers from all errors by applying the provided function to transform them into successful values. This allows you to handle all errors gracefully while still collecting successful values in the stream.
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const recoveredStream = stream.recover(e => 0);
+     * ```
+     */
+    recover<U>(fn: (error: E) => Promisable<U>): Stream<T | U, never>;
+    /**
+     * Throws the specified error types if they are encountered in the stream. This allows you to handle specific errors immediately while continuing to process other errors.
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, "aaaah!" | "eeeek!">(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * const streamWithThrownErrors = stream.throwOn(e => e === "eeeek!");
+     *
+     * try {
+     *   for await (const value of streamWithThrownErrors.successes()) {
+     *     console.log("Value:", value);
+     *   }
+     * } catch (error) {
+     *   console.error("Caught error:", error); // This will catch "eeeek!" errors thrown by throwOn
+     * }
+     * ```
+     */
+    throwOn<E2 extends E>(guard: (error: E) => error is E2): Stream<T, Exclude<E, E2>>;
+    /**
+     * Returns an async iterable of all successful values emitted by the stream. If any errors were collected during the stream processing, they will be ignored in this iterable.
+     *
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * for await (const value of stream.successes()) {
+     *   console.log("Success:", value);
+     * }
+     * ```
+     */
+    successes(): AsyncIterable<T>;
+    /**
+     * Returns an async iterable of all errors collected during the stream processing. If any successful values were emitted during the stream processing, they will be ignored in this iterable.
+     *
+     * @example
+     * ```ts
+     * import { Stream } from "anabranch";
+     *
+     * const stream = Source.from<number, string>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     * });
+     *
+     * for await (const error of stream.errors()) {
+     *   console.error("Error:", error);
+     * }
+     * ```
+     */
+    errors(): AsyncIterable<E>;
+    /**
+     * Collects all successful values emitted by the stream into an array. If any
+     * errors were collected during the stream processing, they will be thrown as
+     * an `AggregateError` containing all collected errors.
+     *
+     * @throws {AggregateError} If any errors were collected during the stream processing.
+     */
+    collect(): Promise<T[]>;
+    /**
+     * Collects all results into separate `successes` and `errors` arrays. Unlike `collect()`, this never throws.
+     *
+     * @example
+     * ```ts
+     * const { successes, errors } = await source.partition();
+     * ```
+     */
+    partition(): Promise<{
+        successes: T[];
+        errors: E[];
+    }>;
+    /**
+     * Collects all results emitted by the stream into an array of `Result`
+     * objects, which can represent either successful values or errors. This
+     * method allows you to see the full outcome of the stream processing,
+     * including both successes and errors, without throwing an aggregate error.
+     */
+    toArray(): Promise<Result<T, E>[]>;
+    /**
+     * Collects consecutive successful values into fixed-size arrays. Errors pass
+     * through without breaking the current chunk.
+     *
+     * @example
+     * ```ts
+     * import { Source } from "anabranch";
+     *
+     * const stream = Source.from<number, Error>(async function* () {
+     *   yield 1;
+     *   yield 2;
+     *   yield 3;
+     *   yield 4;
+     *   yield 5;
+     * });
+     *
+     * const chunked = stream.chunks(2);
+     * // Emits: { type: "success", value: [1, 2] }, { type: "success", value: [3, 4] }, { type: "success", value: [5] }
+     * ```
+     */
+    chunks(size: number): Stream<T[], E>;
+    [Symbol.asyncIterator](): AsyncIterator<Result<T, E>>;
+}
+export declare class _StreamImpl<T, E> implements Stream<T, E> {
+    protected readonly source: () => AsyncGenerator<Result<T, E>>;
+    protected readonly concurrency: number;
+    protected readonly bufferSize: number;
+    constructor(source: () => AsyncGenerator<Result<T, E>>, concurrency?: number, bufferSize?: number);
+    toArray(): Promise<Result<T, E>[]>;
+    collect(): Promise<T[]>;
+    successes(): AsyncIterable<T>;
+    errors(): AsyncIterable<E>;
+    [Symbol.asyncIterator](): AsyncIterator<Result<T, E>>;
+    private transform;
+    private concurrentMap;
+    private concurrentTransform;
+    private sequentialMap;
+    private concurrentTryMap;
+    private concurrentFlatMap;
+    map<U>(fn: (value: T) => Promisable<U>): Stream<U, E>;
+    tryMap<U, F>(fn: (value: T) => Promisable<U>, errFn: (error: unknown, value: T) => Promisable<F>): Stream<U, E | F>;
+    flatMap<U>(fn: (value: T) => Promisable<AsyncIterable<U> | Iterable<U>>): Stream<U, E>;
+    filter(fn: (value: T) => Promisable<boolean>): Stream<T, E>;
+    tap(fn: (value: T) => Promisable<void>): Stream<T, E>;
+    tapErr(fn: (error: E) => Promisable<void>): Stream<T, E>;
+    take(n: number): Stream<T, E>;
+    takeWhile(fn: (value: T) => Promisable<boolean>): Stream<T, E>;
+    partition(): Promise<{
+        successes: T[];
+        errors: E[];
+    }>;
+    fold<U>(fn: (acc: U, value: T) => Promisable<U>, initialValue: U): Promise<U>;
+    scan<U>(fn: (acc: U, value: T) => Promisable<U>, initialValue: U): Stream<U, E>;
+    chunks(size: number): Stream<T[], E>;
+    mapErr<F>(fn: (error: E) => Promisable<F>): Stream<T, F>;
+    filterErr(fn: (error: E) => Promisable<boolean>): Stream<T, E>;
+    foldErr<F>(fn: (acc: F, error: E) => Promisable<F>, initialValue: F): Promise<F>;
+    recoverWhen<E2 extends E, U = T>(guard: (error: E) => error is E2, fn: (error: E2) => Promisable<U>): Stream<T | U, Exclude<E, E2>>;
+    recover<U>(fn: (error: E) => Promisable<U>): Stream<T | U, never>;
+    throwOn<E2 extends E>(guard: (error: E) => error is E2): Stream<T, Exclude<E, E2>>;
+}
+//# sourceMappingURL=stream.d.ts.map

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

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