@nlozgachev/pipelined 0.11.0 → 0.13.0

package/script/src/Composition/not.js

@@ -1,29 +0,0 @@
-"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/on.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.on = void 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"]
- * ```
- */
-const on = (f, g) => (a, b) => f(g(a), g(b));
-exports.on = on;

package/script/src/Composition/pipe.js

@@ -1,6 +0,0 @@
-"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

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

package/script/src/Composition/uncurry.js

@@ -1,38 +0,0 @@
-"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/Deferred.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deferred = void 0;
-const _store = new WeakMap();
-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 || (exports.Deferred = Deferred = {}));

package/script/src/Core/InternalTypes.js

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

package/script/src/Core/Lens.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lens = void 0;
-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 || (exports.Lens = Lens = {}));

package/script/src/Core/Logged.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logged = void 0;
-var Logged;
-(function (Logged) {
-    /**
-     * Wraps a pure value into a `Logged` with an empty log.
-     *
-     * @example
-     * ```ts
-     * Logged.make<string, number>(42); // { value: 42, log: [] }
-     * ```
-     */
-    Logged.make = (value) => ({ value, log: [] });
-    /**
-     * Creates a `Logged` that records a single log entry and produces no
-     * meaningful value. Use this to append to the log inside a `chain`.
-     *
-     * @example
-     * ```ts
-     * Logged.tell("operation completed"); // { value: undefined, log: ["operation completed"] }
-     * ```
-     */
-    Logged.tell = (entry) => ({ value: undefined, log: [entry] });
-    /**
-     * Transforms the value inside a `Logged` without affecting the log.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Logged.make<string, number>(5),
-     *   Logged.map(n => n * 2),
-     * ); // { value: 10, log: [] }
-     * ```
-     */
-    Logged.map = (f) => (data) => ({
-        value: f(data.value),
-        log: data.log,
-    });
-    /**
-     * Sequences two `Logged` computations, concatenating their logs.
-     * The value from the first is passed to `f`; the resulting log entries are
-     * appended after the entries from the first.
-     *
-     * Data-last — the first computation is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const result = pipe(
-     *   Logged.make<string, number>(1),
-     *   Logged.chain(n => pipe(Logged.tell("step"), Logged.map(() => n + 1))),
-     *   Logged.chain(n => pipe(Logged.tell("done"), Logged.map(() => n * 10))),
-     * );
-     *
-     * Logged.run(result); // [20, ["step", "done"]]
-     * ```
-     */
-    Logged.chain = (f) => (data) => {
-        const next = f(data.value);
-        return { value: next.value, log: [...data.log, ...next.log] };
-    };
-    /**
-     * Applies a function wrapped in a `Logged` to a value wrapped in a `Logged`,
-     * concatenating both logs.
-     *
-     * @example
-     * ```ts
-     * const fn: Logged<string, (n: number) => number> = {
-     *   value: n => n * 2,
-     *   log: ["fn-loaded"],
-     * };
-     * const arg: Logged<string, number> = { value: 5, log: ["arg-loaded"] };
-     *
-     * const result = pipe(fn, Logged.ap(arg));
-     * Logged.run(result); // [10, ["fn-loaded", "arg-loaded"]]
-     * ```
-     */
-    Logged.ap = (arg) => (data) => ({
-        value: data.value(arg.value),
-        log: [...data.log, ...arg.log],
-    });
-    /**
-     * Runs a side effect on the value without changing the `Logged`.
-     * Useful for debugging or inspecting intermediate values.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Logged.make<string, number>(42),
-     *   Logged.tap(n => console.log("value:", n)),
-     * );
-     * ```
-     */
-    Logged.tap = (f) => (data) => {
-        f(data.value);
-        return data;
-    };
-    /**
-     * Extracts the value and log as a `readonly [A, ReadonlyArray<W>]` tuple.
-     * Use this at the boundary where you need to consume both.
-     *
-     * @example
-     * ```ts
-     * const result = pipe(
-     *   Logged.make<string, number>(1),
-     *   Logged.chain(n => pipe(Logged.tell("incremented"), Logged.map(() => n + 1))),
-     * );
-     *
-     * const [value, log] = Logged.run(result);
-     * // value = 2, log = ["incremented"]
-     * ```
-     */
-    Logged.run = (data) => [data.value, data.log];
-})(Logged || (exports.Logged = Logged = {}));

package/script/src/Core/Option.js

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Option = void 0;
-const Result_js_1 = require("./Result.js");
-const _none = { kind: "None" };
-var Option;
-(function (Option) {
-    /**
-     * Creates a Some containing the given value.
-     */
-    Option.some = (value) => ({ kind: "Some", value });
-    /**
-     * Type guard that checks if a Option is Some.
-     */
-    Option.isSome = (data) => data.kind === "Some";
-    /**
-     * Creates a None (empty Option).
-     */
-    Option.none = () => _none;
-    /**
-     * Type guard that checks if a Option is None.
-     */
-    Option.isNone = (data) => data.kind === "None";
-    /**
-     * Creates a Option from a nullable value.
-     * Returns None if the value is null or undefined, Some otherwise.
-     *
-     * @example
-     * ```ts
-     * Option.fromNullable(null); // None
-     * Option.fromNullable(42); // Some(42)
-     * ```
-     */
-    Option.fromNullable = (value) => value === null || value === undefined ? Option.none() : Option.some(value);
-    /**
-     * Extracts the value from a Option, returning null if None.
-     */
-    Option.toNullable = (data) => Option.isSome(data) ? data.value : null;
-    /**
-     * Extracts the value from a Option, returning undefined if None.
-     */
-    Option.toUndefined = (data) => Option.isSome(data) ? data.value : undefined;
-    /**
-     * Creates a Option from a possibly undefined value.
-     * Returns None if undefined, Some otherwise.
-     */
-    Option.fromUndefined = (value) => value === undefined ? Option.none() : Option.some(value);
-    /**
-     * Converts an Option to a Result.
-     * Some becomes Ok, None becomes Err with the provided error.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Option.some(42),
-     *   Option.toResult(() => "Value was missing")
-     * ); // Ok(42)
-     *
-     * pipe(
-     *   Option.none(),
-     *   Option.toResult(() => "Value was missing")
-     * ); // Err("Value was missing")
-     * ```
-     */
-    Option.toResult = (onNone) => (data) => Option.isSome(data) ? Result_js_1.Result.ok(data.value) : Result_js_1.Result.err(onNone());
-    /**
-     * Creates an Option from a Result.
-     * Ok becomes Some, Err becomes None (the error is discarded).
-     *
-     * @example
-     * ```ts
-     * Option.fromResult(Result.ok(42)); // Some(42)
-     * Option.fromResult(Result.err("oops")); // None
-     * ```
-     */
-    Option.fromResult = (data) => Result_js_1.Result.isOk(data) ? Option.some(data.value) : Option.none();
-    /**
-     * Transforms the value inside a Option if it exists.
-     *
-     * @example
-     * ```ts
-     * pipe(Option.some(5), Option.map(n => n * 2)); // Some(10)
-     * pipe(Option.none(), Option.map(n => n * 2)); // None
-     * ```
-     */
-    Option.map = (f) => (data) => Option.isSome(data) ? Option.some(f(data.value)) : data;
-    /**
-     * Chains Option computations. If the first is Some, passes the value to f.
-     * If the first is None, propagates None.
-     *
-     * @example
-     * ```ts
-     * const parseNumber = (s: string): Option<number> => {
-     *   const n = parseInt(s, 10);
-     *   return isNaN(n) ? Option.none() : Option.some(n);
-     * };
-     *
-     * pipe(Option.some("42"), Option.chain(parseNumber)); // Some(42)
-     * pipe(Option.some("abc"), Option.chain(parseNumber)); // None
-     * ```
-     */
-    Option.chain = (f) => (data) => Option.isSome(data) ? f(data.value) : data;
-    /**
-     * Extracts the value from a Option by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Option.some(5),
-     *   Option.fold(
-     *     () => "No value",
-     *     n => `Value: ${n}`
-     *   )
-     * ); // "Value: 5"
-     * ```
-     */
-    Option.fold = (onNone, onSome) => (data) => Option.isSome(data) ? onSome(data.value) : onNone();
-    /**
-     * Pattern matches on a Option, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   optionUser,
-     *   Option.match({
-     *     some: user => `Hello, ${user.name}`,
-     *     none: () => "Hello, stranger"
-     *   })
-     * );
-     * ```
-     */
-    Option.match = (cases) => (data) => Option.isSome(data) ? cases.some(data.value) : cases.none();
-    /**
-     * Returns the value inside an Option, or a default value if None.
-     * The default is a thunk `() => B` — evaluated only when the Option is None.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Option.some(5), Option.getOrElse(() => 0)); // 5
-     * pipe(Option.none(), Option.getOrElse(() => 0)); // 0
-     * pipe(Option.none<string>(), Option.getOrElse(() => null)); // null — typed as string | null
-     * ```
-     */
-    Option.getOrElse = (defaultValue) => (data) => Option.isSome(data) ? data.value : defaultValue();
-    /**
-     * Executes a side effect on the value without changing the Option.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Option.some(5),
-     *   Option.tap(n => console.log("Value:", n)),
-     *   Option.map(n => n * 2)
-     * );
-     * ```
-     */
-    Option.tap = (f) => (data) => {
-        if (Option.isSome(data))
-            f(data.value);
-        return data;
-    };
-    /**
-     * Filters a Option based on a predicate.
-     * Returns None if the predicate returns false or if the Option is already None.
-     *
-     * @example
-     * ```ts
-     * pipe(Option.some(5), Option.filter(n => n > 3)); // Some(5)
-     * pipe(Option.some(2), Option.filter(n => n > 3)); // None
-     * ```
-     */
-    Option.filter = (predicate) => (data) => Option.isSome(data) ? (predicate(data.value) ? data : Option.none()) : data;
-    /**
-     * Recovers from a None by providing a fallback Option.
-     * The fallback can produce a different type, widening the result to `Option<A | B>`.
-     */
-    Option.recover = (fallback) => (data) => Option.isSome(data) ? data : fallback();
-    /**
-     * Applies a function wrapped in a Option to a value wrapped in a Option.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Option.some(add),
-     *   Option.ap(Option.some(5)),
-     *   Option.ap(Option.some(3))
-     * ); // Some(8)
-     * ```
-     */
-    Option.ap = (arg) => (data) => Option.isSome(data) && Option.isSome(arg) ? Option.some(data.value(arg.value)) : Option.none();
-})(Option || (exports.Option = Option = {}));