@nlozgachev/pipekit 0.1.6

package/esm/src/Core/Rec.js

@@ -0,0 +1,167 @@
+import { Option } from "./Option.js";
+/**
+ * Functional record/object utilities that compose well with pipe.
+ * All functions are data-last and curried where applicable.
+ *
+ * @example
+ * ```ts
+ * pipe(
+ *   { a: 1, b: 2, c: 3 },
+ *   Rec.filter(n => n > 1),
+ *   Rec.map(n => n * 10)
+ * ); // { b: 20, c: 30 }
+ * ```
+ */
+export var Rec;
+(function (Rec) {
+    /**
+     * Transforms each value in a record.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.map(n => n * 2)); // { a: 2, b: 4 }
+     * ```
+     */
+    Rec.map = (f) => (data) => {
+        const result = {};
+        for (const key of Object.keys(data)) {
+            result[key] = f(data[key]);
+        }
+        return result;
+    };
+    /**
+     * Transforms each value in a record, also receiving the key.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.mapWithKey((k, v) => `${k}:${v}`));
+     * // { a: "a:1", b: "b:2" }
+     * ```
+     */
+    Rec.mapWithKey = (f) => (data) => {
+        const result = {};
+        for (const key of Object.keys(data)) {
+            result[key] = f(key, data[key]);
+        }
+        return result;
+    };
+    /**
+     * Filters values in a record by a predicate.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2, c: 3 }, Rec.filter(n => n > 1)); // { b: 2, c: 3 }
+     * ```
+     */
+    Rec.filter = (predicate) => (data) => {
+        const result = {};
+        for (const key of Object.keys(data)) {
+            if (predicate(data[key]))
+                result[key] = data[key];
+        }
+        return result;
+    };
+    /**
+     * Filters values in a record by a predicate that also receives the key.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.filterWithKey((k, v) => k !== "a" && v > 0));
+     * // { b: 2 }
+     * ```
+     */
+    Rec.filterWithKey = (predicate) => (data) => {
+        const result = {};
+        for (const key of Object.keys(data)) {
+            if (predicate(key, data[key]))
+                result[key] = data[key];
+        }
+        return result;
+    };
+    /**
+     * Looks up a value by key, returning Option.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.lookup("a")); // Some(1)
+     * pipe({ a: 1, b: 2 }, Rec.lookup("c")); // None
+     * ```
+     */
+    Rec.lookup = (key) => (data) => Object.prototype.hasOwnProperty.call(data, key) ? Option.toSome(data[key]) : Option.toNone();
+    /**
+     * Returns all keys of a record.
+     */
+    Rec.keys = (data) => Object.keys(data);
+    /**
+     * Returns all values of a record.
+     */
+    Rec.values = (data) => Object.values(data);
+    /**
+     * Returns all key-value pairs of a record.
+     */
+    Rec.entries = (data) => Object.entries(data);
+    /**
+     * Creates a record from key-value pairs.
+     *
+     * @example
+     * ```ts
+     * Rec.fromEntries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
+     * ```
+     */
+    Rec.fromEntries = (data) => Object.fromEntries(data);
+    /**
+     * Picks specific keys from a record.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2, c: 3 }, Rec.pick("a", "c")); // { a: 1, c: 3 }
+     * ```
+     */
+    Rec.pick = (...pickedKeys) => (data) => {
+        const result = {};
+        for (const key of pickedKeys) {
+            if (Object.prototype.hasOwnProperty.call(data, key)) {
+                result[key] = data[key];
+            }
+        }
+        return result;
+    };
+    /**
+     * Omits specific keys from a record.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2, c: 3 }, Rec.omit("b")); // { a: 1, c: 3 }
+     * ```
+     */
+    Rec.omit = (...omittedKeys) => (data) => {
+        const omitSet = new Set(omittedKeys);
+        const result = {};
+        for (const key of Object.keys(data)) {
+            if (!omitSet.has(key)) {
+                result[key] = data[key];
+            }
+        }
+        return result;
+    };
+    /**
+     * Merges two records. Values from the second record take precedence.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.merge({ b: 3, c: 4 })); // { a: 1, b: 3, c: 4 }
+     * ```
+     */
+    Rec.merge = (other) => (data) => ({
+        ...data,
+        ...other,
+    });
+    /**
+     * Returns true if the record has no keys.
+     */
+    Rec.isEmpty = (data) => Object.keys(data).length === 0;
+    /**
+     * Returns the number of keys in a record.
+     */
+    Rec.size = (data) => Object.keys(data).length;
+})(Rec || (Rec = {}));

package/esm/src/Core/RemoteData.js

@@ -0,0 +1,210 @@
+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,
+    });
+    /**
+     * Wraps a value in a Success RemoteData. Alias for `success`.
+     */
+    RemoteData.of = RemoteData.success;
+    /**
+     * 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.of(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.of(5),
+     *   RemoteData.chain(n => n > 0 ? RemoteData.of(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.of(add),
+     *   RemoteData.ap(RemoteData.of(5)),
+     *   RemoteData.ap(RemoteData.of(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.of(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.of(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.of(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,173 @@
+export var Result;
+(function (Result) {
+    /**
+     * Wraps a value in a successful Result (Ok).
+     *
+     * @example
+     * ```ts
+     * Result.of(42); // Ok(42)
+     * ```
+     */
+    Result.of = (value) => Result.toOk(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 });
+    /**
+     * 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.toOk(f());
+        }
+        catch (e) {
+            return Result.toErr(onError(e));
+        }
+    };
+    /**
+     * Transforms the success value inside an 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")
+     * ```
+     */
+    Result.map = (f) => (data) => Result.isOk(data) ? Result.toOk(f(data.value)) : data;
+    /**
+     * Transforms the error value inside an Result.
+     *
+     * @example
+     * ```ts
+     * pipe(Result.toErr("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * ```
+     */
+    Result.mapError = (f) => (data) => Result.isErr(data) ? Result.toErr(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.of(n) : Result.toErr("Must be positive");
+     *
+     * pipe(Result.of(5), Result.chain(validatePositive)); // Ok(5)
+     * pipe(Result.of(-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.of(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.of(5), Result.getOrElse(0)); // 5
+     * pipe(Result.toErr("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.of(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.toOk(42)); // Some(42)
+     * Result.toOption(Result.toErr("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.of(add),
+     *   Result.ap(Result.of(5)),
+     *   Result.ap(Result.of(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 || (Result = {}));

package/esm/src/Core/Task.js

@@ -0,0 +1,108 @@
+export var Task;
+(function (Task) {
+    /**
+     * Wraps a value in a Task that immediately resolves to that value.
+     *
+     * @example
+     * ```ts
+     * const task = Task.of(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);
+    /**
+     * 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()));
+     * ```
+     */
+    Task.from = (f) => f;
+    /**
+     * Transforms the value inside a Task.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.of(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.
+     *
+     * @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());
+     *
+     * pipe(
+     *   fetchUser("123"),
+     *   Task.chain(fetchPosts)
+     * )(); // Promise<Post[]>
+     * ```
+     */
+    Task.chain = (f) => (data) => () => data().then((a) => 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.of(add),
+     *   Task.ap(Task.of(5)),
+     *   Task.ap(Task.of(3))
+     * )(); // Promise<8>
+     * ```
+     */
+    Task.ap = (arg) => (data) => () => Promise.all([data(), 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(
+     *   fetchData,
+     *   Task.tap(data => console.log("Fetched:", data)),
+     *   Task.map(transform)
+     * );
+     * ```
+     */
+    Task.tap = (f) => (data) => () => data().then((a) => {
+        f(a);
+        return a;
+    });
+    /**
+     * Runs multiple Tasks in parallel and collects their results.
+     *
+     * @example
+     * ```ts
+     * Task.all([fetchUser, fetchPosts, fetchComments])();
+     * // Promise<[User, Post[], Comment[]]>
+     * ```
+     */
+    Task.all = (tasks) => () => Promise.all(tasks.map((t) => t()));
+    /**
+     * Delays the execution of a Task by the specified milliseconds.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Task.of(42),
+     *   Task.delay(1000)
+     * )(); // Resolves after 1 second
+     * ```
+     */
+    Task.delay = (ms) => (data) => () => new Promise((resolve, reject) => setTimeout(() => data().then(resolve, reject), ms));
+})(Task || (Task = {}));