@nlozgachev/pipelined 0.12.0 → 0.14.0

package/esm/src/Core/State.js

@@ -1,181 +0,0 @@
-export var State;
-(function (State) {
-    /**
-     * Lifts a pure value into a State computation. The state passes through unchanged.
-     *
-     * @example
-     * ```ts
-     * State.run(10)(State.resolve(42)); // [42, 10] — value 42, state unchanged
-     * ```
-     */
-    State.resolve = (value) => (s) => [value, s];
-    /**
-     * Produces the current state as the value, without modifying it.
-     *
-     * @example
-     * ```ts
-     * const readStack: State<string[], string[]> = State.get();
-     * State.run(["a", "b"])(readStack); // [["a", "b"], ["a", "b"]]
-     * ```
-     */
-    State.get = () => (s) => [s, s];
-    /**
-     * Reads a projection of the state without modifying it.
-     * Equivalent to `pipe(State.get(), State.map(f))` but more direct.
-     *
-     * @example
-     * ```ts
-     * type AppState = { count: number; label: string };
-     * const readCount: State<AppState, number> = State.gets(s => s.count);
-     * State.run({ count: 5, label: "x" })(readCount); // [5, { count: 5, label: "x" }]
-     * ```
-     */
-    State.gets = (f) => (s) => [f(s), s];
-    /**
-     * Replaces the current state with a new value. Produces no meaningful value.
-     *
-     * @example
-     * ```ts
-     * const reset: State<number, undefined> = State.put(0);
-     * State.run(99)(reset); // [undefined, 0]
-     * ```
-     */
-    State.put = (newState) => (_s) => [undefined, newState];
-    /**
-     * Applies a function to the current state to produce the next state.
-     * Produces no meaningful value.
-     *
-     * @example
-     * ```ts
-     * const push = (item: string): State<string[], undefined> =>
-     *   State.modify(stack => [...stack, item]);
-     *
-     * State.run(["a"])(push("b")); // [undefined, ["a", "b"]]
-     * ```
-     */
-    State.modify = (f) => (s) => [undefined, f(s)];
-    /**
-     * Transforms the value produced by a State computation.
-     * The state transformation is unchanged.
-     *
-     * @example
-     * ```ts
-     * const readLength: State<string[], number> = pipe(
-     *   State.get<string[]>(),
-     *   State.map(stack => stack.length),
-     * );
-     *
-     * State.run(["a", "b", "c"])(readLength); // [3, ["a", "b", "c"]]
-     * ```
-     */
-    State.map = (f) => (st) => (s) => {
-        const [a, s1] = st(s);
-        return [f(a), s1];
-    };
-    /**
-     * Sequences two State computations. The state output of the first is passed
-     * as the state input to the second.
-     *
-     * Data-last — the first computation is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const push = (item: string): State<string[], undefined> =>
-     *   State.modify(stack => [...stack, item]);
-     *
-     * const program = pipe(
-     *   push("a"),
-     *   State.chain(() => push("b")),
-     *   State.chain(() => State.get<string[]>()),
-     * );
-     *
-     * State.evaluate([])(program); // ["a", "b"]
-     * ```
-     */
-    State.chain = (f) => (st) => (s) => {
-        const [a, s1] = st(s);
-        return f(a)(s1);
-    };
-    /**
-     * Applies a function wrapped in a State to a value wrapped in a State.
-     * The function computation runs first; its output state is the input to the
-     * argument computation.
-     *
-     * @example
-     * ```ts
-     * const addCounted = (n: number) => (m: number) => n + m;
-     * const program = pipe(
-     *   State.resolve<number, typeof addCounted>(addCounted),
-     *   State.ap(State.gets((s: number) => s * 2)),
-     *   State.ap(State.gets((s: number) => s)),
-     * );
-     *
-     * State.evaluate(3)(program); // 6 + 3 = 9
-     * ```
-     */
-    State.ap = (arg) => (fn) => (s) => {
-        const [f, s1] = fn(s);
-        const [a, s2] = arg(s1);
-        return [f(a), s2];
-    };
-    /**
-     * Runs a side effect on the produced value without changing the State computation.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   State.get<number>(),
-     *   State.tap(n => console.log("current:", n)),
-     *   State.chain(() => State.modify(n => n + 1)),
-     * );
-     * ```
-     */
-    State.tap = (f) => (st) => (s) => {
-        const [a, s1] = st(s);
-        f(a);
-        return [a, s1];
-    };
-    /**
-     * Runs a State computation with an initial state, returning both the
-     * produced value and the final state as a pair.
-     *
-     * Data-last — the computation is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const program = pipe(
-     *   State.modify<number>(n => n + 1),
-     *   State.chain(() => State.get<number>()),
-     * );
-     *
-     * State.run(0)(program); // [1, 1]
-     * ```
-     */
-    State.run = (initialState) => (st) => st(initialState);
-    /**
-     * Runs a State computation with an initial state, returning only the
-     * produced value (discarding the final state).
-     *
-     * @example
-     * ```ts
-     * State.evaluate([])(pipe(
-     *   State.modify<string[]>(s => [...s, "x"]),
-     *   State.chain(() => State.get<string[]>()),
-     * )); // ["x"]
-     * ```
-     */
-    State.evaluate = (initialState) => (st) => st(initialState)[0];
-    /**
-     * Runs a State computation with an initial state, returning only the
-     * final state (discarding the produced value).
-     *
-     * @example
-     * ```ts
-     * State.execute(0)(pipe(
-     *   State.modify<number>(n => n + 10),
-     *   State.chain(() => State.modify<number>(n => n * 2)),
-     * )); // 20
-     * ```
-     */
-    State.execute = (initialState) => (st) => st(initialState)[1];
-})(State || (State = {}));

package/esm/src/Core/Task.js

@@ -1,223 +0,0 @@
-import { Deferred } from "./Deferred.js";
-import { Result } from "./Result.js";
-// Internal helper — not exported. Runs a Task and converts the result to a Promise
-// so that combinators can use Promise chaining (.then, Promise.all, Promise.race, etc.)
-// internally without leaking that primitive through the public API.
-const toPromise = (task) => Deferred.toPromise(task());
-export var Task;
-(function (Task) {
-    /**
-     * Creates a Task that immediately resolves to the given value.
-     *
-     * @example
-     * ```ts
-     * const task = Task.resolve(42);
-     * const value = await task(); // 42
-     * ```
-     */
-    Task.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
-    /**
-     * Creates a Task from a function that returns a Promise.
-     *
-     * @example
-     * ```ts
-     * const getTimestamp = Task.from(() => Promise.resolve(Date.now()));
-     * ```
-     */
-    Task.from = (f) => () => Deferred.fromPromise(f());
-    /**
-     * Transforms the value inside a Task.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve(5),
-     *   Task.map(n => n * 2)
-     * )(); // Deferred<10>
-     * ```
-     */
-    Task.map = (f) => (data) => Task.from(() => toPromise(data).then(f));
-    /**
-     * Chains Task computations. Passes the resolved value of the first Task to f.
-     *
-     * @example
-     * ```ts
-     * const readUserId: Task<string> = Task.resolve(session.userId);
-     * const loadPrefs = (id: string): Task<Preferences> =>
-     *   Task.resolve(prefsCache.get(id));
-     *
-     * pipe(
-     *   readUserId,
-     *   Task.chain(loadPrefs)
-     * )(); // Deferred<Preferences>
-     * ```
-     */
-    Task.chain = (f) => (data) => Task.from(() => toPromise(data).then((a) => toPromise(f(a))));
-    /**
-     * Applies a function wrapped in a Task to a value wrapped in a Task.
-     * Both Tasks run in parallel.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Task.resolve(add),
-     *   Task.ap(Task.resolve(5)),
-     *   Task.ap(Task.resolve(3))
-     * )(); // Deferred<8>
-     * ```
-     */
-    Task.ap = (arg) => (data) => Task.from(() => Promise.all([
-        toPromise(data),
-        toPromise(arg),
-    ]).then(([f, a]) => f(a)));
-    /**
-     * Executes a side effect on the value without changing the Task.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   loadConfig,
-     *   Task.tap(cfg => console.log("Config:", cfg)),
-     *   Task.map(buildReport)
-     * );
-     * ```
-     */
-    Task.tap = (f) => (data) => Task.from(() => toPromise(data).then((a) => {
-        f(a);
-        return a;
-    }));
-    /**
-     * Runs multiple Tasks in parallel and collects their results.
-     *
-     * @example
-     * ```ts
-     * Task.all([loadConfig, detectLocale, loadTheme])();
-     * // Deferred<[Config, string, Theme]>
-     * ```
-     */
-    Task.all = (tasks) => Task.from(() => Promise.all(tasks.map((t) => toPromise(t))));
-    /**
-     * Delays the execution of a Task by the specified milliseconds.
-     * Useful for debouncing or rate limiting.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Task.resolve(42),
-     *   Task.delay(1000)
-     * )(); // Resolves after 1 second
-     * ```
-     */
-    Task.delay = (ms) => (data) => Task.from(() => new Promise((resolve) => setTimeout(() => toPromise(data).then(resolve), ms)));
-    /**
-     * Runs a Task a fixed number of times sequentially, collecting all results into an array.
-     * An optional delay (ms) can be inserted between runs.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   pollSensor,
-     *   Task.repeat({ times: 5, delay: 1000 })
-     * )(); // Task<Reading[]> — 5 readings, one per second
-     * ```
-     */
-    Task.repeat = (options) => (task) => Task.from(() => {
-        const { times, delay: ms } = options;
-        if (times <= 0)
-            return Promise.resolve([]);
-        const results = [];
-        const wait = () => ms !== undefined && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-        const run = (left) => toPromise(task).then((a) => {
-            results.push(a);
-            if (left <= 1)
-                return results;
-            return wait().then(() => run(left - 1));
-        });
-        return run(times);
-    });
-    /**
-     * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-     * An optional delay (ms) can be inserted between runs.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   checkStatus,
-     *   Task.repeatUntil({ when: (s) => s === "ready", delay: 500 })
-     * )(); // polls every 500ms until status is "ready"
-     * ```
-     */
-    Task.repeatUntil = (options) => (task) => Task.from(() => {
-        const { when: predicate, delay: ms } = options;
-        const wait = () => ms !== undefined && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-        const run = () => toPromise(task).then((a) => {
-            if (predicate(a))
-                return a;
-            return wait().then(run);
-        });
-        return run();
-    });
-    /**
-     * Resolves with the value of the first Task to complete. All Tasks start
-     * immediately; the rest are abandoned once one resolves.
-     *
-     * @example
-     * ```ts
-     * const fast = Task.from(() => new Promise<string>(r => setTimeout(() => r("fast"), 10)));
-     * const slow = Task.from(() => new Promise<string>(r => setTimeout(() => r("slow"), 200)));
-     *
-     * await Task.race([fast, slow])(); // "fast"
-     * ```
-     */
-    Task.race = (tasks) => Task.from(() => Promise.race(tasks.map(toPromise)));
-    /**
-     * Runs an array of Tasks one at a time in order, collecting all results.
-     * Each Task starts only after the previous one resolves.
-     *
-     * @example
-     * ```ts
-     * let log: number[] = [];
-     * const makeTask = (n: number) => Task.from(() => {
-     *   log.push(n);
-     *   return Promise.resolve(n);
-     * });
-     *
-     * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
-     * // log = [1, 2, 3] — tasks ran in order
-     * ```
-     */
-    Task.sequential = (tasks) => Task.from(async () => {
-        const results = [];
-        for (const task of tasks) {
-            results.push(await toPromise(task));
-        }
-        return results;
-    });
-    /**
-     * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
-     * Task does not complete within the given time.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   heavyComputation,
-     *   Task.timeout(5000, () => "timed out"),
-     *   TaskResult.chain(processResult)
-     * );
-     * ```
-     */
-    Task.timeout = (ms, onTimeout) => (task) => Task.from(() => {
-        let timerId;
-        return Promise.race([
-            toPromise(task).then((a) => {
-                clearTimeout(timerId);
-                return Result.ok(a);
-            }),
-            new Promise((resolve) => {
-                timerId = setTimeout(() => resolve(Result.err(onTimeout())), ms);
-            }),
-        ]);
-    });
-})(Task || (Task = {}));

package/esm/src/Core/TaskOption.js

@@ -1,106 +0,0 @@
-import { Deferred } from "./Deferred.js";
-import { Option } from "./Option.js";
-import { Task } from "./Task.js";
-export var TaskOption;
-(function (TaskOption) {
-    /**
-     * Wraps a value in a Some inside a Task.
-     */
-    TaskOption.some = (value) => Task.resolve(Option.some(value));
-    /**
-     * Creates a TaskOption that resolves to None.
-     */
-    TaskOption.none = () => Task.resolve(Option.none());
-    /**
-     * Lifts an Option into a TaskOption.
-     */
-    TaskOption.fromOption = (option) => Task.resolve(option);
-    /**
-     * Lifts a Task into a TaskOption by wrapping its result in Some.
-     */
-    TaskOption.fromTask = (task) => Task.map(Option.some)(task);
-    /**
-     * Creates a TaskOption from a Promise-returning function.
-     * Returns Some if the promise resolves, None if it rejects.
-     *
-     * @example
-     * ```ts
-     * const fetchUser = TaskOption.tryCatch(() =>
-     *   fetch("/user/1").then(r => r.json())
-     * );
-     * ```
-     */
-    TaskOption.tryCatch = (f) => Task.from(() => f()
-        .then(Option.some)
-        .catch(() => Option.none()));
-    /**
-     * Transforms the value inside a TaskOption.
-     */
-    TaskOption.map = (f) => (data) => Task.map(Option.map(f))(data);
-    /**
-     * Chains TaskOption computations. If the first resolves to Some, passes the
-     * value to f. If the first resolves to None, propagates None.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   findUser("123"),
-     *   TaskOption.chain(user => findOrg(user.orgId))
-     * )();
-     * ```
-     */
-    TaskOption.chain = (f) => (data) => Task.chain((option) => Option.isSome(option) ? f(option.value) : Task.resolve(Option.none()))(data);
-    /**
-     * Applies a function wrapped in a TaskOption to a value wrapped in a TaskOption.
-     * Both Tasks run in parallel.
-     */
-    TaskOption.ap = (arg) => (data) => Task.from(() => Promise.all([
-        Deferred.toPromise(data()),
-        Deferred.toPromise(arg()),
-    ]).then(([of_, oa]) => Option.ap(oa)(of_)));
-    /**
-     * Extracts a value from a TaskOption by providing handlers for both cases.
-     */
-    TaskOption.fold = (onNone, onSome) => (data) => Task.map(Option.fold(onNone, onSome))(data);
-    /**
-     * Pattern matches on a TaskOption, returning a Task of the result.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   findUser("123"),
-     *   TaskOption.match({
-     *     some: user => `Hello, ${user.name}`,
-     *     none: () => "User not found"
-     *   })
-     * )();
-     * ```
-     */
-    TaskOption.match = (cases) => (data) => Task.map(Option.match(cases))(data);
-    /**
-     * Returns the value or a default if the TaskOption resolves to None.
-     * The default can be a different type, widening the result to `Task<A | B>`.
-     */
-    TaskOption.getOrElse = (defaultValue) => (data) => Task.map(Option.getOrElse(defaultValue))(data);
-    /**
-     * Executes a side effect on the value without changing the TaskOption.
-     * Useful for logging or debugging.
-     */
-    TaskOption.tap = (f) => (data) => Task.map(Option.tap(f))(data);
-    /**
-     * Filters the value inside a TaskOption. Returns None if the predicate fails.
-     */
-    TaskOption.filter = (predicate) => (data) => Task.map(Option.filter(predicate))(data);
-    /**
-     * Converts a TaskOption to a TaskResult, using onNone to produce the error value.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   findUser("123"),
-     *   TaskOption.toTaskResult(() => "User not found")
-     * );
-     * ```
-     */
-    TaskOption.toTaskResult = (onNone) => (data) => Task.map(Option.toResult(onNone))(data);
-})(TaskOption || (TaskOption = {}));

package/esm/src/Core/TaskResult.js

@@ -1,127 +0,0 @@
-import { Deferred } from "./Deferred.js";
-import { Result } from "./Result.js";
-import { Task } from "./Task.js";
-export var TaskResult;
-(function (TaskResult) {
-    /**
-     * Wraps a value in a successful TaskResult.
-     */
-    TaskResult.ok = (value) => Task.resolve(Result.ok(value));
-    /**
-     * Creates a failed TaskResult with the given error.
-     */
-    TaskResult.err = (error) => Task.resolve(Result.err(error));
-    /**
-     * Creates a TaskResult from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     *
-     * @example
-     * ```ts
-     * const parseJson = (s: string): TaskResult<string, unknown> =>
-     *   TaskResult.tryCatch(
-     *     async () => JSON.parse(s),
-     *     (e) => `Parse error: ${e}`
-     *   );
-     * ```
-     */
-    TaskResult.tryCatch = (f, onError) => Task.from(() => f()
-        .then(Result.ok)
-        .catch((e) => Result.err(onError(e))));
-    /**
-     * Transforms the success value inside a TaskResult.
-     */
-    TaskResult.map = (f) => (data) => Task.map(Result.map(f))(data);
-    /**
-     * Transforms the error value inside a TaskResult.
-     */
-    TaskResult.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
-    /**
-     * Chains TaskResult computations. If the first succeeds, passes the value to f.
-     * If the first fails, propagates the error.
-     */
-    TaskResult.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(data);
-    /**
-     * Extracts the value from a TaskResult by providing handlers for both cases.
-     */
-    TaskResult.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
-    /**
-     * Pattern matches on a TaskResult, returning a Task of the result.
-     */
-    TaskResult.match = (cases) => (data) => Task.map(Result.match(cases))(data);
-    /**
-     * Recovers from an error by providing a fallback TaskResult.
-     * The fallback can produce a different success type, widening the result to `TaskResult<E, A | B>`.
-     */
-    TaskResult.recover = (fallback) => (data) => Task.chain((result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result))(data);
-    /**
-     * Returns the success value or a default value if the TaskResult is an error.
-     * The default can be a different type, widening the result to `Task<A | B>`.
-     */
-    TaskResult.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
-    /**
-     * Executes a side effect on the success value without changing the TaskResult.
-     * Useful for logging or debugging.
-     */
-    TaskResult.tap = (f) => (data) => Task.map(Result.tap(f))(data);
-    /**
-     * Re-runs a TaskResult on `Err` with configurable attempts, backoff, and retry condition.
-     *
-     * @param options.attempts - Total number of attempts (1 = no retry, 3 = up to 3 tries)
-     * @param options.backoff - Fixed delay in ms, or a function `(attempt) => ms` for computed delay
-     * @param options.when - Only retry when this returns true; defaults to always retry on Err
-     *
-     * @example
-     * ```ts
-     * // Retry up to 3 times with exponential backoff
-     * pipe(
-     *   fetchUser,
-     *   TaskResult.retry({ attempts: 3, backoff: n => n * 1000 })
-     * );
-     *
-     * // Only retry on network errors, not auth errors
-     * pipe(
-     *   fetchUser,
-     *   TaskResult.retry({ attempts: 3, when: e => e instanceof NetworkError })
-     * );
-     * ```
-     */
-    TaskResult.retry = (options) => (data) => Task.from(() => {
-        const { attempts, backoff, when: shouldRetry } = options;
-        const getDelay = (n) => backoff === undefined ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
-        const run = (left) => Deferred.toPromise(data()).then((result) => {
-            if (Result.isOk(result))
-                return result;
-            if (left <= 1)
-                return result;
-            if (shouldRetry !== undefined && !shouldRetry(result.error)) {
-                return result;
-            }
-            const ms = getDelay(attempts - left + 1);
-            return (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve()).then(() => run(left - 1));
-        });
-        return run(attempts);
-    });
-    /**
-     * Fails a TaskResult with a typed error if it does not resolve within the given time.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   fetchUser,
-     *   TaskResult.timeout(5000, () => new TimeoutError("fetch user timed out"))
-     * );
-     * ```
-     */
-    TaskResult.timeout = (ms, onTimeout) => (data) => Task.from(() => {
-        let timerId;
-        return Promise.race([
-            Deferred.toPromise(data()).then((result) => {
-                clearTimeout(timerId);
-                return result;
-            }),
-            new Promise((resolve) => {
-                timerId = setTimeout(() => resolve(Result.err(onTimeout())), ms);
-            }),
-        ]);
-    });
-})(TaskResult || (TaskResult = {}));