@nlozgachev/pipelined 0.11.0 → 0.13.0

package/script/src/Utils/Arr.js

@@ -1,573 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Arr = void 0;
-const Deferred_js_1 = require("../Core/Deferred.js");
-const Option_js_1 = require("../Core/Option.js");
-const Result_js_1 = require("../Core/Result.js");
-const Task_js_1 = require("../Core/Task.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.some(data[0]) : Option_js_1.Option.none();
-    /**
-     * 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.some(data[data.length - 1]) : Option_js_1.Option.none();
-    /**
-     * 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.some(data.slice(1)) : Option_js_1.Option.none();
-    /**
-     * 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.some(data.slice(0, -1)) : Option_js_1.Option.none();
-    // --- 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.some(data[idx]) : Option_js_1.Option.none();
-    };
-    /**
-     * 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.some(data[i]);
-        }
-        return Option_js_1.Option.none();
-    };
-    /**
-     * 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.some(idx) : Option_js_1.Option.none();
-    };
-    // --- 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) => {
-        const n = data.length;
-        const result = new Array(n);
-        for (let i = 0; i < n; i++)
-            result[i] = f(data[i]);
-        return result;
-    };
-    /**
-     * 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) => {
-        const n = data.length;
-        const result = [];
-        for (let i = 0; i < n; i++) {
-            if (predicate(data[i]))
-                result.push(data[i]);
-        }
-        return result;
-    };
-    /**
-     * 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 = new Array(len);
-        for (let i = 0; i < len; i++) {
-            result[i] = [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 = new Array(len);
-        for (let i = 0; i < len; i++) {
-            result[i] = 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) => {
-        const n = data.length;
-        const result = [];
-        for (let i = 0; i < n; i++) {
-            const chunk = f(data[i]);
-            const m = chunk.length;
-            for (let j = 0; j < m; j++)
-                result.push(chunk[j]);
-        }
-        return result;
-    };
-    /**
-     * 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.none() : Option.some(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 n = data.length;
-        const result = new Array(n);
-        for (let i = 0; i < n; i++) {
-            const mapped = f(data[i]);
-            if (mapped.kind === "None")
-                return Option_js_1.Option.none();
-            result[i] = mapped.value;
-        }
-        return Option_js_1.Option.some(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.ok(n) : Result.err("negative"))
-     * ); // Ok([1, 2, 3])
-     * ```
-     */
-    Arr.traverseResult = (f) => (data) => {
-        const n = data.length;
-        const result = new Array(n);
-        for (let i = 0; i < n; i++) {
-            const mapped = f(data[i]);
-            if (mapped.kind === "Error")
-                return mapped;
-            result[i] = mapped.value;
-        }
-        return Result_js_1.Result.ok(result);
-    };
-    /**
-     * Maps each element to a Task and runs all in parallel.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   [1, 2, 3],
-     *   Arr.traverseTask(n => Task.resolve(n * 2))
-     * )(); // Promise<[2, 4, 6]>
-     * ```
-     */
-    Arr.traverseTask = (f) => (data) => Task_js_1.Task.from(() => Promise.all(data.map((a) => Deferred_js_1.Deferred.toPromise(f(a)()))));
-    /**
-     * Collects an array of Options into an Option of array.
-     * Returns None if any element is None.
-     *
-     * @example
-     * ```ts
-     * Arr.sequence([Option.some(1), Option.some(2)]); // Some([1, 2])
-     * Arr.sequence([Option.some(1), Option.none()]); // 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);
-    /**
-     * Maps each element to a TaskResult and runs them sequentially.
-     * Returns the first Err encountered, or Ok of all results if all succeed.
-     *
-     * @example
-     * ```ts
-     * const validate = (n: number): TaskResult<string, number> =>
-     *   n > 0 ? TaskResult.ok(n) : TaskResult.err("non-positive");
-     *
-     * pipe(
-     *   [1, 2, 3],
-     *   Arr.traverseTaskResult(validate)
-     * )(); // Deferred<Ok([1, 2, 3])>
-     *
-     * pipe(
-     *   [1, -1, 3],
-     *   Arr.traverseTaskResult(validate)
-     * )(); // Deferred<Err("non-positive")>
-     * ```
-     */
-    Arr.traverseTaskResult = (f) => (data) => Task_js_1.Task.from(async () => {
-        const result = [];
-        for (const a of data) {
-            const r = await Deferred_js_1.Deferred.toPromise(f(a)());
-            if (Result_js_1.Result.isErr(r))
-                return r;
-            result.push(r.value);
-        }
-        return Result_js_1.Result.ok(result);
-    });
-    /**
-     * Collects an array of TaskResults into a TaskResult of array.
-     * Returns the first Err if any element is Err, runs sequentially.
-     */
-    Arr.sequenceTaskResult = (data) => Arr.traverseTaskResult((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) => {
-        const n = data.length;
-        for (let i = 0; i < n; i++)
-            if (predicate(data[i]))
-                return true;
-        return false;
-    };
-    /**
-     * Returns true if all elements satisfy the predicate.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.every(n => n > 0)); // true
-     * ```
-     */
-    Arr.every = (predicate) => (data) => {
-        const n = data.length;
-        for (let i = 0; i < n; i++)
-            if (!predicate(data[i]))
-                return false;
-        return true;
-    };
-    /**
-     * 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);
-    };
-    /**
-     * Like `reduce`, but returns every intermediate accumulator as an array.
-     * The initial value is not included — the output has the same length as the input.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3], Arr.scan(0, (acc, n) => acc + n)); // [1, 3, 6]
-     * ```
-     */
-    Arr.scan = (initial, f) => (data) => {
-        const n = data.length;
-        const result = new Array(n);
-        let acc = initial;
-        for (let i = 0; i < n; i++) {
-            acc = f(acc, data[i]);
-            result[i] = acc;
-        }
-        return result;
-    };
-    /**
-     * Splits an array at an index into a `[before, after]` tuple.
-     * Negative indices clamp to 0; indices beyond the array length clamp to the end.
-     *
-     * @example
-     * ```ts
-     * pipe([1, 2, 3, 4], Arr.splitAt(2)); // [[1, 2], [3, 4]]
-     * pipe([1, 2, 3], Arr.splitAt(0));    // [[], [1, 2, 3]]
-     * pipe([1, 2, 3], Arr.splitAt(10));   // [[1, 2, 3], []]
-     * ```
-     */
-    Arr.splitAt = (index) => (data) => {
-        const i = Math.max(0, index);
-        return [data.slice(0, i), data.slice(i)];
-    };
-})(Arr || (exports.Arr = Arr = {}));

package/script/src/Utils/Num.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Num = void 0;
-const Option_js_1 = require("../Core/Option.js");
-/**
- * Number utilities for common operations. All transformation functions are data-last
- * and curried so they compose naturally with `pipe` and `Arr.map`.
- *
- * @example
- * ```ts
- * import { Num } from "@nlozgachev/pipelined/utils";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * pipe(
- *   Num.range(1, 6),
- *   Arr.map(Num.multiply(2)),
- *   Arr.filter(Num.between(4, 8))
- * ); // [4, 6, 8]
- * ```
- */
-var Num;
-(function (Num) {
-    /**
-     * Generates an array of numbers from `from` to `to` (both inclusive),
-     * stepping by `step` (default `1`). If `step` is negative or zero, or `from > to`,
-     * returns an empty array. When `step` does not land exactly on `to`, the last value
-     * is the largest reachable value that does not exceed `to`.
-     *
-     * @example
-     * ```ts
-     * Num.range(0, 5);       // [0, 1, 2, 3, 4, 5]
-     * Num.range(0, 10, 2);   // [0, 2, 4, 6, 8, 10]
-     * Num.range(0, 9, 2);    // [0, 2, 4, 6, 8]
-     * Num.range(5, 0);       // []
-     * Num.range(3, 3);       // [3]
-     * ```
-     */
-    Num.range = (from, to, step = 1) => {
-        if (step <= 0 || from > to)
-            return [];
-        const count = Math.floor((to - from) / step) + 1;
-        const result = new Array(count);
-        for (let i = 0; i < count; i++) {
-            result[i] = from + i * step;
-        }
-        return result;
-    };
-    /**
-     * Clamps a number between `min` and `max` (both inclusive).
-     *
-     * @example
-     * ```ts
-     * pipe(150, Num.clamp(0, 100)); // 100
-     * pipe(-5, Num.clamp(0, 100));  // 0
-     * pipe(42, Num.clamp(0, 100));  // 42
-     * ```
-     */
-    Num.clamp = (min, max) => (n) => Math.min(Math.max(n, min), max);
-    /**
-     * Returns `true` when the number is between `min` and `max` (both inclusive).
-     *
-     * @example
-     * ```ts
-     * pipe(5, Num.between(1, 10));  // true
-     * pipe(0, Num.between(1, 10));  // false
-     * pipe(10, Num.between(1, 10)); // true
-     * ```
-     */
-    Num.between = (min, max) => (n) => n >= min && n <= max;
-    /**
-     * Parses a string as a number. Returns `None` when the result is `NaN`.
-     *
-     * @example
-     * ```ts
-     * Num.parse("42");   // Some(42)
-     * Num.parse("3.14"); // Some(3.14)
-     * Num.parse("abc");  // None
-     * Num.parse("");     // None
-     * ```
-     */
-    Num.parse = (s) => {
-        if (s.trim() === "")
-            return Option_js_1.Option.none();
-        const n = Number(s);
-        return isNaN(n) ? Option_js_1.Option.none() : Option_js_1.Option.some(n);
-    };
-    /**
-     * Adds `b` to a number. Data-last: use in `pipe` or `Arr.map`.
-     *
-     * @example
-     * ```ts
-     * pipe(5, Num.add(3));                   // 8
-     * pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]
-     * ```
-     */
-    Num.add = (b) => (a) => a + b;
-    /**
-     * Subtracts `b` from a number. Data-last: `subtract(b)(a)` = `a - b`.
-     *
-     * @example
-     * ```ts
-     * pipe(10, Num.subtract(3));                  // 7
-     * pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]
-     * ```
-     */
-    Num.subtract = (b) => (a) => a - b;
-    /**
-     * Multiplies a number by `b`. Data-last: use in `pipe` or `Arr.map`.
-     *
-     * @example
-     * ```ts
-     * pipe(6, Num.multiply(7));                    // 42
-     * pipe([1, 2, 3], Arr.map(Num.multiply(100))); // [100, 200, 300]
-     * ```
-     */
-    Num.multiply = (b) => (a) => a * b;
-    /**
-     * Divides a number by `b`. Data-last: `divide(b)(a)` = `a / b`.
-     *
-     * @example
-     * ```ts
-     * pipe(20, Num.divide(4));                      // 5
-     * pipe([10, 20, 30], Arr.map(Num.divide(10)));  // [1, 2, 3]
-     * ```
-     */
-    Num.divide = (b) => (a) => a / b;
-})(Num || (exports.Num = Num = {}));