@nlozgachev/pipekit 0.1.6

package/script/src/Core/Option.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Option = void 0;
+const Result_js_1 = require("./Result.js");
+var Option;
+(function (Option) {
+    /**
+     * Wraps a value in a Some.
+     *
+     * @example
+     * ```ts
+     * Option.of(42); // Some(42)
+     * ```
+     */
+    Option.of = (value) => Option.toSome(value);
+    /**
+     * Creates a Some containing the given value.
+     */
+    Option.toSome = (value) => ({ kind: "Some", value });
+    /**
+     * Type guard that checks if a Option is Some.
+     */
+    Option.isSome = (data) => data.kind === "Some";
+    /**
+     * Creates a None (empty Option).
+     */
+    Option.toNone = () => ({ kind: "None" });
+    /**
+     * Type guard that checks if a Option is None.
+     */
+    Option.isNone = (data) => data.kind === "None";
+    /**
+     * Creates a Option from a nullable value.
+     * Returns None if the value is null or undefined, Some otherwise.
+     *
+     * @example
+     * ```ts
+     * Option.fromNullable(null); // None
+     * Option.fromNullable(42); // Some(42)
+     * ```
+     */
+    Option.fromNullable = (value) => value === null || value === undefined ? Option.toNone() : Option.toSome(value);
+    /**
+     * Extracts the value from a Option, returning null if None.
+     */
+    Option.toNullable = (data) => Option.isSome(data) ? data.value : null;
+    /**
+     * Extracts the value from a Option, returning undefined if None.
+     */
+    Option.toUndefined = (data) => Option.isSome(data) ? data.value : undefined;
+    /**
+     * Creates a Option from a possibly undefined value.
+     * Returns None if undefined, Some otherwise.
+     */
+    Option.fromUndefined = (value) => value === undefined ? Option.toNone() : Option.toSome(value);
+    /**
+     * Converts an Option to a Result.
+     * Some becomes Ok, None becomes Err with the provided error.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Option.of(42),
+     *   Option.toResult(() => "Value was missing")
+     * ); // Ok(42)
+     *
+     * pipe(
+     *   Option.toNone(),
+     *   Option.toResult(() => "Value was missing")
+     * ); // Err("Value was missing")
+     * ```
+     */
+    Option.toResult = (onNone) => (data) => Option.isSome(data) ? Result_js_1.Result.toOk(data.value) : Result_js_1.Result.toErr(onNone());
+    /**
+     * Creates an Option from a Result.
+     * Ok becomes Some, Err becomes None (the error is discarded).
+     *
+     * @example
+     * ```ts
+     * Option.fromResult(Result.toOk(42)); // Some(42)
+     * Option.fromResult(Result.toErr("oops")); // None
+     * ```
+     */
+    Option.fromResult = (data) => Result_js_1.Result.isOk(data) ? Option.toSome(data.value) : Option.toNone();
+    /**
+     * Transforms the value inside a Option if it exists.
+     *
+     * @example
+     * ```ts
+     * pipe(Option.of(5), Option.map(n => n * 2)); // Some(10)
+     * pipe(Option.toNone(), Option.map(n => n * 2)); // None
+     * ```
+     */
+    Option.map = (f) => (data) => Option.isSome(data) ? Option.toSome(f(data.value)) : data;
+    /**
+     * Chains Option computations. If the first is Some, passes the value to f.
+     * If the first is None, propagates None.
+     *
+     * @example
+     * ```ts
+     * const parseNumber = (s: string): Option<number> => {
+     *   const n = parseInt(s, 10);
+     *   return isNaN(n) ? Option.toNone() : Option.of(n);
+     * };
+     *
+     * pipe(Option.of("42"), Option.chain(parseNumber)); // Some(42)
+     * pipe(Option.of("abc"), Option.chain(parseNumber)); // None
+     * ```
+     */
+    Option.chain = (f) => (data) => Option.isSome(data) ? f(data.value) : data;
+    /**
+     * Extracts the value from a Option by providing handlers for both cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Option.of(5),
+     *   Option.fold(
+     *     () => "No value",
+     *     n => `Value: ${n}`
+     *   )
+     * ); // "Value: 5"
+     * ```
+     */
+    Option.fold = (onNone, onSome) => (data) => Option.isSome(data) ? onSome(data.value) : onNone();
+    /**
+     * Pattern matches on a Option, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   optionUser,
+     *   Option.match({
+     *     some: user => `Hello, ${user.name}`,
+     *     none: () => "Hello, stranger"
+     *   })
+     * );
+     * ```
+     */
+    Option.match = (cases) => (data) => Option.isSome(data) ? cases.some(data.value) : cases.none();
+    /**
+     * Returns the value inside a Option, or a default value if None.
+     *
+     * @example
+     * ```ts
+     * pipe(Option.of(5), Option.getOrElse(0)); // 5
+     * pipe(Option.toNone(), Option.getOrElse(0)); // 0
+     * ```
+     */
+    Option.getOrElse = (defaultValue) => (data) => Option.isSome(data) ? data.value : defaultValue;
+    /**
+     * Executes a side effect on the value without changing the Option.
+     * Useful for logging or debugging.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Option.of(5),
+     *   Option.tap(n => console.log("Value:", n)),
+     *   Option.map(n => n * 2)
+     * );
+     * ```
+     */
+    Option.tap = (f) => (data) => {
+        if (Option.isSome(data))
+            f(data.value);
+        return data;
+    };
+    /**
+     * Filters a Option based on a predicate.
+     * Returns None if the predicate returns false or if the Option is already None.
+     *
+     * @example
+     * ```ts
+     * pipe(Option.of(5), Option.filter(n => n > 3)); // Some(5)
+     * pipe(Option.of(2), Option.filter(n => n > 3)); // None
+     * ```
+     */
+    Option.filter = (predicate) => (data) => Option.isSome(data) && predicate(data.value) ? data : Option.toNone();
+    /**
+     * Recovers from a None by providing a fallback Option.
+     */
+    Option.recover = (fallback) => (data) => Option.isSome(data) ? data : fallback();
+    /**
+     * Applies a function wrapped in a Option to a value wrapped in a Option.
+     *
+     * @example
+     * ```ts
+     * const add = (a: number) => (b: number) => a + b;
+     * pipe(
+     *   Option.of(add),
+     *   Option.ap(Option.of(5)),
+     *   Option.ap(Option.of(3))
+     * ); // Some(8)
+     * ```
+     */
+    Option.ap = (arg) => (data) => Option.isSome(data) && Option.isSome(arg) ? Option.toSome(data.value(arg.value)) : Option.toNone();
+})(Option || (exports.Option = Option = {}));

package/script/src/Core/Rec.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rec = void 0;
+const Option_js_1 = require("./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 }
+ * ```
+ */
+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_js_1.Option.toSome(data[key]) : Option_js_1.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 || (exports.Rec = Rec = {}));

package/script/src/Core/RemoteData.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteData = void 0;
+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 || (exports.RemoteData = RemoteData = {}));