@nlozgachev/pipelined 0.12.0 → 0.14.0

package/dist/utils.mjs

@@ -0,0 +1,18 @@
+import {
+  Arr,
+  Dict,
+  Num,
+  Rec,
+  Str,
+  Uniq
+} from "./chunk-FAZN3IWZ.mjs";
+import "./chunk-QPTGO5AS.mjs";
+import "./chunk-DBIC62UV.mjs";
+export {
+  Arr,
+  Dict,
+  Num,
+  Rec,
+  Str,
+  Uniq
+};

package/package.json

@@ -1,71 +1,66 @@
 {
-  "name": "@nlozgachev/pipelined",
-  "version": "0.12.0",
-  "description": "Simple functional programming toolkit for TypeScript",
-  "keywords": [
-    "functional",
-    "fp",
-    "typescript",
-    "composition",
-    "pipe"
-  ],
-  "homepage": "https://pipelined.lozgachev.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/nlozgachev/pipelined"
-  },
-  "license": "BSD-3-Clause",
-  "types": "./types/mod.d.ts",
-  "exports": {
-    "./composition": {
-      "import": {
-        "types": "./types/src/Composition/index.d.ts",
-        "default": "./esm/src/Composition/index.js"
-      },
-      "require": {
-        "types": "./types/src/Composition/index.d.ts",
-        "default": "./script/src/Composition/index.js"
-      }
-    },
-    "./core": {
-      "import": {
-        "types": "./types/src/Core/index.d.ts",
-        "default": "./esm/src/Core/index.js"
-      },
-      "require": {
-        "types": "./types/src/Core/index.d.ts",
-        "default": "./script/src/Core/index.js"
-      }
-    },
-    "./utils": {
-      "import": {
-        "types": "./types/src/Utils/index.d.ts",
-        "default": "./esm/src/Utils/index.js"
-      },
-      "require": {
-        "types": "./types/src/Utils/index.d.ts",
-        "default": "./script/src/Utils/index.js"
-      }
-    },
-    "./types": {
-      "import": {
-        "types": "./types/src/Types/index.d.ts",
-        "default": "./esm/src/Types/index.js"
-      },
-      "require": {
-        "types": "./types/src/Types/index.d.ts",
-        "default": "./script/src/Types/index.js"
-      }
-    }
-  },
-  "scripts": {},
-  "sideEffects": false,
-  "engines": {
-    "node": ">=22"
-  },
-  "files": [
-    "esm",
-    "script",
-    "types"
-  ]
+	"name": "@nlozgachev/pipelined",
+	"version": "0.14.0",
+	"description": "Simple functional programming toolkit for TypeScript",
+	"license": "BSD-3-Clause",
+	"homepage": "https://pipelined.lozgachev.dev",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nlozgachev/pipelined.git"
+	},
+	"keywords": [
+		"functional",
+		"fp",
+		"typescript",
+		"composition",
+		"pipe"
+	],
+	"types": "./dist/index.d.ts",
+	"sideEffects": false,
+	"engines": {
+		"node": ">=22"
+	},
+	"files": [
+		"dist"
+	],
+	"exports": {
+		"./composition": {
+			"types": "./dist/composition.d.ts",
+			"import": "./dist/composition.mjs",
+			"require": "./dist/composition.cjs"
+		},
+		"./core": {
+			"types": "./dist/core.d.ts",
+			"import": "./dist/core.mjs",
+			"require": "./dist/core.cjs"
+		},
+		"./utils": {
+			"types": "./dist/utils.d.ts",
+			"import": "./dist/utils.mjs",
+			"require": "./dist/utils.cjs"
+		},
+		"./types": {
+			"types": "./dist/types.d.ts",
+			"import": "./dist/types.mjs",
+			"require": "./dist/types.cjs"
+		}
+	},
+	"scripts": {
+		"test": "vitest run",
+		"bench": "vitest bench",
+		"build": "tsup",
+		"format": "dprint fmt",
+		"format:check": "dprint check",
+		"typecheck": "tsc --noEmit",
+		"lint": "oxlint src/",
+		"publish:npm": "pnpm build && npm publish --access public"
+	},
+	"devDependencies": {
+		"@types/node": "25.5.0",
+		"dprint": "0.53.0",
+		"oxlint": "1.56.0",
+		"tsup": "8.5.1",
+		"typescript": "5.9.3",
+		"vitest": "4.1.0"
+	}
 }

package/esm/mod.js

@@ -1,3 +0,0 @@
-export * from "./src/Composition/index.js";
-export * from "./src/Core/index.js";
-export * from "./src/Composition/index.js";

package/esm/package.json

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

package/esm/src/Composition/compose.js

@@ -1,3 +0,0 @@
-export function compose(...fns) {
-    return (arg) => fns.reduceRight((acc, fn) => fn(acc), arg);
-}

package/esm/src/Composition/converge.js

@@ -1,3 +0,0 @@
-export function converge(f, transformers) {
-    return (a) => f(...transformers.map((t) => t(a)));
-}

package/esm/src/Composition/curry.js

@@ -1,42 +0,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
- */
-export const curry = (f) => (a) => (b) => f(a, b);
-/**
- * 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
- * ```
- */
-export const curry3 = (f) => (a) => (b) => (c) => f(a, b, c);
-/**
- * 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
- * ```
- */
-export const curry4 = (f) => (a) => (b) => (c) => (d) => f(a, b, c, d);

package/esm/src/Composition/flip.js

@@ -1,20 +0,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
- */
-export const flip = (f) => (b) => (a) => f(a)(b);

package/esm/src/Composition/flow.js

@@ -1,8 +0,0 @@
-export 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/esm/src/Composition/fn.js

@@ -1,85 +0,0 @@
-/**
- * Returns the value unchanged. The identity function.
- *
- * @example
- * ```ts
- * identity(42); // 42
- * pipe(Option.some(5), Option.fold(() => 0, identity)); // 5
- * ```
- */
-export const identity = (a) => a;
-/**
- * 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"]
- * ```
- */
-export const constant = (a) => () => a;
-/** Always returns `true`. */
-export const constTrue = () => true;
-/** Always returns `false`. */
-export const constFalse = () => false;
-/** Always returns `null`. */
-export const constNull = () => null;
-/** Always returns `undefined`. */
-export const constUndefined = () => undefined;
-/** Always returns `void`. */
-export const 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
- * ```
- */
-export const and = (p1, p2) => (...args) => p1(...args) && p2(...args);
-/**
- * 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
- * ```
- */
-export const or = (p1, p2) => (...args) => p1(...args) || p2(...args);
-/**
- * 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)
- * ```
- */
-export const once = (f) => {
-    let called = false;
-    let result;
-    return () => {
-        if (!called) {
-            result = f();
-            called = true;
-        }
-        return result;
-    };
-};

package/esm/src/Composition/index.js

@@ -1,13 +0,0 @@
-export * from "./compose.js";
-export * from "./converge.js";
-export * from "./curry.js";
-export * from "./flip.js";
-export * from "./fn.js";
-export * from "./flow.js";
-export * from "./juxt.js";
-export * from "./memoize.js";
-export * from "./not.js";
-export * from "./on.js";
-export * from "./pipe.js";
-export * from "./tap.js";
-export * from "./uncurry.js";

package/esm/src/Composition/juxt.js

@@ -1,3 +0,0 @@
-export function juxt(fns) {
-    return (a) => fns.map((f) => f(a));
-}

package/esm/src/Composition/memoize.js

@@ -1,66 +0,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
- * );
- * ```
- */
-export 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;
-    };
-};
-/**
- * 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
- * ```
- */
-export 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;
-    };
-};

package/esm/src/Composition/not.js

@@ -1,25 +0,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)
- * );
- * ```
- */
-export const not = (predicate) => (...args) => !predicate(...args);

package/esm/src/Composition/on.js

@@ -1,12 +0,0 @@
-/**
- * Applies a projection to both arguments of a binary function before calling it.
- * Most useful for building comparators and equality checks over projected values.
- *
- * @example
- * ```ts
- * const byLength = on((a: number, b: number) => a - b, (s: string) => s.length);
- *
- * ["banana", "fig", "apple"].sort(byLength); // ["fig", "apple", "banana"]
- * ```
- */
-export const on = (f, g) => (a, b) => f(g(a), g(b));

package/esm/src/Composition/pipe.js

@@ -1,3 +0,0 @@
-export function pipe(a, ...fns) {
-    return fns.reduce((acc, fn) => fn(acc), a);
-}

package/esm/src/Composition/tap.js

@@ -1,33 +0,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.some(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
- */
-export const tap = (f) => (a) => {
-    f(a);
-    return a;
-};

package/esm/src/Composition/uncurry.js

@@ -1,32 +0,0 @@
-// deno-lint-ignore no-explicit-any
-export 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
- * ```
- */
-export const uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
-/**
- * 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
- * ```
- */
-export const uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);

package/esm/src/Core/Deferred.js

@@ -1,30 +0,0 @@
-const _store = new WeakMap();
-export var Deferred;
-(function (Deferred) {
-    /**
-     * Wraps a `Promise` into a `Deferred`, structurally excluding rejection handlers,
-     * `.catch()`, `.finally()`, and chainable `.then()`.
-     *
-     * @example
-     * ```ts
-     * const d = Deferred.fromPromise(Promise.resolve("hello"));
-     * const value = await d; // "hello"
-     * ```
-     */
-    Deferred.fromPromise = (p) => {
-        const d = ({ then: ((f) => p.then(f)) });
-        _store.set(d, p);
-        return d;
-    };
-    /**
-     * Converts a `Deferred` back into a `Promise`.
-     *
-     * @example
-     * ```ts
-     * const p = Deferred.toPromise(Deferred.fromPromise(Promise.resolve(42)));
-     * // p is Promise<42>
-     * ```
-     */
-    Deferred.toPromise = (d) => _store.get(d) ??
-        new Promise((resolve) => d.then(resolve));
-})(Deferred || (Deferred = {}));

package/esm/src/Core/InternalTypes.js

@@ -1 +0,0 @@
-export {};

package/esm/src/Core/Lens.js

@@ -1,98 +0,0 @@
-export var Lens;
-(function (Lens) {
-    /**
-     * Constructs a Lens from a getter and a setter.
-     *
-     * @example
-     * ```ts
-     * const nameLens = Lens.make(
-     *   (user: User) => user.name,
-     *   (name) => (user) => ({ ...user, name }),
-     * );
-     * ```
-     */
-    Lens.make = (get, set) => ({ get, set });
-    /**
-     * Creates a Lens that focuses on a property of an object.
-     * Call with the structure type first, then the key.
-     *
-     * @example
-     * ```ts
-     * const nameLens = Lens.prop<User>()("name");
-     * ```
-     */
-    Lens.prop = () => (key) => Lens.make((s) => s[key], (a) => (s) => ({ ...s, [key]: a }));
-    /**
-     * Reads the focused value from a structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.get(nameLens)); // "Alice"
-     * ```
-     */
-    Lens.get = (lens) => (s) => lens.get(s);
-    /**
-     * Replaces the focused value within a structure, returning a new structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.set(nameLens)("Bob")); // new User with name "Bob"
-     * ```
-     */
-    Lens.set = (lens) => (a) => (s) => lens.set(a)(s);
-    /**
-     * Applies a function to the focused value, returning a new structure.
-     *
-     * @example
-     * ```ts
-     * pipe(user, Lens.modify(nameLens)(n => n.toUpperCase())); // "ALICE"
-     * ```
-     */
-    Lens.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
-    /**
-     * Composes two Lenses: focuses through the outer, then through the inner.
-     * Use in a pipe chain to build up a deep focus step by step.
-     *
-     * @example
-     * ```ts
-     * const userCityLens = pipe(
-     *   Lens.prop<User>()("address"),
-     *   Lens.andThen(Lens.prop<Address>()("city")),
-     * );
-     * ```
-     */
-    Lens.andThen = (inner) => (outer) => Lens.make((s) => inner.get(outer.get(s)), (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s));
-    /**
-     * Composes a Lens with an Optional, producing an Optional.
-     * Use when the next step in the focus is optional (may be absent).
-     *
-     * @example
-     * ```ts
-     * const userBioOpt = pipe(
-     *   Lens.prop<User>()("profile"),
-     *   Lens.andThenOptional(Optional.prop<Profile>()("bio")),
-     * );
-     * ```
-     */
-    Lens.andThenOptional = (inner) => (outer) => ({
-        get: (s) => inner.get(outer.get(s)),
-        set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s),
-    });
-    /**
-     * Converts a Lens to an Optional. Every Lens is a valid Optional
-     * whose get always returns Some.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Lens.prop<User>()("address"),
-     *   Lens.toOptional,
-     *   Optional.andThen(Optional.prop<Address>()("landmark")),
-     * );
-     * ```
-     */
-    Lens.toOptional = (lens) => ({
-        get: (s) => ({ kind: "Some", value: lens.get(s) }),
-        set: lens.set,
-    });
-})(Lens || (Lens = {}));