@nlozgachev/pipekit 0.1.6

package/script/src/Composition/not.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.not = void 0;
+/**
+ * Negates a predicate function.
+ * Returns a new predicate that returns true when the original returns false, and vice versa.
+ *
+ * @example
+ * ```ts
+ * const isEven = (n: number) => n % 2 === 0;
+ * const isOdd = not(isEven);
+ *
+ * isOdd(3); // true
+ * isOdd(4); // false
+ *
+ * // With array methods
+ * const numbers = [1, 2, 3, 4, 5];
+ * numbers.filter(not(isEven)); // [1, 3, 5]
+ *
+ * // In pipelines
+ * pipe(
+ *   users,
+ *   Array.filter(not(isAdmin)),
+ *   Array.map(u => u.name)
+ * );
+ * ```
+ */
+const not = (predicate) => (...args) => !predicate(...args);
+exports.not = not;

package/script/src/Composition/pipe.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipe = pipe;
+function pipe(a, ...fns) {
+    return fns.reduce((acc, fn) => fn(acc), a);
+}

package/script/src/Composition/tap.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tap = void 0;
+/**
+ * Executes a side effect function and returns the original value unchanged.
+ * Useful for logging, debugging, or other side effects within a pipeline.
+ *
+ * @example
+ * ```ts
+ * // Debugging a pipeline
+ * pipe(
+ *   Option.of(5),
+ *   tap(x => console.log("Before map:", x)),
+ *   Option.map(n => n * 2),
+ *   tap(x => console.log("After map:", x)),
+ *   Option.getOrElse(0)
+ * );
+ * // logs: "Before map: { kind: 'Some', value: 5 }"
+ * // logs: "After map: { kind: 'Some', value: 10 }"
+ * // returns: 10
+ *
+ * // Collecting intermediate values
+ * const values: number[] = [];
+ * pipe(
+ *   [1, 2, 3],
+ *   arr => arr.map(n => n * 2),
+ *   tap(arr => values.push(...arr))
+ * );
+ * ```
+ *
+ * @see {@link Option.tap} for Option-specific tap that only runs on Some
+ */
+const tap = (f) => (a) => {
+    f(a);
+    return a;
+};
+exports.tap = tap;

package/script/src/Composition/uncurry.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uncurry4 = exports.uncurry3 = void 0;
+exports.uncurry = uncurry;
+// deno-lint-ignore no-explicit-any
+function uncurry(f) {
+    // f.length determines the outer arity; inner.length determines the inner arity.
+    // The typed overloads guarantee these are 0, 1, or 2 total args.
+    // deno-lint-ignore no-explicit-any
+    return (...args) => {
+        const inner = f(...args.slice(0, f.length));
+        return inner.length === 0 ? inner() : inner(...args.slice(f.length));
+    };
+}
+/**
+ * Converts a curried 3-argument function into a multi-argument function.
+ *
+ * @example
+ * ```ts
+ * const curriedAdd3 = (a: number) => (b: number) => (c: number) => a + b + c;
+ * const add3 = uncurry3(curriedAdd3);
+ * add3(1, 2, 3); // 6
+ * ```
+ */
+const uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
+exports.uncurry3 = uncurry3;
+/**
+ * Converts a curried 4-argument function into a multi-argument function.
+ *
+ * @example
+ * ```ts
+ * const curriedAdd4 = (a: number) => (b: number) => (c: number) => (d: number) => a + b + c + d;
+ * const add4 = uncurry4(curriedAdd4);
+ * add4(1, 2, 3, 4); // 10
+ * ```
+ */
+const uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
+exports.uncurry4 = uncurry4;

package/script/src/Core/Arr.js

@@ -0,0 +1,464 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Arr = void 0;
+const Option_js_1 = require("./Option.js");
+const Result_js_1 = require("./Result.js");
+const NonEmptyList_js_1 = require("../Types/NonEmptyList.js");
+/**
+ * Functional array utilities that compose well with pipe.
+ * All functions are data-last and curried where applicable.
+ * Safe access functions return Option instead of throwing or returning undefined.
+ *
+ * @example
+ * ```ts
+ * pipe(
+ *   [1, 2, 3, 4, 5],
+ *   Arr.filter(n => n > 2),
+ *   Arr.map(n => n * 10),
+ *   Arr.head
+ * ); // Some(30)
+ * ```
+ */
+var Arr;
+(function (Arr) {
+    // --- Safe access ---
+    /**
+     * Returns the first element of an array, or None if the array is empty.
+     *
+     * @example
+     * ```ts
+     * Arr.head([1, 2, 3]); // Some(1)
+     * Arr.head([]); // None
+     * ```
+     */
+    Arr.head = (data) => data.length > 0 ? Option_js_1.Option.toSome(data[0]) : Option_js_1.Option.toNone();
+    /**
+     * Returns the last element of an array, or None if the array is empty.
+     *
+     * @example
+     * ```ts
+     * Arr.last([1, 2, 3]); // Some(3)
+     * Arr.last([]); // None
+     * ```
+     */
+    Arr.last = (data) => data.length > 0 ? Option_js_1.Option.toSome(data[data.length - 1]) : Option_js_1.Option.toNone();
+    /**
+     * Returns all elements except the first, or None if the array is empty.
+     *
+     * @example
+     * ```ts
+     * Arr.tail([1, 2, 3]); // Some([2, 3])
+     * Arr.tail([]); // None
+     * ```
+     */
+    Arr.tail = (data) => data.length > 0 ? Option_js_1.Option.toSome(data.slice(1)) : Option_js_1.Option.toNone();
+    /**
+     * Returns all elements except the last, or None if the array is empty.
+     *
+     * @example
+     * ```ts
+     * Arr.init([1, 2, 3]); // Some([1, 2])
+     * Arr.init([]); // None
+     * ```
+     */
+    Arr.init = (data) => data.length > 0 ? Option_js_1.Option.toSome(data.slice(0, -1)) : Option_js_1.Option.toNone();
+    // --- Search ---
+    /**
+     * Returns the first element matching the predicate, or None.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.findFirst(n => n > 2)); // Some(3)
+     * ```
+     */
+    Arr.findFirst = (predicate) => (data) => {
+        const idx = data.findIndex(predicate);
+        return idx >= 0 ? Option_js_1.Option.toSome(data[idx]) : Option_js_1.Option.toNone();
+    };
+    /**
+     * Returns the last element matching the predicate, or None.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.findLast(n => n > 2)); // Some(4)
+     * ```
+     */
+    Arr.findLast = (predicate) => (data) => {
+        for (let i = data.length - 1; i >= 0; i--) {
+            if (predicate(data[i]))
+                return Option_js_1.Option.toSome(data[i]);
+        }
+        return Option_js_1.Option.toNone();
+    };
+    /**
+     * Returns the index of the first element matching the predicate, or None.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.findIndex(n => n > 2)); // Some(2)
+     * ```
+     */
+    Arr.findIndex = (predicate) => (data) => {
+        const idx = data.findIndex(predicate);
+        return idx >= 0 ? Option_js_1.Option.toSome(idx) : Option_js_1.Option.toNone();
+    };
+    // --- Transform ---
+    /**
+     * Transforms each element of an array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.map(n => n * 2)); // [2, 4, 6]
+     * ```
+     */
+    Arr.map = (f) => (data) => data.map(f);
+    /**
+     * Filters elements that satisfy the predicate.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.filter(n => n % 2 === 0)); // [2, 4]
+     * ```
+     */
+    Arr.filter = (predicate) => (data) => data.filter(predicate);
+    /**
+     * Splits an array into two groups based on a predicate.
+     * First group contains elements that satisfy the predicate,
+     * second group contains the rest.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.partition(n => n % 2 === 0)); // [[2, 4], [1, 3]]
+     * ```
+     */
+    Arr.partition = (predicate) => (data) => {
+        const pass = [];
+        const fail = [];
+        for (const a of data) {
+            (predicate(a) ? pass : fail).push(a);
+        }
+        return [pass, fail];
+    };
+    /**
+     * Groups elements by a key function.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   ["apple", "avocado", "banana"],
+     *   Arr.groupBy(s => s[0])
+     * ); // { a: ["apple", "avocado"], b: ["banana"] }
+     * ```
+     */
+    Arr.groupBy = (f) => (data) => {
+        const result = {};
+        for (const a of data) {
+            const key = f(a);
+            if (!result[key])
+                result[key] = [];
+            result[key].push(a);
+        }
+        return result;
+    };
+    /**
+     * Removes duplicate elements using strict equality.
+     *
+     * @example
+     * ```ts
+     * Arr.uniq([1, 2, 2, 3, 1]); // [1, 2, 3]
+     * ```
+     */
+    Arr.uniq = (data) => [
+        ...new Set(data),
+    ];
+    /**
+     * Removes duplicate elements by comparing the result of a key function.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [{id: 1, name: "a"}, {id: 1, name: "b"}, {id: 2, name: "c"}],
+     *   Arr.uniqBy(x => x.id)
+     * ); // [{id: 1, name: "a"}, {id: 2, name: "c"}]
+     * ```
+     */
+    Arr.uniqBy = (f) => (data) => {
+        const seen = new Set();
+        const result = [];
+        for (const a of data) {
+            const key = f(a);
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(a);
+            }
+        }
+        return result;
+    };
+    /**
+     * Sorts an array using a comparison function. Returns a new array.
+     *
+     * @example
+     * ```ts
+     * pipe([3, 1, 2], Arr.sortBy((a, b) => a - b)); // [1, 2, 3]
+     * ```
+     */
+    Arr.sortBy = (compare) => (data) => [...data].sort(compare);
+    // --- Combine ---
+    /**
+     * Pairs up elements from two arrays. Stops at the shorter array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.zip(["a", "b"])); // [[1, "a"], [2, "b"]]
+     * ```
+     */
+    Arr.zip = (other) => (data) => {
+        const len = Math.min(data.length, other.length);
+        const result = [];
+        for (let i = 0; i < len; i++) {
+            result.push([data[i], other[i]]);
+        }
+        return result;
+    };
+    /**
+     * Combines elements from two arrays using a function. Stops at the shorter array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2], Arr.zipWith((a, b) => a + b, ["a", "b"])); // ["1a", "2b"]
+     * ```
+     */
+    Arr.zipWith = (f, other) => (data) => {
+        const len = Math.min(data.length, other.length);
+        const result = [];
+        for (let i = 0; i < len; i++) {
+            result.push(f(data[i], other[i]));
+        }
+        return result;
+    };
+    /**
+     * Inserts a separator between every element.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.intersperse(0)); // [1, 0, 2, 0, 3]
+     * ```
+     */
+    Arr.intersperse = (sep) => (data) => {
+        if (data.length <= 1)
+            return data;
+        const result = [data[0]];
+        for (let i = 1; i < data.length; i++) {
+            result.push(sep, data[i]);
+        }
+        return result;
+    };
+    /**
+     * Splits an array into chunks of the given size.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4, 5], Arr.chunksOf(2)); // [[1, 2], [3, 4], [5]]
+     * ```
+     */
+    Arr.chunksOf = (n) => (data) => {
+        if (n <= 0)
+            return [];
+        const result = [];
+        for (let i = 0; i < data.length; i += n) {
+            result.push(data.slice(i, i + n));
+        }
+        return result;
+    };
+    /**
+     * Flattens a nested array by one level.
+     *
+     * @example
+     * ```ts
+     * Arr.flatten([[1, 2], [3], [4, 5]]); // [1, 2, 3, 4, 5]
+     * ```
+     */
+    Arr.flatten = (data) => [].concat(...data);
+    /**
+     * Maps each element to an array and flattens the result.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.flatMap(n => [n, n * 10])); // [1, 10, 2, 20, 3, 30]
+     * ```
+     */
+    Arr.flatMap = (f) => (data) => [].concat(...data.map(f));
+    /**
+     * Reduces an array from the left.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.reduce(0, (acc, n) => acc + n)); // 6
+     * ```
+     */
+    Arr.reduce = (initial, f) => (data) => data.reduce(f, initial);
+    // --- Traverse / Sequence ---
+    /**
+     * Maps each element to an Option and collects the results.
+     * Returns None if any mapping returns None.
+     *
+     * @example
+     * ```ts
+     * const parseNum = (s: string): Option<number> => {
+     *   const n = Number(s);
+     *   return isNaN(n) ? Option.toNone() : Option.of(n);
+     * };
+     *
+     * pipe(["1", "2", "3"], Arr.traverse(parseNum)); // Some([1, 2, 3])
+     * pipe(["1", "x", "3"], Arr.traverse(parseNum)); // None
+     * ```
+     */
+    Arr.traverse = (f) => (data) => {
+        const result = [];
+        for (const a of data) {
+            const mapped = f(a);
+            if (Option_js_1.Option.isNone(mapped))
+                return Option_js_1.Option.toNone();
+            result.push(mapped.value);
+        }
+        return Option_js_1.Option.toSome(result);
+    };
+    /**
+     * Maps each element to a Result and collects the results.
+     * Returns the first Err if any mapping fails.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [1, 2, 3],
+     *   Arr.traverseResult(n => n > 0 ? Result.toOk(n) : Result.toErr("negative"))
+     * ); // Ok([1, 2, 3])
+     * ```
+     */
+    Arr.traverseResult = (f) => (data) => {
+        const result = [];
+        for (const a of data) {
+            const mapped = f(a);
+            if (Result_js_1.Result.isErr(mapped))
+                return mapped;
+            result.push(mapped.value);
+        }
+        return Result_js_1.Result.toOk(result);
+    };
+    /**
+     * Maps each element to a Task and runs all in parallel.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [1, 2, 3],
+     *   Arr.traverseTask(n => Task.of(n * 2))
+     * )(); // Promise<[2, 4, 6]>
+     * ```
+     */
+    Arr.traverseTask = (f) => (data) => () => Promise.all(data.map((a) => f(a)()));
+    /**
+     * Collects an array of Options into an Option of array.
+     * Returns None if any element is None.
+     *
+     * @example
+     * ```ts
+     * Arr.sequence([Option.of(1), Option.of(2)]); // Some([1, 2])
+     * Arr.sequence([Option.of(1), Option.toNone()]); // None
+     * ```
+     */
+    Arr.sequence = (data) => Arr.traverse((a) => a)(data);
+    /**
+     * Collects an array of Results into a Result of array.
+     * Returns the first Err if any element is Err.
+     */
+    Arr.sequenceResult = (data) => Arr.traverseResult((a) => a)(data);
+    /**
+     * Collects an array of Tasks into a Task of array. Runs in parallel.
+     */
+    Arr.sequenceTask = (data) => Arr.traverseTask((a) => a)(data);
+    /**
+     * Returns true if the array is non-empty (type guard).
+     */
+    Arr.isNonEmpty = (data) => (0, NonEmptyList_js_1.isNonEmptyList)(data);
+    /**
+     * Returns the length of an array.
+     */
+    Arr.size = (data) => data.length;
+    /**
+     * Returns true if any element satisfies the predicate.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.some(n => n > 2)); // true
+     * ```
+     */
+    Arr.some = (predicate) => (data) => data.some(predicate);
+    /**
+     * Returns true if all elements satisfy the predicate.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.every(n => n > 0)); // true
+     * ```
+     */
+    Arr.every = (predicate) => (data) => data.every(predicate);
+    /**
+     * Reverses an array. Returns a new array.
+     *
+     * @example
+     * ```ts
+     * Arr.reverse([1, 2, 3]); // [3, 2, 1]
+     * ```
+     */
+    Arr.reverse = (data) => [...data].reverse();
+    /**
+     * Takes the first n elements from an array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.take(2)); // [1, 2]
+     * ```
+     */
+    Arr.take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
+    /**
+     * Drops the first n elements from an array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.drop(2)); // [3, 4]
+     * ```
+     */
+    Arr.drop = (n) => (data) => data.slice(n);
+    /**
+     * Takes elements from the start while the predicate holds.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 1], Arr.takeWhile(n => n < 3)); // [1, 2]
+     * ```
+     */
+    Arr.takeWhile = (predicate) => (data) => {
+        const result = [];
+        for (const a of data) {
+            if (!predicate(a))
+                break;
+            result.push(a);
+        }
+        return result;
+    };
+    /**
+     * Drops elements from the start while the predicate holds.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 1], Arr.dropWhile(n => n < 3)); // [3, 1]
+     * ```
+     */
+    Arr.dropWhile = (predicate) => (data) => {
+        let i = 0;
+        while (i < data.length && predicate(data[i]))
+            i++;
+        return data.slice(i);
+    };
+})(Arr || (exports.Arr = Arr = {}));

package/script/src/Core/InternalTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });