@nlozgachev/pipelined 0.6.4

package/esm/src/Core/RemoteData.js

@@ -0,0 +1,206 @@
+export var RemoteData;
+(function (RemoteData) {
+    /**
+     * Creates a NotAsked RemoteData.
+     */
+    RemoteData.notAsked = () => ({ kind: "NotAsked" });
+    /**
+     * Creates a Loading RemoteData.
+     */
+    RemoteData.loading = () => ({ kind: "Loading" });
+    /**
+     * Creates a Failure RemoteData with the given error.
+     */
+    RemoteData.failure = (error) => ({
+        kind: "Failure",
+        error,
+    });
+    /**
+     * Creates a Success RemoteData with the given value.
+     */
+    RemoteData.success = (value) => ({
+        kind: "Success",
+        value,
+    });
+    /**
+     * Type guard that checks if a RemoteData is NotAsked.
+     */
+    RemoteData.isNotAsked = (data) => data.kind === "NotAsked";
+    /**
+     * Type guard that checks if a RemoteData is Loading.
+     */
+    RemoteData.isLoading = (data) => data.kind === "Loading";
+    /**
+     * Type guard that checks if a RemoteData is Failure.
+     */
+    RemoteData.isFailure = (data) => data.kind === "Failure";
+    /**
+     * Type guard that checks if a RemoteData is Success.
+     */
+    RemoteData.isSuccess = (data) => data.kind === "Success";
+    /**
+     * Transforms the success value inside a RemoteData.
+     *
+     * @example
+     * ```ts
+     * pipe(RemoteData.success(5), RemoteData.map(n => n * 2)); // Success(10)
+     * pipe(RemoteData.loading(), RemoteData.map(n => n * 2)); // Loading
+     * ```
+     */
+    RemoteData.map = (f) => (data) => RemoteData.isSuccess(data) ? RemoteData.success(f(data.value)) : data;
+    /**
+     * Transforms the error value inside a RemoteData.
+     *
+     * @example
+     * ```ts
+     * pipe(RemoteData.failure("oops"), RemoteData.mapError(e => e.toUpperCase())); // Failure("OOPS")
+     * ```
+     */
+    RemoteData.mapError = (f) => (data) => RemoteData.isFailure(data) ? RemoteData.failure(f(data.error)) : data;
+    /**
+     * Chains RemoteData computations. If the input is Success, passes the value to f.
+     * Otherwise, propagates the current state.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   RemoteData.success(5),
+     *   RemoteData.chain(n => n > 0 ? RemoteData.success(n) : RemoteData.failure("negative"))
+     * );
+     * ```
+     */
+    RemoteData.chain = (f) => (data) => RemoteData.isSuccess(data) ? f(data.value) : data;
+    /**
+     * Applies a function wrapped in a RemoteData to a value wrapped in a RemoteData.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   RemoteData.success(add),
+     *   RemoteData.ap(RemoteData.success(5)),
+     *   RemoteData.ap(RemoteData.success(3))
+     * ); // Success(8)
+     * ```
+     */
+    RemoteData.ap = (arg) => (data) => {
+        if (RemoteData.isSuccess(data) && RemoteData.isSuccess(arg)) {
+            return RemoteData.success(data.value(arg.value));
+        }
+        if (RemoteData.isFailure(data))
+            return data;
+        if (RemoteData.isFailure(arg))
+            return arg;
+        if (RemoteData.isLoading(data) || RemoteData.isLoading(arg))
+            return RemoteData.loading();
+        return RemoteData.notAsked();
+    };
+    /**
+     * Extracts the value from a RemoteData by providing handlers for all four cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   userData,
+     *   RemoteData.fold(
+     *     () => "Not asked",
+     *     () => "Loading...",
+     *     e => `Error: ${e}`,
+     *     value => `Got: ${value}`
+     *   )
+     * );
+     * ```
+     */
+    RemoteData.fold = (onNotAsked, onLoading, onFailure, onSuccess) => (data) => {
+        switch (data.kind) {
+            case "NotAsked":
+                return onNotAsked();
+            case "Loading":
+                return onLoading();
+            case "Failure":
+                return onFailure(data.error);
+            case "Success":
+                return onSuccess(data.value);
+        }
+    };
+    /**
+     * Pattern matches on a RemoteData, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   userData,
+     *   RemoteData.match({
+     *     notAsked: () => "Click to load",
+     *     loading: () => "Loading...",
+     *     failure: e => `Error: ${e}`,
+     *     success: user => `Hello, ${user.name}!`
+     *   })
+     * );
+     * ```
+     */
+    RemoteData.match = (cases) => (data) => {
+        switch (data.kind) {
+            case "NotAsked":
+                return cases.notAsked();
+            case "Loading":
+                return cases.loading();
+            case "Failure":
+                return cases.failure(data.error);
+            case "Success":
+                return cases.success(data.value);
+        }
+    };
+    /**
+     * Returns the success value or a default value if the RemoteData is not Success.
+     *
+     * @example
+     * ```ts
+     * pipe(RemoteData.success(5), RemoteData.getOrElse(0)); // 5
+     * pipe(RemoteData.loading(), RemoteData.getOrElse(0)); // 0
+     * ```
+     */
+    RemoteData.getOrElse = (defaultValue) => (data) => RemoteData.isSuccess(data) ? data.value : defaultValue;
+    /**
+     * Executes a side effect on the success value without changing the RemoteData.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   RemoteData.success(5),
+     *   RemoteData.tap(n => console.log("Value:", n)),
+     *   RemoteData.map(n => n * 2)
+     * );
+     * ```
+     */
+    RemoteData.tap = (f) => (data) => {
+        if (RemoteData.isSuccess(data))
+            f(data.value);
+        return data;
+    };
+    /**
+     * Recovers from a Failure state by providing a fallback RemoteData.
+     */
+    RemoteData.recover = (fallback) => (data) => RemoteData.isFailure(data) ? fallback(data.error) : data;
+    /**
+     * Converts a RemoteData to an Option.
+     * Success becomes Some, all other states become None.
+     */
+    RemoteData.toOption = (data) => RemoteData.isSuccess(data) ? { kind: "Some", value: data.value } : { kind: "None" };
+    /**
+     * Converts a RemoteData to a Result.
+     * Success becomes Ok, Failure becomes Err.
+     * NotAsked and Loading become Err with the provided fallback error.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   RemoteData.success(42),
+     *   RemoteData.toResult(() => "not loaded")
+     * ); // Ok(42)
+     * ```
+     */
+    RemoteData.toResult = (onNotReady) => (data) => RemoteData.isSuccess(data)
+        ? { kind: "Ok", value: data.value }
+        : { kind: "Error", error: RemoteData.isFailure(data) ? data.error : onNotReady() };
+})(RemoteData || (RemoteData = {}));

package/esm/src/Core/Result.js

@@ -0,0 +1,164 @@
+export var Result;
+(function (Result) {
+    /**
+     * Creates a successful Result with the given value.
+     */
+    Result.ok = (value) => ({ kind: "Ok", value });
+    /**
+     * Creates a failed Result with the given error.
+     */
+    Result.err = (error) => ({ kind: "Error", error });
+    /**
+     * Type guard that checks if an Result is Ok.
+     */
+    Result.isOk = (data) => data.kind === "Ok";
+    /**
+     * Type guard that checks if an Result is Err.
+     */
+    Result.isErr = (data) => data.kind === "Error";
+    /**
+     * Creates an Result from a function that may throw.
+     * Catches any errors and transforms them using the onError function.
+     *
+     * @example
+     * ```ts
+     * const parseJson = (s: string): Result<string, unknown> =>
+     *   Result.tryCatch(
+     *     () => JSON.parse(s),
+     *     (e) => `Parse error: ${e}`
+     *   );
+     * ```
+     */
+    Result.tryCatch = (f, onError) => {
+        try {
+            return Result.ok(f());
+        }
+        catch (e) {
+            return Result.err(onError(e));
+        }
+    };
+    /**
+     * Transforms the success value inside an Result.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.ok(5), Result.map(n => n * 2)); // Ok(10)
+     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
+     * ```
+     */
+    Result.map = (f) => (data) => Result.isOk(data) ? Result.ok(f(data.value)) : data;
+    /**
+     * Transforms the error value inside an Result.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * ```
+     */
+    Result.mapError = (f) => (data) => Result.isErr(data) ? Result.err(f(data.error)) : data;
+    /**
+     * Chains Result computations. If the first is Ok, passes the value to f.
+     * If the first is Err, propagates the error.
+     *
+     * @example
+     * ```ts
+     * const validatePositive = (n: number): Result<string, number> =>
+     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
+     *
+     * pipe(Result.ok(5), Result.chain(validatePositive)); // Ok(5)
+     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
+     * ```
+     */
+    Result.chain = (f) => (data) => Result.isOk(data) ? f(data.value) : data;
+    /**
+     * Extracts the value from an Result by providing handlers for both cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.ok(5),
+     *   Result.fold(
+     *     e => `Error: ${e}`,
+     *     n => `Value: ${n}`
+     *   )
+     * ); // "Value: 5"
+     * ```
+     */
+    Result.fold = (onErr, onOk) => (data) => Result.isOk(data) ? onOk(data.value) : onErr(data.error);
+    /**
+     * Pattern matches on a Result, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   result,
+     *   Result.match({
+     *     ok: value => `Got ${value}`,
+     *     err: error => `Failed: ${error}`
+     *   })
+     * );
+     * ```
+     */
+    Result.match = (cases) => (data) => Result.isOk(data) ? cases.ok(data.value) : cases.err(data.error);
+    /**
+     * Returns the success value or a default value if the Result is an error.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.ok(5), Result.getOrElse(0)); // 5
+     * pipe(Result.err("error"), Result.getOrElse(0)); // 0
+     * ```
+     */
+    Result.getOrElse = (defaultValue) => (data) => Result.isOk(data) ? data.value : defaultValue;
+    /**
+     * Executes a side effect on the success value without changing the Result.
+     * Useful for logging or debugging.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Result.ok(5),
+     *   Result.tap(n => console.log("Value:", n)),
+     *   Result.map(n => n * 2)
+     * );
+     * ```
+     */
+    Result.tap = (f) => (data) => {
+        if (Result.isOk(data))
+            f(data.value);
+        return data;
+    };
+    /**
+     * Recovers from an error by providing a fallback Result.
+     */
+    Result.recover = (fallback) => (data) => Result.isOk(data) ? data : fallback();
+    /**
+     * Recovers from an error unless it matches the blocked error.
+     */
+    Result.recoverUnless = (blockedErr, fallback) => (data) => Result.isErr(data) && data.error !== blockedErr ? fallback() : data;
+    /**
+     * Converts a Result to an Option.
+     * Ok becomes Some, Err becomes None (the error is discarded).
+     *
+     * @example
+     * ```ts
+     * Result.toOption(Result.ok(42)); // Some(42)
+     * Result.toOption(Result.err("oops")); // None
+     * ```
+     */
+    Result.toOption = (data) => Result.isOk(data) ? { kind: "Some", value: data.value } : { kind: "None" };
+    /**
+     * Applies a function wrapped in an Result to a value wrapped in an Result.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Result.ok(add),
+     *   Result.ap(Result.ok(5)),
+     *   Result.ap(Result.ok(3))
+     * ); // Ok(8)
+     * ```
+     */
+    Result.ap = (arg) => (data) => Result.isOk(data) && Result.isOk(arg) ? Result.ok(data.value(arg.value)) : Result.isErr(data) ? data : arg;
+})(Result || (Result = {}));

package/esm/src/Core/Task.js

@@ -0,0 +1,187 @@
+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();
+    });
+    /**
+     * 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

@@ -0,0 +1,105 @@
+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.
+     */
+    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 = {}));