@nlozgachev/pipelined 0.12.0 → 0.13.0

package/esm/src/Utils/Rec.js

@@ -1,241 +0,0 @@
-import { Option } from "../Core/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 keys = Object.keys(data);
-        const vals = Object.values(data);
-        const result = {};
-        for (let i = 0; i < keys.length; i++) {
-            result[keys[i]] = f(vals[i]);
-        }
-        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 keys = Object.keys(data);
-        const vals = Object.values(data);
-        const result = {};
-        for (let i = 0; i < keys.length; i++) {
-            result[keys[i]] = f(keys[i], vals[i]);
-        }
-        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 keys = Object.keys(data);
-        const vals = Object.values(data);
-        const result = {};
-        for (let i = 0; i < keys.length; i++) {
-            if (predicate(vals[i]))
-                result[keys[i]] = vals[i];
-        }
-        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 keys = Object.keys(data);
-        const vals = Object.values(data);
-        const result = {};
-        for (let i = 0; i < keys.length; i++) {
-            if (predicate(keys[i], vals[i]))
-                result[keys[i]] = vals[i];
-        }
-        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.some(data[key]) : Option.none();
-    /**
-     * 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);
-    /**
-     * Groups elements of an array into a record keyed by the result of `keyFn`. Each key maps to
-     * the array of elements that produced it, in insertion order.
-     *
-     * Unlike `Dict.groupBy`, keys are always strings. Use `Dict.groupBy` when you need non-string
-     * keys or want to avoid the plain-object prototype chain.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   ["apple", "avocado", "banana", "blueberry"],
-     *   Rec.groupBy(s => s[0]),
-     * ); // { a: ["apple", "avocado"], b: ["banana", "blueberry"] }
-     * ```
-     */
-    Rec.groupBy = (keyFn) => (items) => {
-        const result = {};
-        for (const item of items) {
-            const key = keyFn(item);
-            if (key in result)
-                result[key].push(item);
-            else
-                result[key] = [item];
-        }
-        return result;
-    };
-    /**
-     * 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;
-    /**
-     * Transforms each key while preserving values.
-     * If two keys map to the same new key, the last one wins.
-     *
-     * @example
-     * ```ts
-     * pipe({ firstName: "Alice", lastName: "Smith" }, Rec.mapKeys(k => k.toUpperCase()));
-     * // { FIRSTNAME: "Alice", LASTNAME: "Smith" }
-     * ```
-     */
-    Rec.mapKeys = (f) => (data) => {
-        const keys = Object.keys(data);
-        const vals = Object.values(data);
-        const result = {};
-        for (let i = 0; i < keys.length; i++) {
-            result[f(keys[i])] = vals[i];
-        }
-        return result;
-    };
-    /**
-     * Removes all `None` values from a `Record<string, Option<A>>`, returning a plain `Record<string, A>`.
-     * Useful when building records from fallible lookups.
-     *
-     * @example
-     * ```ts
-     * Rec.compact({ a: Option.some(1), b: Option.none(), c: Option.some(3) });
-     * // { a: 1, c: 3 }
-     * ```
-     */
-    Rec.compact = (data) => {
-        const keys = Object.keys(data);
-        const vals = Object.values(data);
-        const result = {};
-        for (let i = 0; i < keys.length; i++) {
-            const v = vals[i];
-            if (v.kind === "Some")
-                result[keys[i]] = v.value;
-        }
-        return result;
-    };
-})(Rec || (Rec = {}));

package/esm/src/Utils/Str.js

@@ -1,134 +0,0 @@
-import { Option } from "../Core/Option.js";
-/**
- * String utilities. All transformation functions are data-last and curried so they
- * compose naturally with `pipe`. Safe parsers return `Option` instead of `NaN`.
- *
- * @example
- * ```ts
- * import { Str } from "@nlozgachev/pipelined/utils";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * pipe("  Hello, World!  ", Str.trim, Str.toLowerCase); // "hello, world!"
- * ```
- */
-export var Str;
-(function (Str) {
-    /**
-     * Splits a string by a separator. Data-last: use in `pipe`.
-     *
-     * @example
-     * ```ts
-     * pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
-     * ```
-     */
-    Str.split = (separator) => (s) => s.split(separator);
-    /**
-     * Removes leading and trailing whitespace from a string.
-     *
-     * @example
-     * ```ts
-     * pipe("  hello  ", Str.trim); // "hello"
-     * ```
-     */
-    Str.trim = (s) => s.trim();
-    /**
-     * Returns `true` when the string contains the given substring.
-     *
-     * @example
-     * ```ts
-     * pipe("hello world", Str.includes("world")); // true
-     * pipe("hello world", Str.includes("xyz"));   // false
-     * ```
-     */
-    Str.includes = (substring) => (s) => s.includes(substring);
-    /**
-     * Returns `true` when the string starts with the given prefix.
-     *
-     * @example
-     * ```ts
-     * pipe("hello world", Str.startsWith("hello")); // true
-     * pipe("hello world", Str.startsWith("world")); // false
-     * ```
-     */
-    Str.startsWith = (prefix) => (s) => s.startsWith(prefix);
-    /**
-     * Returns `true` when the string ends with the given suffix.
-     *
-     * @example
-     * ```ts
-     * pipe("hello world", Str.endsWith("world")); // true
-     * pipe("hello world", Str.endsWith("hello")); // false
-     * ```
-     */
-    Str.endsWith = (suffix) => (s) => s.endsWith(suffix);
-    /**
-     * Converts a string to uppercase.
-     *
-     * @example
-     * ```ts
-     * pipe("hello", Str.toUpperCase); // "HELLO"
-     * ```
-     */
-    Str.toUpperCase = (s) => s.toUpperCase();
-    /**
-     * Converts a string to lowercase.
-     *
-     * @example
-     * ```ts
-     * pipe("HELLO", Str.toLowerCase); // "hello"
-     * ```
-     */
-    Str.toLowerCase = (s) => s.toLowerCase();
-    /**
-     * Splits a string into lines, normalising `\r\n` and `\r` line endings.
-     *
-     * @example
-     * ```ts
-     * Str.lines("one\ntwo\nthree"); // ["one", "two", "three"]
-     * Str.lines("a\r\nb");         // ["a", "b"]
-     * ```
-     */
-    Str.lines = (s) => s.split(/\r?\n|\r/);
-    /**
-     * Splits a string into words on any whitespace boundary, filtering out empty strings.
-     *
-     * @example
-     * ```ts
-     * Str.words("  hello   world  "); // ["hello", "world"]
-     * ```
-     */
-    Str.words = (s) => s.trim().split(/\s+/).filter(Boolean);
-    /**
-     * Safe number parsers that return `Option` instead of `NaN`.
-     */
-    Str.parse = {
-        /**
-         * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
-         *
-         * @example
-         * ```ts
-         * Str.parse.int("42");   // Some(42)
-         * Str.parse.int("3.7");  // Some(3)
-         * Str.parse.int("abc");  // None
-         * ```
-         */
-        int: (s) => {
-            const n = parseInt(s, 10);
-            return isNaN(n) ? Option.none() : Option.some(n);
-        },
-        /**
-         * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
-         *
-         * @example
-         * ```ts
-         * Str.parse.float("3.14"); // Some(3.14)
-         * Str.parse.float("42");   // Some(42)
-         * Str.parse.float("abc");  // None
-         * ```
-         */
-        float: (s) => {
-            const n = parseFloat(s);
-            return isNaN(n) ? Option.none() : Option.some(n);
-        },
-    };
-})(Str || (Str = {}));

package/esm/src/Utils/Uniq.js

@@ -1,265 +0,0 @@
-/**
- * Functional utilities for unique-value collections (`ReadonlySet<A>`). All functions are pure
- * and data-last — they compose naturally with `pipe`.
- *
- * Every "mutating" operation returns a new set; the original is never changed.
- *
- * @example
- * ```ts
- * import { Uniq } from "@nlozgachev/pipelined/utils";
- * import { pipe } from "@nlozgachev/pipelined/composition";
- *
- * const active = pipe(
- *   Uniq.fromArray(["alice", "bob", "alice", "carol"]),
- *   Uniq.remove("bob"),
- *   Uniq.map(name => name.toUpperCase()),
- * );
- * // ReadonlySet { "ALICE", "CAROL" }
- * ```
- */
-export var Uniq;
-(function (Uniq) {
-    // ---------------------------------------------------------------------------
-    // Constructors
-    // ---------------------------------------------------------------------------
-    /**
-     * Creates an empty unique collection.
-     *
-     * @example
-     * ```ts
-     * Uniq.empty<number>(); // ReadonlySet {}
-     * ```
-     */
-    Uniq.empty = () => new globalThis.Set();
-    /**
-     * Creates a unique collection containing a single item.
-     *
-     * @example
-     * ```ts
-     * Uniq.singleton(42); // ReadonlySet { 42 }
-     * ```
-     */
-    Uniq.singleton = (item) => new globalThis.Set([item]);
-    /**
-     * Creates a unique collection from an array, automatically discarding duplicates.
-     *
-     * @example
-     * ```ts
-     * Uniq.fromArray([1, 2, 2, 3, 3, 3]); // ReadonlySet { 1, 2, 3 }
-     * Uniq.fromArray([]);                  // ReadonlySet {}
-     * ```
-     */
-    Uniq.fromArray = (arr) => new globalThis.Set(arr);
-    // ---------------------------------------------------------------------------
-    // Query
-    // ---------------------------------------------------------------------------
-    /**
-     * Returns `true` if the collection contains the given item.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.has(2)); // true
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.has(4)); // false
-     * ```
-     */
-    Uniq.has = (item) => (s) => s.has(item);
-    /**
-     * Returns the number of items in the collection.
-     *
-     * @example
-     * ```ts
-     * Uniq.size(Uniq.fromArray([1, 2, 3])); // 3
-     * ```
-     */
-    Uniq.size = (s) => s.size;
-    /**
-     * Returns `true` if the collection has no items.
-     *
-     * @example
-     * ```ts
-     * Uniq.isEmpty(Uniq.empty()); // true
-     * ```
-     */
-    Uniq.isEmpty = (s) => s.size === 0;
-    /**
-     * Returns `true` if every item in `set` also exists in `other`.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2]), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3]))); // true
-     * pipe(Uniq.fromArray([1, 4]), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3]))); // false
-     * pipe(Uniq.empty<number>(), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3])));   // true
-     * ```
-     */
-    Uniq.isSubsetOf = (other) => (s) => {
-        const set = s;
-        if (typeof set.isSubsetOf === "function")
-            return set.isSubsetOf(other);
-        for (const item of s)
-            if (!other.has(item))
-                return false;
-        return true;
-    };
-    // ---------------------------------------------------------------------------
-    // Modification
-    // ---------------------------------------------------------------------------
-    /**
-     * Returns a new collection with the item added. If the item is already present, returns the
-     * original collection unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2]), Uniq.insert(3)); // ReadonlySet { 1, 2, 3 }
-     * pipe(Uniq.fromArray([1, 2]), Uniq.insert(2)); // ReadonlySet { 1, 2 } — unchanged
-     * ```
-     */
-    Uniq.insert = (item) => (s) => {
-        if (s.has(item))
-            return s;
-        const result = new globalThis.Set(s);
-        result.add(item);
-        return result;
-    };
-    /**
-     * Returns a new collection with the item removed. If the item is not present, returns the
-     * original collection unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.remove(2)); // ReadonlySet { 1, 3 }
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.remove(4)); // ReadonlySet { 1, 2, 3 } — unchanged
-     * ```
-     */
-    Uniq.remove = (item) => (s) => {
-        if (!s.has(item))
-            return s;
-        const result = new globalThis.Set(s);
-        result.delete(item);
-        return result;
-    };
-    // ---------------------------------------------------------------------------
-    // Transform
-    // ---------------------------------------------------------------------------
-    /**
-     * Applies `f` to each item, returning a new collection of the results. Duplicate results are
-     * automatically merged.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4]), Uniq.map(n => n % 3)); // ReadonlySet { 1, 2, 0 }
-     * ```
-     */
-    Uniq.map = (f) => (s) => {
-        const result = new globalThis.Set();
-        for (const item of s) {
-            result.add(f(item));
-        }
-        return result;
-    };
-    /**
-     * Returns a new collection containing only the items for which the predicate returns `true`.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4, 5]), Uniq.filter(n => n % 2 === 0));
-     * // ReadonlySet { 2, 4 }
-     * ```
-     */
-    Uniq.filter = (predicate) => (s) => {
-        const result = new globalThis.Set();
-        for (const item of s) {
-            if (predicate(item))
-                result.add(item);
-        }
-        return result;
-    };
-    // ---------------------------------------------------------------------------
-    // Set operations
-    // ---------------------------------------------------------------------------
-    /**
-     * Returns a new collection containing all items from both collections.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.union(Uniq.fromArray([2, 3, 4])));
-     * // ReadonlySet { 1, 2, 3, 4 }
-     * ```
-     */
-    Uniq.union = (other) => (s) => {
-        const set = s;
-        if (typeof set.union === "function")
-            return set.union(other);
-        const result = new globalThis.Set(s);
-        for (const item of other)
-            result.add(item);
-        return result;
-    };
-    /**
-     * Returns a new collection containing only the items that appear in both collections.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.intersection(Uniq.fromArray([2, 3, 4])));
-     * // ReadonlySet { 2, 3 }
-     * ```
-     */
-    Uniq.intersection = (other) => (s) => {
-        const set = s;
-        if (typeof set.intersection === "function")
-            return set.intersection(other);
-        const result = new globalThis.Set();
-        for (const item of s)
-            if (other.has(item))
-                result.add(item);
-        return result;
-    };
-    /**
-     * Returns a new collection containing only the items from `set` that do not appear in `other`.
-     *
-     * @example
-     * ```ts
-     * pipe(Uniq.fromArray([1, 2, 3, 4]), Uniq.difference(Uniq.fromArray([2, 4])));
-     * // ReadonlySet { 1, 3 }
-     * ```
-     */
-    Uniq.difference = (other) => (s) => {
-        const set = s;
-        if (typeof set.difference === "function")
-            return set.difference(other);
-        const result = new globalThis.Set();
-        for (const item of s)
-            if (!other.has(item))
-                result.add(item);
-        return result;
-    };
-    // ---------------------------------------------------------------------------
-    // Fold
-    // ---------------------------------------------------------------------------
-    /**
-     * Folds the collection into a single value by applying `f` to each item in insertion order.
-     *
-     * @example
-     * ```ts
-     * Uniq.reduce(0, (acc, n) => acc + n)(Uniq.fromArray([1, 2, 3])); // 6
-     * ```
-     */
-    Uniq.reduce = (init, f) => (s) => {
-        let acc = init;
-        for (const item of s) {
-            acc = f(acc, item);
-        }
-        return acc;
-    };
-    // ---------------------------------------------------------------------------
-    // Convert
-    // ---------------------------------------------------------------------------
-    /**
-     * Converts the collection to a readonly array in insertion order.
-     *
-     * @example
-     * ```ts
-     * Uniq.toArray(Uniq.fromArray([3, 1, 2])); // [3, 1, 2]
-     * ```
-     */
-    Uniq.toArray = (s) => [...s];
-})(Uniq || (Uniq = {}));

package/esm/src/Utils/index.js

@@ -1,6 +0,0 @@
-export * from "./Arr.js";
-export * from "./Rec.js";
-export * from "./Num.js";
-export * from "./Str.js";
-export * from "./Dict.js";
-export * from "./Uniq.js";

package/script/mod.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/Composition/index.js"), exports);
-__exportStar(require("./src/Core/index.js"), exports);
-__exportStar(require("./src/Composition/index.js"), exports);

package/script/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/script/src/Composition/compose.js

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

package/script/src/Composition/converge.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.converge = converge;
-function converge(f, transformers) {
-    return (a) => f(...transformers.map((t) => t(a)));
-}