@nlozgachev/pipekit 0.1.8 → 0.3.0

package/esm/src/Core/Task.js

@@ -1,26 +1,23 @@
+import { Result } from "./Result.js";
 export var Task;
 (function (Task) {
     /**
-     * Wraps a value in a Task that immediately resolves to that value.
+     * Creates a Task that immediately resolves to the given value.
      *
      * @example
      * ```ts
-     * const task = Task.of(42);
+     * const task = Task.resolve(42);
      * task().then(console.log); // 42
      * ```
      */
-    Task.of = (value) => () => Promise.resolve(value);
-    /**
-     * Creates a Task that will reject with the given error.
-     */
-    Task.fail = (error) => () => Promise.reject(error);
+    Task.resolve = (value) => () => Promise.resolve(value);
     /**
      * Creates a Task from a function that returns a Promise.
      * Alias for directly creating a Task.
      *
      * @example
      * ```ts
-     * const fetchUser = Task.from(() => fetch('/user').then(r => r.json()));
+     * const getTimestamp = Task.from(() => Promise.resolve(Date.now()));
      * ```
      */
     Task.from = (f) => f;
@@ -30,24 +27,24 @@ export var Task;
      * @example
      * ```ts
      * pipe(
-     *   Task.of(5),
+     *   Task.resolve(5),
      *   Task.map(n => n * 2)
      * )(); // Promise<10>
      * ```
      */
     Task.map = (f) => (data) => () => data().then(f);
     /**
-     * Chains Task computations. If the first succeeds, passes the value to f.
+     * Chains Task computations. Passes the resolved value of the first Task to f.
      *
      * @example
      * ```ts
-     * const fetchUser = (id: string): Task<User> => () => fetch(`/users/${id}`).then(r => r.json());
-     * const fetchPosts = (user: User): Task<Post[]> => () => fetch(`/posts?userId=${user.id}`).then(r => r.json());
+     * const readUserId: Task<string> = () => Promise.resolve(session.userId);
+     * const loadPrefs = (id: string): Task<Preferences> => () => Promise.resolve(prefsCache.get(id));
      *
      * pipe(
-     *   fetchUser("123"),
-     *   Task.chain(fetchPosts)
-     * )(); // Promise<Post[]>
+     *   readUserId,
+     *   Task.chain(loadPrefs)
+     * )(); // Promise<Preferences>
      * ```
      */
     Task.chain = (f) => (data) => () => data().then((a) => f(a)());
@@ -59,9 +56,9 @@ export var Task;
      * ```ts
      * const add = (a: number) => (b: number) => a + b;
      * pipe(
-     *   Task.of(add),
-     *   Task.ap(Task.of(5)),
-     *   Task.ap(Task.of(3))
+     *   Task.resolve(add),
+     *   Task.ap(Task.resolve(5)),
+     *   Task.ap(Task.resolve(3))
      * )(); // Promise<8>
      * ```
      */
@@ -73,9 +70,9 @@ export var Task;
      * @example
      * ```ts
      * pipe(
-     *   fetchData,
-     *   Task.tap(data => console.log("Fetched:", data)),
-     *   Task.map(transform)
+     *   loadConfig,
+     *   Task.tap(cfg => console.log("Config:", cfg)),
+     *   Task.map(buildReport)
      * );
      * ```
      */
@@ -88,21 +85,95 @@ export var Task;
      *
      * @example
      * ```ts
-     * Task.all([fetchUser, fetchPosts, fetchComments])();
-     * // Promise<[User, Post[], Comment[]]>
+     * Task.all([loadConfig, detectLocale, loadTheme])();
+     * // Promise<[Config, string, Theme]>
      * ```
      */
     Task.all = (tasks) => () => Promise.all(tasks.map((t) => t()));
     /**
      * Delays the execution of a Task by the specified milliseconds.
+     * Useful for debouncing or rate limiting.
      *
      * @example
      * ```ts
      * pipe(
-     *   Task.of(42),
+     *   Task.resolve(42),
      *   Task.delay(1000)
      * )(); // Resolves after 1 second
      * ```
      */
     Task.delay = (ms) => (data) => () => new Promise((resolve, reject) => setTimeout(() => data().then(resolve, reject), 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) => () => {
+        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) => 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) => () => {
+        const { when: predicate, delay: ms } = options;
+        const wait = () => ms !== undefined && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
+        const run = () => 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) => () => {
+        let timerId;
+        return Promise.race([
+            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

@@ -5,19 +5,19 @@ export var TaskOption;
     /**
      * Wraps a value in a Some inside a Task.
      */
-    TaskOption.of = (value) => Task.of(Option.of(value));
+    TaskOption.some = (value) => Task.resolve(Option.some(value));
     /**
      * Creates a TaskOption that resolves to None.
      */
-    TaskOption.none = () => Task.of(Option.toNone());
+    TaskOption.none = () => Task.resolve(Option.none());
     /**
      * Lifts an Option into a TaskOption.
      */
-    TaskOption.fromOption = (option) => Task.of(option);
+    TaskOption.fromOption = (option) => Task.resolve(option);
     /**
      * Lifts a Task into a TaskOption by wrapping its result in Some.
      */
-    TaskOption.fromTask = (task) => Task.map(Option.of)(task);
+    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.
@@ -29,7 +29,9 @@ export var TaskOption;
      * );
      * ```
      */
-    TaskOption.tryCatch = (f) => () => f().then(Option.of).catch(() => Option.toNone());
+    TaskOption.tryCatch = (f) => () => f()
+        .then(Option.some)
+        .catch(() => Option.none());
     /**
      * Transforms the value inside a TaskOption.
      */
@@ -46,7 +48,7 @@ export var TaskOption;
      * )();
      * ```
      */
-    TaskOption.chain = (f) => (data) => Task.chain((option) => Option.isSome(option) ? f(option.value) : Task.of(Option.toNone()))(data);
+    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.

package/esm/src/Core/TaskResult.js

@@ -5,11 +5,11 @@ export var TaskResult;
     /**
      * Wraps a value in a successful TaskResult.
      */
-    TaskResult.of = (value) => Task.of(Result.toOk(value));
+    TaskResult.ok = (value) => Task.resolve(Result.ok(value));
     /**
      * Creates a failed TaskResult with the given error.
      */
-    TaskResult.fail = (error) => Task.of(Result.toErr(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.
@@ -24,8 +24,8 @@ export var TaskResult;
      * ```
      */
     TaskResult.tryCatch = (f, onError) => () => f()
-        .then(Result.toOk)
-        .catch((e) => Result.toErr(onError(e)));
+        .then(Result.ok)
+        .catch((e) => Result.err(onError(e)));
     /**
      * Transforms the success value inside a TaskResult.
      */
@@ -38,7 +38,7 @@ export var TaskResult;
      * 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.of(Result.toErr(result.error)))(data);
+    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.
      */
@@ -50,7 +50,7 @@ export var TaskResult;
     /**
      * Recovers from an error by providing a fallback TaskResult.
      */
-    TaskResult.recover = (fallback) => (data) => Task.chain((result) => Result.isErr(result) ? fallback(result.error) : Task.of(result))(data);
+    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.
      */
@@ -60,4 +60,65 @@ export var 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) => () => {
+        const { attempts, backoff, when: shouldRetry } = options;
+        const getDelay = (n) => backoff === undefined ? 0 : typeof backoff === "function" ? backoff(n) : backoff;
+        const run = (left) => 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) => () => {
+        let timerId;
+        return Promise.race([
+            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

@@ -5,15 +5,19 @@ export var TaskValidation;
     /**
      * Wraps a value in a valid TaskValidation.
      */
-    TaskValidation.of = (value) => Task.of(Validation.of(value));
+    TaskValidation.valid = (value) => Task.resolve(Validation.valid(value));
     /**
      * Creates a failed TaskValidation with a single error.
      */
-    TaskValidation.fail = (error) => Task.of(Validation.fail(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.of(validation);
+    TaskValidation.fromValidation = (validation) => Task.resolve(validation);
     /**
      * Creates a TaskValidation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
@@ -28,8 +32,8 @@ export var TaskValidation;
      * ```
      */
     TaskValidation.tryCatch = (f, onError) => () => f()
-        .then((Validation.of))
-        .catch((e) => Validation.fail(onError(e)));
+        .then((Validation.valid))
+        .catch((e) => Validation.invalid(onError(e)));
     /**
      * Transforms the success value inside a TaskValidation.
      */
@@ -42,7 +46,7 @@ export var TaskValidation;
      */
     TaskValidation.chain = (f) => (data) => Task.chain((validation) => Validation.isValid(validation)
         ? f(validation.value)
-        : Task.of(Validation.toInvalid(validation.errors)))(data);
+        : Task.resolve(Validation.invalidAll(validation.errors)))(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
@@ -51,7 +55,7 @@ export var TaskValidation;
      * @example
      * ```ts
      * pipe(
-     *   TaskValidation.of((name: string) => (age: number) => ({ name, age })),
+     *   TaskValidation.valid((name: string) => (age: number) => ({ name, age })),
      *   TaskValidation.ap(validateName(name)),
      *   TaskValidation.ap(validateAge(age))
      * )();
@@ -89,5 +93,5 @@ export var TaskValidation;
     /**
      * Recovers from an Invalid state by providing a fallback TaskValidation.
      */
-    TaskValidation.recover = (fallback) => (data) => Task.chain((validation) => Validation.isValid(validation) ? Task.of(validation) : fallback())(data);
+    TaskValidation.recover = (fallback) => (data) => Task.chain((validation) => Validation.isValid(validation) ? Task.resolve(validation) : fallback())(data);
 })(TaskValidation || (TaskValidation = {}));

package/esm/src/Core/These.js

@@ -2,32 +2,32 @@ import { Result } from "./Result.js";
 export var These;
 (function (These) {
     /**
-     * Creates a These holding only an error/warning (no success value).
+     * Creates a These holding only a success value (no error).
      *
      * @example
      * ```ts
-     * These.toErr("Something went wrong");
+     * These.ok(42);
      * ```
      */
-    These.toErr = (error) => Result.toErr(error);
+    These.ok = (value) => Result.ok(value);
     /**
-     * Creates a These holding only a success value (no error).
+     * Creates a These holding only an error/warning (no success value).
      *
      * @example
      * ```ts
-     * These.toOk(42);
+     * These.err("Something went wrong");
      * ```
      */
-    These.toOk = (value) => Result.toOk(value);
+    These.err = (error) => Result.err(error);
     /**
      * Creates a These holding both an error/warning and a success value.
      *
      * @example
      * ```ts
-     * These.toBoth("Deprecated API used", result);
+     * These.both("Deprecated API used", result);
      * ```
      */
-    These.toBoth = (error, value) => ({
+    These.both = (error, value) => ({
         kind: "Both",
         error,
         value,
@@ -57,33 +57,33 @@ export var These;
      *
      * @example
      * ```ts
-     * pipe(These.toOk(5), These.map(n => n * 2));          // Ok(10)
-     * pipe(These.toBoth("warn", 5), These.map(n => n * 2)); // Both("warn", 10)
-     * pipe(These.toErr("err"), These.map(n => n * 2));      // Err("err")
+     * pipe(These.ok(5), These.map(n => n * 2));          // Ok(10)
+     * pipe(These.both("warn", 5), These.map(n => n * 2)); // Both("warn", 10)
+     * pipe(These.err("err"), These.map(n => n * 2));      // Err("err")
      * ```
      */
     These.map = (f) => (data) => {
         if (These.isErr(data))
             return data;
         if (These.isOk(data))
-            return These.toOk(f(data.value));
-        return These.toBoth(data.error, f(data.value));
+            return These.ok(f(data.value));
+        return These.both(data.error, f(data.value));
     };
     /**
      * Transforms the error/warning value, leaving the success value unchanged.
      *
      * @example
      * ```ts
-     * pipe(These.toErr("err"), These.mapErr(e => e.toUpperCase()));         // Err("ERR")
-     * pipe(These.toBoth("warn", 5), These.mapErr(e => e.toUpperCase()));    // Both("WARN", 5)
+     * pipe(These.err("err"), These.mapErr(e => e.toUpperCase()));         // Err("ERR")
+     * pipe(These.both("warn", 5), These.mapErr(e => e.toUpperCase()));    // Both("WARN", 5)
      * ```
      */
     These.mapErr = (f) => (data) => {
         if (These.isOk(data))
             return data;
         if (These.isErr(data))
-            return These.toErr(f(data.error));
-        return These.toBoth(f(data.error), data.value);
+            return These.err(f(data.error));
+        return These.both(f(data.error), data.value);
     };
     /**
      * Transforms both the error and success values independently.
@@ -91,17 +91,17 @@ export var These;
      * @example
      * ```ts
      * pipe(
-     *   These.toBoth("warn", 5),
+     *   These.both("warn", 5),
      *   These.bimap(e => e.toUpperCase(), n => n * 2)
      * ); // Both("WARN", 10)
      * ```
      */
     These.bimap = (onErr, onOk) => (data) => {
         if (These.isErr(data))
-            return These.toErr(onErr(data.error));
+            return These.err(onErr(data.error));
         if (These.isOk(data))
-            return These.toOk(onOk(data.value));
-        return These.toBoth(onErr(data.error), onOk(data.value));
+            return These.ok(onOk(data.value));
+        return These.both(onErr(data.error), onOk(data.value));
     };
     /**
      * Chains These computations by passing the success value to f.
@@ -112,11 +112,11 @@ export var These;
      *
      * @example
      * ```ts
-     * const double = (n: number): These<string, number> => These.toOk(n * 2);
+     * const double = (n: number): These<string, number> => These.ok(n * 2);
      *
-     * pipe(These.toOk(5), These.chain(double));           // Ok(10)
-     * pipe(These.toBoth("warn", 5), These.chain(double)); // Both("warn", 10)
-     * pipe(These.toErr("err"), These.chain(double));      // Err("err")
+     * pipe(These.ok(5), These.chain(double));           // Ok(10)
+     * pipe(These.both("warn", 5), These.chain(double)); // Both("warn", 10)
+     * pipe(These.err("err"), These.chain(double));      // Err("err")
      * ```
      */
     These.chain = (f) => (data) => {
@@ -125,7 +125,7 @@ export var These;
         if (These.isOk(data))
             return f(data.value);
         const result = f(data.value);
-        return These.isOk(result) ? These.toBoth(data.error, result.value) : result;
+        return These.isOk(result) ? These.both(data.error, result.value) : result;
     };
     /**
      * Extracts a value from a These by providing handlers for all three cases.
@@ -176,9 +176,9 @@ export var These;
      *
      * @example
      * ```ts
-     * pipe(These.toOk(5), These.getOrElse(0));           // 5
-     * pipe(These.toBoth("warn", 5), These.getOrElse(0)); // 5
-     * pipe(These.toErr("err"), These.getOrElse(0));      // 0
+     * pipe(These.ok(5), These.getOrElse(0));           // 5
+     * pipe(These.both("warn", 5), These.getOrElse(0)); // 5
+     * pipe(These.err("err"), These.getOrElse(0));      // 0
      * ```
      */
     These.getOrElse = (defaultValue) => (data) => These.hasValue(data) ? data.value : defaultValue;
@@ -199,17 +199,17 @@ export var These;
      *
      * @example
      * ```ts
-     * These.swap(These.toErr("err"));        // Ok("err")
-     * These.swap(These.toOk(5));             // Err(5)
-     * These.swap(These.toBoth("warn", 5));   // Both(5, "warn")
+     * These.swap(These.err("err"));        // Ok("err")
+     * These.swap(These.ok(5));             // Err(5)
+     * These.swap(These.both("warn", 5));   // Both(5, "warn")
      * ```
      */
     These.swap = (data) => {
         if (These.isErr(data))
-            return These.toOk(data.error);
+            return These.ok(data.error);
         if (These.isOk(data))
-            return These.toErr(data.value);
-        return These.toBoth(data.value, data.error);
+            return These.err(data.value);
+        return These.both(data.value, data.error);
     };
     /**
      * Converts a These to an Option.
@@ -217,9 +217,9 @@ export var These;
      *
      * @example
      * ```ts
-     * These.toOption(These.toOk(42));          // Some(42)
-     * These.toOption(These.toBoth("warn", 42)); // Some(42)
-     * These.toOption(These.toErr("err"));       // None
+     * These.toOption(These.ok(42));          // Some(42)
+     * These.toOption(These.both("warn", 42)); // Some(42)
+     * These.toOption(These.err("err"));       // None
      * ```
      */
     These.toOption = (data) => These.hasValue(data) ? { kind: "Some", value: data.value } : { kind: "None" };
@@ -229,14 +229,14 @@ export var These;
      *
      * @example
      * ```ts
-     * These.toResult(These.toOk(42));           // Ok(42)
-     * These.toResult(These.toBoth("warn", 42)); // Ok(42)
-     * These.toResult(These.toErr("err"));       // Err("err")
+     * These.toResult(These.ok(42));           // Ok(42)
+     * These.toResult(These.both("warn", 42)); // Ok(42)
+     * These.toResult(These.err("err"));       // Err("err")
      * ```
      */
     These.toResult = (data) => {
         if (These.hasValue(data))
-            return Result.toOk(data.value);
+            return Result.ok(data.value);
         return data;
     };
 })(These || (These = {}));