@nlozgachev/pipelined 0.11.0 → 0.13.0

package/esm/src/Utils/Rec.js

@@ -1,215 +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);
-    /**
-     * 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/index.js

@@ -1,4 +0,0 @@
-export * from "./Arr.js";
-export * from "./Rec.js";
-export * from "./Num.js";
-export * from "./Str.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)));
-}

package/script/src/Composition/curry.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.curry4 = exports.curry3 = exports.curry = void 0;
-/**
- * Converts a multi-argument function into a curried function.
- * The inverse of `uncurry`.
- *
- * @example
- * ```ts
- * const add = (a: number, b: number) => a + b;
- * const curriedAdd = curry(add);
- * curriedAdd(1)(2); // 3
- *
- * // Partial application
- * const addTen = curriedAdd(10);
- * addTen(5); // 15
- * ```
- *
- * @see {@link uncurry} for the inverse operation
- * @see {@link curry3} for 3-argument functions
- * @see {@link curry4} for 4-argument functions
- */
-const curry = (f) => (a) => (b) => f(a, b);
-exports.curry = curry;
-/**
- * Converts a 3-argument function into a curried function.
- *
- * @example
- * ```ts
- * const add3 = (a: number, b: number, c: number) => a + b + c;
- * const curriedAdd3 = curry3(add3);
- * curriedAdd3(1)(2)(3); // 6
- * ```
- */
-const curry3 = (f) => (a) => (b) => (c) => f(a, b, c);
-exports.curry3 = curry3;
-/**
- * Converts a 4-argument function into a curried function.
- *
- * @example
- * ```ts
- * const add4 = (a: number, b: number, c: number, d: number) => a + b + c + d;
- * const curriedAdd4 = curry4(add4);
- * curriedAdd4(1)(2)(3)(4); // 10
- * ```
- */
-const curry4 = (f) => (a) => (b) => (c) => (d) => f(a, b, c, d);
-exports.curry4 = curry4;

package/script/src/Composition/flip.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flip = void 0;
-/**
- * Flips the order of arguments for a curried binary function.
- * Converts a data-last function to data-first.
- *
- * @example
- * ```ts
- * // Original data-last (for pipe)
- * pipe(
- *   Option.some(5),
- *   Option.map(n => n * 2)
- * ); // Some(10)
- *
- * // Flipped to data-first
- * const mapFirst = flip(Option.map);
- * mapFirst(Option.some(5))(n => n * 2); // Some(10)
- * ```
- *
- * @see {@link uncurry} for converting curried functions to multi-argument functions
- */
-const flip = (f) => (b) => (a) => f(a)(b);
-exports.flip = flip;

package/script/src/Composition/flow.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flow = flow;
-function flow(...fns) {
-    return (...args) => {
-        if (fns.length === 0)
-            return args[0];
-        const [first, ...rest] = fns;
-        return rest.reduce((acc, fn) => fn(acc), first(...args));
-    };
-}

package/script/src/Composition/fn.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.once = exports.or = exports.and = exports.constVoid = exports.constUndefined = exports.constNull = exports.constFalse = exports.constTrue = exports.constant = exports.identity = void 0;
-/**
- * Returns the value unchanged. The identity function.
- *
- * @example
- * ```ts
- * identity(42); // 42
- * pipe(Option.some(5), Option.fold(() => 0, identity)); // 5
- * ```
- */
-const identity = (a) => a;
-exports.identity = identity;
-/**
- * Creates a function that always returns the given value, ignoring its argument.
- *
- * @example
- * ```ts
- * const always42 = constant(42);
- * always42(); // 42
- * [1, 2, 3].map(constant("x")); // ["x", "x", "x"]
- * ```
- */
-const constant = (a) => () => a;
-exports.constant = constant;
-/** Always returns `true`. */
-const constTrue = () => true;
-exports.constTrue = constTrue;
-/** Always returns `false`. */
-const constFalse = () => false;
-exports.constFalse = constFalse;
-/** Always returns `null`. */
-const constNull = () => null;
-exports.constNull = constNull;
-/** Always returns `undefined`. */
-const constUndefined = () => undefined;
-exports.constUndefined = constUndefined;
-/** Always returns `void`. */
-const constVoid = () => { };
-exports.constVoid = constVoid;
-/**
- * Combines two predicates with logical AND.
- *
- * @example
- * ```ts
- * const isPositive = (n: number) => n > 0;
- * const isEven = (n: number) => n % 2 === 0;
- * const isPositiveEven = and(isPositive, isEven);
- *
- * isPositiveEven(4); // true
- * isPositiveEven(-2); // false
- * isPositiveEven(3); // false
- * ```
- */
-const and = (p1, p2) => (...args) => p1(...args) && p2(...args);
-exports.and = and;
-/**
- * Combines two predicates with logical OR.
- *
- * @example
- * ```ts
- * const isNegative = (n: number) => n < 0;
- * const isZero = (n: number) => n === 0;
- * const isNonPositive = or(isNegative, isZero);
- *
- * isNonPositive(-1); // true
- * isNonPositive(0); // true
- * isNonPositive(1); // false
- * ```
- */
-const or = (p1, p2) => (...args) => p1(...args) || p2(...args);
-exports.or = or;
-/**
- * Creates a function that executes at most once.
- * Subsequent calls return the cached result from the first execution.
- *
- * @example
- * ```ts
- * let count = 0;
- * const initOnce = once(() => { count++; return "initialized"; });
- *
- * initOnce(); // "initialized", count === 1
- * initOnce(); // "initialized", count === 1 (not called again)
- * ```
- */
-const once = (f) => {
-    let called = false;
-    let result;
-    return () => {
-        if (!called) {
-            result = f();
-            called = true;
-        }
-        return result;
-    };
-};
-exports.once = once;

package/script/src/Composition/index.js

@@ -1,29 +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("./compose.js"), exports);
-__exportStar(require("./converge.js"), exports);
-__exportStar(require("./curry.js"), exports);
-__exportStar(require("./flip.js"), exports);
-__exportStar(require("./fn.js"), exports);
-__exportStar(require("./flow.js"), exports);
-__exportStar(require("./juxt.js"), exports);
-__exportStar(require("./memoize.js"), exports);
-__exportStar(require("./not.js"), exports);
-__exportStar(require("./on.js"), exports);
-__exportStar(require("./pipe.js"), exports);
-__exportStar(require("./tap.js"), exports);
-__exportStar(require("./uncurry.js"), exports);

package/script/src/Composition/juxt.js

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

package/script/src/Composition/memoize.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.memoizeWeak = exports.memoize = void 0;
-/**
- * Creates a memoized version of a function that caches results.
- * Subsequent calls with the same argument return the cached result.
- *
- * By default, uses the argument directly as the cache key.
- * For complex arguments, provide a custom `keyFn` to generate cache keys.
- *
- * @example
- * ```ts
- * // Basic usage
- * const expensive = memoize((n: number) => {
- *   console.log("Computing...");
- *   return n * 2;
- * });
- *
- * expensive(5); // logs "Computing...", returns 10
- * expensive(5); // returns 10 (cached, no log)
- * expensive(3); // logs "Computing...", returns 6
- *
- * // With custom key function for objects
- * const fetchUser = memoize(
- *   (opts: { id: string }) => fetch(`/users/${opts.id}`),
- *   opts => opts.id
- * );
- * ```
- */
-const memoize = (f, keyFn = (a) => a) => {
-    const cache = new Map();
-    return (a) => {
-        const key = keyFn(a);
-        if (cache.has(key)) {
-            return cache.get(key);
-        }
-        const result = f(a);
-        cache.set(key, result);
-        return result;
-    };
-};
-exports.memoize = memoize;
-/**
- * Creates a memoized version of a function using WeakMap.
- * Only works with object arguments, but allows garbage collection
- * of cached values when keys are no longer referenced.
- *
- * @example
- * ```ts
- * const processUser = memoizeWeak((user: User) => {
- *   return expensiveOperation(user);
- * });
- *
- * const user = { id: 1, name: "Alice" };
- * processUser(user); // computed
- * processUser(user); // cached
- * // When `user` is garbage collected, cached result is too
- * ```
- */
-const memoizeWeak = (f) => {
-    const cache = new WeakMap();
-    return (a) => {
-        if (cache.has(a)) {
-            return cache.get(a);
-        }
-        const result = f(a);
-        cache.set(a, result);
-        return result;
-    };
-};
-exports.memoizeWeak = memoizeWeak;