@nlozgachev/pipekit 0.1.8 → 0.3.0

package/script/src/Core/Result.js

@@ -4,22 +4,13 @@ exports.Result = void 0;
 var Result;
 (function (Result) {
     /**
-     * Wraps a value in a successful Result (Ok).
-     *
-     * @example
-     * ```ts
-     * Result.of(42); // Ok(42)
-     * ```
+     * Creates a successful Result with the given value.
      */
-    Result.of = (value) => Result.toOk(value);
+    Result.ok = (value) => ({ kind: "Ok", value });
     /**
      * Creates a failed Result with the given error.
      */
-    Result.toErr = (error) => ({ kind: "Error", error });
-    /**
-     * Creates a successful Result with the given value.
-     */
-    Result.toOk = (value) => ({ kind: "Ok", value });
+    Result.err = (error) => ({ kind: "Error", error });
     /**
      * Type guard that checks if an Result is Ok.
      */
@@ -43,10 +34,10 @@ var Result;
      */
     Result.tryCatch = (f, onError) => {
         try {
-            return Result.toOk(f());
+            return Result.ok(f());
         }
         catch (e) {
-            return Result.toErr(onError(e));
+            return Result.err(onError(e));
         }
     };
     /**
@@ -54,20 +45,20 @@ var Result;
      *
      * @example
      * ```ts
-     * pipe(Result.of(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.toErr("error"), Result.map(n => n * 2)); // Err("error")
+     * 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.toOk(f(data.value)) : data;
+    Result.map = (f) => (data) => Result.isOk(data) ? Result.ok(f(data.value)) : data;
     /**
      * Transforms the error value inside an Result.
      *
      * @example
      * ```ts
-     * pipe(Result.toErr("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
      * ```
      */
-    Result.mapError = (f) => (data) => Result.isErr(data) ? Result.toErr(f(data.error)) : data;
+    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.
@@ -75,10 +66,10 @@ var Result;
      * @example
      * ```ts
      * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.of(n) : Result.toErr("Must be positive");
+     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
      *
-     * pipe(Result.of(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.of(-1), Result.chain(validatePositive)); // 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;
@@ -88,7 +79,7 @@ var Result;
      * @example
      * ```ts
      * pipe(
-     *   Result.of(5),
+     *   Result.ok(5),
      *   Result.fold(
      *     e => `Error: ${e}`,
      *     n => `Value: ${n}`
@@ -117,8 +108,8 @@ var Result;
      *
      * @example
      * ```ts
-     * pipe(Result.of(5), Result.getOrElse(0)); // 5
-     * pipe(Result.toErr("error"), Result.getOrElse(0)); // 0
+     * 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;
@@ -129,7 +120,7 @@ var Result;
      * @example
      * ```ts
      * pipe(
-     *   Result.of(5),
+     *   Result.ok(5),
      *   Result.tap(n => console.log("Value:", n)),
      *   Result.map(n => n * 2)
      * );
@@ -154,8 +145,8 @@ var Result;
      *
      * @example
      * ```ts
-     * Result.toOption(Result.toOk(42)); // Some(42)
-     * Result.toOption(Result.toErr("oops")); // None
+     * 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" };
@@ -166,11 +157,11 @@ var Result;
      * ```ts
      * const add = (a: number) => (b: number) => a + b;
      * pipe(
-     *   Result.of(add),
-     *   Result.ap(Result.of(5)),
-     *   Result.ap(Result.of(3))
+     *   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.toOk(data.value(arg.value)) : Result.isErr(data) ? data : arg;
+    Result.ap = (arg) => (data) => Result.isOk(data) && Result.isOk(arg) ? Result.ok(data.value(arg.value)) : Result.isErr(data) ? data : arg;
 })(Result || (exports.Result = Result = {}));

package/script/src/Core/Task.js

@@ -1,29 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Task = void 0;
+const Result_js_1 = require("./Result.js");
 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;
@@ -33,24 +30,24 @@ 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)());
@@ -62,9 +59,9 @@ 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>
      * ```
      */
@@ -76,9 +73,9 @@ 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)
      * );
      * ```
      */
@@ -91,21 +88,95 @@ 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_js_1.Result.ok(a);
+            }),
+            new Promise((resolve) => {
+                timerId = setTimeout(() => resolve(Result_js_1.Result.err(onTimeout())), ms);
+            }),
+        ]);
+    };
 })(Task || (exports.Task = Task = {}));

package/script/src/Core/TaskOption.js

@@ -8,19 +8,19 @@ var TaskOption;
     /**
      * Wraps a value in a Some inside a Task.
      */
-    TaskOption.of = (value) => Task_js_1.Task.of(Option_js_1.Option.of(value));
+    TaskOption.some = (value) => Task_js_1.Task.resolve(Option_js_1.Option.some(value));
     /**
      * Creates a TaskOption that resolves to None.
      */
-    TaskOption.none = () => Task_js_1.Task.of(Option_js_1.Option.toNone());
+    TaskOption.none = () => Task_js_1.Task.resolve(Option_js_1.Option.none());
     /**
      * Lifts an Option into a TaskOption.
      */
-    TaskOption.fromOption = (option) => Task_js_1.Task.of(option);
+    TaskOption.fromOption = (option) => Task_js_1.Task.resolve(option);
     /**
      * Lifts a Task into a TaskOption by wrapping its result in Some.
      */
-    TaskOption.fromTask = (task) => Task_js_1.Task.map(Option_js_1.Option.of)(task);
+    TaskOption.fromTask = (task) => Task_js_1.Task.map(Option_js_1.Option.some)(task);
     /**
      * Creates a TaskOption from a Promise-returning function.
      * Returns Some if the promise resolves, None if it rejects.
@@ -32,7 +32,9 @@ var TaskOption;
      * );
      * ```
      */
-    TaskOption.tryCatch = (f) => () => f().then(Option_js_1.Option.of).catch(() => Option_js_1.Option.toNone());
+    TaskOption.tryCatch = (f) => () => f()
+        .then(Option_js_1.Option.some)
+        .catch(() => Option_js_1.Option.none());
     /**
      * Transforms the value inside a TaskOption.
      */
@@ -49,7 +51,7 @@ var TaskOption;
      * )();
      * ```
      */
-    TaskOption.chain = (f) => (data) => Task_js_1.Task.chain((option) => Option_js_1.Option.isSome(option) ? f(option.value) : Task_js_1.Task.of(Option_js_1.Option.toNone()))(data);
+    TaskOption.chain = (f) => (data) => Task_js_1.Task.chain((option) => Option_js_1.Option.isSome(option) ? f(option.value) : Task_js_1.Task.resolve(Option_js_1.Option.none()))(data);
     /**
      * Applies a function wrapped in a TaskOption to a value wrapped in a TaskOption.
      * Both Tasks run in parallel.

package/script/src/Core/TaskResult.js

@@ -8,11 +8,11 @@ var TaskResult;
     /**
      * Wraps a value in a successful TaskResult.
      */
-    TaskResult.of = (value) => Task_js_1.Task.of(Result_js_1.Result.toOk(value));
+    TaskResult.ok = (value) => Task_js_1.Task.resolve(Result_js_1.Result.ok(value));
     /**
      * Creates a failed TaskResult with the given error.
      */
-    TaskResult.fail = (error) => Task_js_1.Task.of(Result_js_1.Result.toErr(error));
+    TaskResult.err = (error) => Task_js_1.Task.resolve(Result_js_1.Result.err(error));
     /**
      * Creates a TaskResult from a function that may throw.
      * Catches any errors and transforms them using the onError function.
@@ -27,8 +27,8 @@ var TaskResult;
      * ```
      */
     TaskResult.tryCatch = (f, onError) => () => f()
-        .then(Result_js_1.Result.toOk)
-        .catch((e) => Result_js_1.Result.toErr(onError(e)));
+        .then(Result_js_1.Result.ok)
+        .catch((e) => Result_js_1.Result.err(onError(e)));
     /**
      * Transforms the success value inside a TaskResult.
      */
@@ -41,7 +41,7 @@ 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_js_1.Task.chain((result) => Result_js_1.Result.isOk(result) ? f(result.value) : Task_js_1.Task.of(Result_js_1.Result.toErr(result.error)))(data);
+    TaskResult.chain = (f) => (data) => Task_js_1.Task.chain((result) => Result_js_1.Result.isOk(result) ? f(result.value) : Task_js_1.Task.resolve(Result_js_1.Result.err(result.error)))(data);
     /**
      * Extracts the value from a TaskResult by providing handlers for both cases.
      */
@@ -53,7 +53,7 @@ var TaskResult;
     /**
      * Recovers from an error by providing a fallback TaskResult.
      */
-    TaskResult.recover = (fallback) => (data) => Task_js_1.Task.chain((result) => Result_js_1.Result.isErr(result) ? fallback(result.error) : Task_js_1.Task.of(result))(data);
+    TaskResult.recover = (fallback) => (data) => Task_js_1.Task.chain((result) => Result_js_1.Result.isErr(result) ? fallback(result.error) : Task_js_1.Task.resolve(result))(data);
     /**
      * Returns the success value or a default value if the TaskResult is an error.
      */
@@ -63,4 +63,65 @@ var TaskResult;
      * Useful for logging or debugging.
      */
     TaskResult.tap = (f) => (data) => Task_js_1.Task.map(Result_js_1.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_js_1.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_js_1.Result.err(onTimeout())), ms);
+            }),
+        ]);
+    };
 })(TaskResult || (exports.TaskResult = TaskResult = {}));

package/script/src/Core/TaskValidation.js

@@ -8,15 +8,19 @@ var TaskValidation;
     /**
      * Wraps a value in a valid TaskValidation.
      */
-    TaskValidation.of = (value) => Task_js_1.Task.of(Validation_js_1.Validation.of(value));
+    TaskValidation.valid = (value) => Task_js_1.Task.resolve(Validation_js_1.Validation.valid(value));
     /**
      * Creates a failed TaskValidation with a single error.
      */
-    TaskValidation.fail = (error) => Task_js_1.Task.of(Validation_js_1.Validation.fail(error));
+    TaskValidation.invalid = (error) => Task_js_1.Task.resolve(Validation_js_1.Validation.invalid(error));
+    /**
+     * Creates an invalid TaskValidation from multiple errors.
+     */
+    TaskValidation.invalidAll = (errors) => Task_js_1.Task.resolve(Validation_js_1.Validation.invalidAll(errors));
     /**
      * Lifts a Validation into a TaskValidation.
      */
-    TaskValidation.fromValidation = (validation) => Task_js_1.Task.of(validation);
+    TaskValidation.fromValidation = (validation) => Task_js_1.Task.resolve(validation);
     /**
      * Creates a TaskValidation from a Promise-returning function.
      * Catches any errors and transforms them using the onError function.
@@ -31,8 +35,8 @@ var TaskValidation;
      * ```
      */
     TaskValidation.tryCatch = (f, onError) => () => f()
-        .then((Validation_js_1.Validation.of))
-        .catch((e) => Validation_js_1.Validation.fail(onError(e)));
+        .then((Validation_js_1.Validation.valid))
+        .catch((e) => Validation_js_1.Validation.invalid(onError(e)));
     /**
      * Transforms the success value inside a TaskValidation.
      */
@@ -45,7 +49,7 @@ var TaskValidation;
      */
     TaskValidation.chain = (f) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation)
         ? f(validation.value)
-        : Task_js_1.Task.of(Validation_js_1.Validation.toInvalid(validation.errors)))(data);
+        : Task_js_1.Task.resolve(Validation_js_1.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
@@ -54,7 +58,7 @@ 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))
      * )();
@@ -92,5 +96,5 @@ var TaskValidation;
     /**
      * Recovers from an Invalid state by providing a fallback TaskValidation.
      */
-    TaskValidation.recover = (fallback) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation) ? Task_js_1.Task.of(validation) : fallback())(data);
+    TaskValidation.recover = (fallback) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation) ? Task_js_1.Task.resolve(validation) : fallback())(data);
 })(TaskValidation || (exports.TaskValidation = TaskValidation = {}));