@nlozgachev/pipelined 0.12.0 → 0.13.0

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 = {}));

package/esm/src/Core/TaskValidation.js

@@ -1,128 +0,0 @@
-import { Deferred } from "./Deferred.js";
-import { Task } from "./Task.js";
-import { Validation } from "./Validation.js";
-export var TaskValidation;
-(function (TaskValidation) {
-    /**
-     * Wraps a value in a valid TaskValidation.
-     */
-    TaskValidation.valid = (value) => Task.resolve(Validation.valid(value));
-    /**
-     * Creates a failed TaskValidation with a single error.
-     */
-    TaskValidation.invalid = (error) => Task.resolve(Validation.invalid(error));
-    /**
-     * Creates an invalid TaskValidation from multiple errors.
-     */
-    TaskValidation.invalidAll = (errors) => Task.resolve(Validation.invalidAll(errors));
-    /**
-     * Lifts a Validation into a TaskValidation.
-     */
-    TaskValidation.fromValidation = (validation) => Task.resolve(validation);
-    /**
-     * Creates a TaskValidation from a Promise-returning function.
-     * Catches any errors and transforms them using the onError function.
-     *
-     * @example
-     * ```ts
-     * const fetchUser = (id: string): TaskValidation<string, User> =>
-     *   TaskValidation.tryCatch(
-     *     () => fetch(`/users/${id}`).then(r => r.json()),
-     *     e => `Failed to fetch user: ${e}`
-     *   );
-     * ```
-     */
-    TaskValidation.tryCatch = (f, onError) => Task.from(() => f()
-        .then((Validation.valid))
-        .catch((e) => Validation.invalid(onError(e))));
-    /**
-     * Transforms the success value inside a TaskValidation.
-     */
-    TaskValidation.map = (f) => (data) => Task.map(Validation.map(f))(data);
-    /**
-     * Applies a function wrapped in a TaskValidation to a value wrapped in a
-     * TaskValidation. Both Tasks run in parallel and errors from both sides
-     * are accumulated.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   TaskValidation.valid((name: string) => (age: number) => ({ name, age })),
-     *   TaskValidation.ap(validateName(name)),
-     *   TaskValidation.ap(validateAge(age))
-     * )();
-     * ```
-     */
-    TaskValidation.ap = (arg) => (data) => Task.from(() => Promise.all([
-        Deferred.toPromise(data()),
-        Deferred.toPromise(arg()),
-    ]).then(([vf, va]) => Validation.ap(va)(vf)));
-    /**
-     * Extracts a value from a TaskValidation by providing handlers for both cases.
-     */
-    TaskValidation.fold = (onInvalid, onValid) => (data) => Task.map(Validation.fold(onInvalid, onValid))(data);
-    /**
-     * Pattern matches on a TaskValidation, returning a Task of the result.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   validateForm(input),
-     *   TaskValidation.match({
-     *     valid: data => save(data),
-     *     invalid: errors => showErrors(errors)
-     *   })
-     * )();
-     * ```
-     */
-    TaskValidation.match = (cases) => (data) => Task.map(Validation.match(cases))(data);
-    /**
-     * Returns the success value or a default value if the TaskValidation is invalid.
-     * The default can be a different type, widening the result to `Task<A | B>`.
-     */
-    TaskValidation.getOrElse = (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data);
-    /**
-     * Executes a side effect on the success value without changing the TaskValidation.
-     * Useful for logging or debugging.
-     */
-    TaskValidation.tap = (f) => (data) => Task.map(Validation.tap(f))(data);
-    /**
-     * Recovers from an Invalid state by providing a fallback TaskValidation.
-     * The fallback receives the accumulated error list so callers can inspect which errors occurred.
-     * The fallback can produce a different success type, widening the result to `TaskValidation<E, A | B>`.
-     */
-    TaskValidation.recover = (fallback) => (data) => Task.chain((validation) => Validation.isValid(validation) ? Task.resolve(validation) : fallback(validation.errors))(data);
-    /**
-     * Runs two TaskValidations concurrently and combines their results into a tuple.
-     * If both are Valid, returns Valid with both values. If either fails, accumulates
-     * errors from both sides.
-     *
-     * @example
-     * ```ts
-     * await TaskValidation.product(
-     *   validateName(form.name),
-     *   validateAge(form.age),
-     * )(); // Valid(["Alice", 30]) or Invalid([...errors])
-     * ```
-     */
-    TaskValidation.product = (first, second) => Task.from(() => Promise.all([
-        Deferred.toPromise(first()),
-        Deferred.toPromise(second()),
-    ]).then(([va, vb]) => Validation.product(va, vb)));
-    /**
-     * Runs all TaskValidations concurrently and collects results.
-     * If all are Valid, returns Valid with all values as an array.
-     * If any fail, returns Invalid with all accumulated errors.
-     *
-     * @example
-     * ```ts
-     * await TaskValidation.productAll([
-     *   validateName(form.name),
-     *   validateEmail(form.email),
-     *   validateAge(form.age),
-     * ])(); // Valid([name, email, age]) or Invalid([...all errors])
-     * ```
-     */
-    TaskValidation.productAll = (data) => Task.from(() => Promise.all(data.map((t) => Deferred.toPromise(t())))
-        .then((results) => Validation.productAll(results)));
-})(TaskValidation || (TaskValidation = {}));