@nlozgachev/pipelined 0.12.0 → 0.14.0

package/esm/src/Core/Logged.js

@@ -1,111 +0,0 @@
-export 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 || (Logged = {}));

package/esm/src/Core/Option.js

@@ -1,191 +0,0 @@
-import { Result } from "./Result.js";
-const _none = { kind: "None" };
-export 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.ok(data.value) : 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.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 || (Option = {}));

package/esm/src/Core/Optional.js

@@ -1,160 +0,0 @@
-import { Option } from "./Option.js";
-export var Optional;
-(function (Optional) {
-    /**
-     * Constructs an Optional from a getter (returning Option<A>) and a setter.
-     *
-     * @example
-     * ```ts
-     * const firstChar = Optional.make(
-     *   (s: string) => s.length > 0 ? Option.some(s[0]) : Option.none(),
-     *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
-     * );
-     * ```
-     */
-    Optional.make = (get, set) => ({ get, set });
-    /**
-     * Creates an Optional that focuses on an optional property of an object.
-     * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
-     * Call with the structure type first, then the key.
-     *
-     * @example
-     * ```ts
-     * type Profile = { username: string; bio?: string };
-     * const bioOpt = Optional.prop<Profile>()("bio");
-     * ```
-     */
-    Optional.prop = () => (key) => Optional.make((s) => {
-        const val = s[key];
-        return val != null ? Option.some(val) : Option.none();
-    }, (a) => (s) => ({ ...s, [key]: a }));
-    /**
-     * Creates an Optional that focuses on an element at a given index in an array.
-     * Returns None when the index is out of bounds; set is a no-op when out of bounds.
-     *
-     * @example
-     * ```ts
-     * const firstItem = Optional.index<string>(0);
-     *
-     * pipe(["a", "b"], Optional.get(firstItem)); // Some("a")
-     * pipe([], Optional.get(firstItem));         // None
-     * ```
-     */
-    Optional.index = (i) => Optional.make((arr) => i >= 0 && i < arr.length ? Option.some(arr[i]) : Option.none(), (a) => (arr) => {
-        if (i < 0 || i >= arr.length)
-            return arr;
-        const copy = [...arr];
-        copy[i] = a;
-        return copy;
-    });
-    /**
-     * Reads the focused value from a structure, returning Option<A>.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
-     * ```
-     */
-    Optional.get = (opt) => (s) => opt.get(s);
-    /**
-     * Replaces the focused value within a structure.
-     * For indexed focuses, this is a no-op when the index is out of bounds.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.set(bioOpt)("hello"));
-     * ```
-     */
-    Optional.set = (opt) => (a) => (s) => opt.set(a)(s);
-    /**
-     * Applies a function to the focused value if it is present; returns the
-     * structure unchanged if the focus is absent.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.modify(bioOpt)(s => s.toUpperCase()));
-     * ```
-     */
-    Optional.modify = (opt) => (f) => (s) => {
-        const val = opt.get(s);
-        return val.kind === "None" ? s : opt.set(f(val.value))(s);
-    };
-    /**
-     * Returns the focused value or a default when the focus is absent.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
-     * ```
-     */
-    Optional.getOrElse = (opt) => (defaultValue) => (s) => {
-        const val = opt.get(s);
-        return val.kind === "Some" ? val.value : defaultValue();
-    };
-    /**
-     * Extracts a value from an Optional focus using handlers for the present
-     * and absent cases.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.fold(bioOpt)(() => "no bio", (bio) => bio.toUpperCase()));
-     * ```
-     */
-    Optional.fold = (opt) => (onNone, onSome) => (s) => {
-        const val = opt.get(s);
-        return val.kind === "Some" ? onSome(val.value) : onNone();
-    };
-    /**
-     * Pattern matches on an Optional focus using a named-case object.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   profile,
-     *   Optional.match(bioOpt)({ none: () => "no bio", some: (bio) => bio }),
-     * );
-     * ```
-     */
-    Optional.match = (opt) => (cases) => (s) => {
-        const val = opt.get(s);
-        return val.kind === "Some" ? cases.some(val.value) : cases.none();
-    };
-    /**
-     * Composes two Optionals: focuses through the outer, then through the inner.
-     * Returns None if either focus is absent.
-     *
-     * @example
-     * ```ts
-     * const deepOpt = pipe(
-     *   Optional.prop<User>()("address"),
-     *   Optional.andThen(Optional.prop<Address>()("landmark")),
-     * );
-     * ```
-     */
-    Optional.andThen = (inner) => (outer) => Optional.make((s) => {
-        const mid = outer.get(s);
-        return mid.kind === "None" ? Option.none() : inner.get(mid.value);
-    }, (b) => (s) => {
-        const mid = outer.get(s);
-        return mid.kind === "None" ? s : outer.set(inner.set(b)(mid.value))(s);
-    });
-    /**
-     * Composes an Optional with a Lens, producing an Optional.
-     * The Lens focuses within the value found by the Optional.
-     *
-     * @example
-     * ```ts
-     * const cityOpt = pipe(
-     *   Optional.prop<User>()("address"),
-     *   Optional.andThenLens(Lens.prop<Address>()("city")),
-     * );
-     * ```
-     */
-    Optional.andThenLens = (inner) => (outer) => Optional.make((s) => {
-        const mid = outer.get(s);
-        return mid.kind === "None" ? Option.none() : Option.some(inner.get(mid.value));
-    }, (b) => (s) => {
-        const mid = outer.get(s);
-        return mid.kind === "None" ? s : outer.set(inner.set(b)(mid.value))(s);
-    });
-})(Optional || (Optional = {}));

package/esm/src/Core/Predicate.js

@@ -1,133 +0,0 @@
-export var Predicate;
-(function (Predicate) {
-    /**
-     * Negates a predicate: the result passes exactly when the original fails.
-     *
-     * @example
-     * ```ts
-     * const isBlank: Predicate<string> = s => s.trim().length === 0;
-     * const isNotBlank = Predicate.not(isBlank);
-     *
-     * isNotBlank("hello");  // true
-     * isNotBlank("   ");    // false
-     * ```
-     */
-    Predicate.not = (p) => (a) => !p(a);
-    /**
-     * Combines two predicates with logical AND: passes only when both hold.
-     *
-     * Data-last — the first predicate is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const isPositive: Predicate<number> = n => n > 0;
-     * const isEven: Predicate<number> = n => n % 2 === 0;
-     *
-     * const isPositiveEven: Predicate<number> = pipe(isPositive, Predicate.and(isEven));
-     *
-     * isPositiveEven(4);   // true
-     * isPositiveEven(3);   // false — positive but odd
-     * isPositiveEven(-2);  // false — even but not positive
-     * ```
-     */
-    Predicate.and = (second) => (first) => (a) => first(a) && second(a);
-    /**
-     * Combines two predicates with logical OR: passes when either holds.
-     *
-     * Data-last — the first predicate is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const isChild: Predicate<number> = n => n < 13;
-     * const isSenior: Predicate<number> = n => n >= 65;
-     *
-     * const getsDiscount: Predicate<number> = pipe(isChild, Predicate.or(isSenior));
-     *
-     * getsDiscount(8);   // true
-     * getsDiscount(70);  // true
-     * getsDiscount(30);  // false
-     * ```
-     */
-    Predicate.or = (second) => (first) => (a) => first(a) || second(a);
-    /**
-     * Adapts a `Predicate<A>` to work on a different input type `B` by applying `f`
-     * to extract the relevant `A` from a `B` before running the check.
-     *
-     * Data-last — the predicate is the data being piped; `f` is the extractor.
-     *
-     * @example
-     * ```ts
-     * type User = { name: string; age: number };
-     *
-     * const isAdult: Predicate<number> = n => n >= 18;
-     *
-     * // Lift isAdult to work on Users by extracting the age field
-     * const isAdultUser: Predicate<User> = pipe(
-     *   isAdult,
-     *   Predicate.using((u: User) => u.age)
-     * );
-     *
-     * isAdultUser({ name: "Alice", age: 30 });  // true
-     * isAdultUser({ name: "Bob",   age: 15 });  // false
-     * ```
-     */
-    Predicate.using = (f) => (p) => (b) => p(f(b));
-    /**
-     * Combines an array of predicates with AND: passes only when every predicate holds.
-     * Returns `true` for an empty array (vacuous truth).
-     *
-     * @example
-     * ```ts
-     * const checks: Predicate<string>[] = [
-     *   s => s.length > 0,
-     *   s => s.length <= 100,
-     *   s => !s.includes("<"),
-     * ];
-     *
-     * Predicate.all(checks)("hello");  // true
-     * Predicate.all(checks)("");       // false — too short
-     * Predicate.all(checks)("<b>");    // false — contains "<"
-     * Predicate.all([])("anything");   // true
-     * ```
-     */
-    Predicate.all = (predicates) => (a) => predicates.every((p) => p(a));
-    /**
-     * Combines an array of predicates with OR: passes when at least one holds.
-     * Returns `false` for an empty array.
-     *
-     * @example
-     * ```ts
-     * const acceptedFormats: Predicate<string>[] = [
-     *   s => s.endsWith(".jpg"),
-     *   s => s.endsWith(".png"),
-     *   s => s.endsWith(".webp"),
-     * ];
-     *
-     * Predicate.any(acceptedFormats)("photo.jpg");   // true
-     * Predicate.any(acceptedFormats)("photo.gif");   // false
-     * Predicate.any([])("anything");                 // false
-     * ```
-     */
-    Predicate.any = (predicates) => (a) => predicates.some((p) => p(a));
-    /**
-     * Converts a `Refinement<A, B>` into a `Predicate<A>`, discarding the compile-time
-     * narrowing. Use this when you want to combine a type guard with plain predicates
-     * using `and`, `or`, or `all`.
-     *
-     * @example
-     * ```ts
-     * const isString: Refinement<unknown, string> =
-     *   Refinement.make(x => typeof x === "string");
-     *
-     * const isShortString: Predicate<unknown> = pipe(
-     *   Predicate.fromRefinement(isString),
-     *   Predicate.and(x => (x as string).length < 10)
-     * );
-     *
-     * isShortString("hi");            // true
-     * isShortString("a very long string that exceeds ten characters");  // false
-     * isShortString(42);              // false
-     * ```
-     */
-    Predicate.fromRefinement = (r) => r;
-})(Predicate || (Predicate = {}));