@nlozgachev/pipelined 0.12.0 → 0.13.0

package/esm/src/Core/These.js

@@ -1,245 +0,0 @@
-export var These;
-(function (These) {
-    /**
-     * Creates a These holding only a first value.
-     *
-     * @example
-     * ```ts
-     * These.first(42); // { kind: "First", first: 42 }
-     * ```
-     */
-    These.first = (value) => ({ kind: "First", first: value });
-    /**
-     * Creates a These holding only a second value.
-     *
-     * @example
-     * ```ts
-     * These.second("warning"); // { kind: "Second", second: "warning" }
-     * ```
-     */
-    These.second = (value) => ({ kind: "Second", second: value });
-    /**
-     * Creates a These holding both a first and a second value simultaneously.
-     *
-     * @example
-     * ```ts
-     * These.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
-     * ```
-     */
-    These.both = (first, second) => ({
-        kind: "Both",
-        first,
-        second,
-    });
-    /**
-     * Type guard — checks if a These holds only a first value.
-     */
-    These.isFirst = (data) => data.kind === "First";
-    /**
-     * Type guard — checks if a These holds only a second value.
-     */
-    These.isSecond = (data) => data.kind === "Second";
-    /**
-     * Type guard — checks if a These holds both values simultaneously.
-     */
-    These.isBoth = (data) => data.kind === "Both";
-    /**
-     * Returns true if the These contains a first value (First or Both).
-     */
-    These.hasFirst = (data) => data.kind === "First" || data.kind === "Both";
-    /**
-     * Returns true if the These contains a second value (Second or Both).
-     */
-    These.hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
-    /**
-     * Transforms the first value, leaving the second unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(These.first(5), These.mapFirst(n => n * 2));           // First(10)
-     * pipe(These.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
-     * pipe(These.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
-     * ```
-     */
-    These.mapFirst = (f) => (data) => {
-        if (These.isSecond(data))
-            return data;
-        if (These.isFirst(data))
-            return These.first(f(data.first));
-        return These.both(f(data.first), data.second);
-    };
-    /**
-     * Transforms the second value, leaving the first unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(These.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
-     * pipe(These.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
-     * ```
-     */
-    These.mapSecond = (f) => (data) => {
-        if (These.isFirst(data))
-            return data;
-        if (These.isSecond(data))
-            return These.second(f(data.second));
-        return These.both(data.first, f(data.second));
-    };
-    /**
-     * Transforms both the first and second values independently.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   These.both(5, "warn"),
-     *   These.mapBoth(n => n * 2, e => e.toUpperCase())
-     * ); // Both(10, "WARN")
-     * ```
-     */
-    These.mapBoth = (onFirst, onSecond) => (data) => {
-        if (These.isSecond(data))
-            return These.second(onSecond(data.second));
-        if (These.isFirst(data))
-            return These.first(onFirst(data.first));
-        return These.both(onFirst(data.first), onSecond(data.second));
-    };
-    /**
-     * Chains These computations by passing the first value to f.
-     * Second propagates unchanged; First and Both apply f to the first value.
-     *
-     * @example
-     * ```ts
-     * const double = (n: number): These<number, string> => These.first(n * 2);
-     *
-     * pipe(These.first(5), These.chainFirst(double));            // First(10)
-     * pipe(These.both(5, "warn"), These.chainFirst(double));     // First(10)
-     * pipe(These.second("warn"), These.chainFirst(double));      // Second("warn")
-     * ```
-     */
-    These.chainFirst = (f) => (data) => {
-        if (These.isSecond(data))
-            return data;
-        return f(data.first);
-    };
-    /**
-     * Chains These computations by passing the second value to f.
-     * First propagates unchanged; Second and Both apply f to the second value.
-     *
-     * @example
-     * ```ts
-     * const shout = (s: string): These<number, string> => These.second(s.toUpperCase());
-     *
-     * pipe(These.second("warn"), These.chainSecond(shout));      // Second("WARN")
-     * pipe(These.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
-     * pipe(These.first(5), These.chainSecond(shout));            // First(5)
-     * ```
-     */
-    These.chainSecond = (f) => (data) => {
-        if (These.isFirst(data))
-            return data;
-        return f(data.second);
-    };
-    /**
-     * Extracts a value from a These by providing handlers for all three cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   these,
-     *   These.fold(
-     *     a => `First: ${a}`,
-     *     b => `Second: ${b}`,
-     *     (a, b) => `Both: ${a} / ${b}`
-     *   )
-     * );
-     * ```
-     */
-    These.fold = (onFirst, onSecond, onBoth) => (data) => {
-        if (These.isSecond(data))
-            return onSecond(data.second);
-        if (These.isFirst(data))
-            return onFirst(data.first);
-        return onBoth(data.first, data.second);
-    };
-    /**
-     * Pattern matches on a These, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   these,
-     *   These.match({
-     *     first: a => `First: ${a}`,
-     *     second: b => `Second: ${b}`,
-     *     both: (a, b) => `Both: ${a} / ${b}`
-     *   })
-     * );
-     * ```
-     */
-    These.match = (cases) => (data) => {
-        if (These.isSecond(data))
-            return cases.second(data.second);
-        if (These.isFirst(data))
-            return cases.first(data.first);
-        return cases.both(data.first, data.second);
-    };
-    /**
-     * Returns the first value, or a default if the These has no first value.
-     * The default can be a different type, widening the result to `A | C`.
-     *
-     * @example
-     * ```ts
-     * pipe(These.first(5), These.getFirstOrElse(() => 0));            // 5
-     * pipe(These.both(5, "warn"), These.getFirstOrElse(() => 0));     // 5
-     * pipe(These.second("warn"), These.getFirstOrElse(() => 0));      // 0
-     * pipe(These.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
-     * ```
-     */
-    These.getFirstOrElse = (defaultValue) => (data) => These.hasFirst(data) ? data.first : defaultValue();
-    /**
-     * Returns the second value, or a default if the These has no second value.
-     * The default can be a different type, widening the result to `B | D`.
-     *
-     * @example
-     * ```ts
-     * pipe(These.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
-     * pipe(These.both(5, "warn"), These.getSecondOrElse(() => "none")); // "warn"
-     * pipe(These.first(5), These.getSecondOrElse(() => "none"));       // "none"
-     * pipe(These.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
-     * ```
-     */
-    These.getSecondOrElse = (defaultValue) => (data) => These.hasSecond(data) ? data.second : defaultValue();
-    /**
-     * Executes a side effect on the first value without changing the These.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(These.first(5), These.tap(console.log)); // logs 5, returns First(5)
-     * ```
-     */
-    These.tap = (f) => (data) => {
-        if (These.hasFirst(data))
-            f(data.first);
-        return data;
-    };
-    /**
-     * Swaps the roles of first and second values.
-     * - First(a)    → Second(a)
-     * - Second(b)   → First(b)
-     * - Both(a, b)  → Both(b, a)
-     *
-     * @example
-     * ```ts
-     * These.swap(These.first(5));            // Second(5)
-     * These.swap(These.second("warn"));      // First("warn")
-     * These.swap(These.both(5, "warn"));     // Both("warn", 5)
-     * ```
-     */
-    These.swap = (data) => {
-        if (These.isSecond(data))
-            return These.first(data.second);
-        if (These.isFirst(data))
-            return These.second(data.first);
-        return These.both(data.second, data.first);
-    };
-})(These || (These = {}));

package/esm/src/Core/Tuple.js

@@ -1,112 +0,0 @@
-export var Tuple;
-(function (Tuple) {
-    /**
-     * Creates a pair from two values.
-     *
-     * @example
-     * ```ts
-     * Tuple.make("Paris", 2_161_000); // ["Paris", 2161000]
-     * ```
-     */
-    Tuple.make = (first, second) => [first, second];
-    /**
-     * Returns the first value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.first(Tuple.make("Paris", 2_161_000)); // "Paris"
-     * ```
-     */
-    Tuple.first = (tuple) => tuple[0];
-    /**
-     * Returns the second value from the pair.
-     *
-     * @example
-     * ```ts
-     * Tuple.second(Tuple.make("Paris", 2_161_000)); // 2161000
-     * ```
-     */
-    Tuple.second = (tuple) => tuple[1];
-    /**
-     * Transforms the first value, leaving the second unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.make("alice", 42), Tuple.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
-     * ```
-     */
-    Tuple.mapFirst = (f) => (tuple) => [f(tuple[0]), tuple[1]];
-    /**
-     * Transforms the second value, leaving the first unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.make("alice", 42), Tuple.mapSecond((n) => n * 2)); // ["alice", 84]
-     * ```
-     */
-    Tuple.mapSecond = (f) => (tuple) => [tuple[0], f(tuple[1])];
-    /**
-     * Transforms both values independently in a single step.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.make("alice", 42),
-     *   Tuple.mapBoth(
-     *     (name) => name.toUpperCase(),
-     *     (score) => score * 2,
-     *   ),
-     * ); // ["ALICE", 84]
-     * ```
-     */
-    Tuple.mapBoth = (onFirst, onSecond) => (tuple) => [
-        onFirst(tuple[0]),
-        onSecond(tuple[1]),
-    ];
-    /**
-     * Applies a binary function to both values, collapsing the pair into a single value.
-     * Useful as the final step when consuming a pair in a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(Tuple.make("Alice", 100), Tuple.fold((name, score) => `${name}: ${score}`));
-     * // "Alice: 100"
-     * ```
-     */
-    Tuple.fold = (f) => (tuple) => f(tuple[0], tuple[1]);
-    /**
-     * Swaps the two values: `[A, B]` becomes `[B, A]`.
-     *
-     * @example
-     * ```ts
-     * Tuple.swap(Tuple.make("key", 1)); // [1, "key"]
-     * ```
-     */
-    Tuple.swap = (tuple) => [tuple[1], tuple[0]];
-    /**
-     * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
-     *
-     * @example
-     * ```ts
-     * Tuple.toArray(Tuple.make("hello", 42)); // ["hello", 42]
-     * ```
-     */
-    Tuple.toArray = (tuple) => [...tuple];
-    /**
-     * Runs a side effect with both values without changing the pair.
-     * Useful for logging or debugging in the middle of a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Tuple.make("Paris", 2_161_000),
-     *   Tuple.tap((city, pop) => console.log(`${city}: ${pop}`)),
-     *   Tuple.mapSecond((n) => n / 1_000_000),
-     * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
-     * ```
-     */
-    Tuple.tap = (f) => (tuple) => {
-        f(tuple[0], tuple[1]);
-        return tuple;
-    };
-})(Tuple || (Tuple = {}));

package/esm/src/Core/Validation.js

@@ -1,212 +0,0 @@
-export var Validation;
-(function (Validation) {
-    /**
-     * Wraps a value in a valid Validation.
-     *
-     * @example
-     * ```ts
-     * Validation.valid(42); // Valid(42)
-     * ```
-     */
-    Validation.valid = (value) => ({
-        kind: "Valid",
-        value,
-    });
-    /**
-     * Creates an invalid Validation from a single error.
-     *
-     * @example
-     * ```ts
-     * Validation.invalid("Invalid input");
-     * ```
-     */
-    Validation.invalid = (error) => ({
-        kind: "Invalid",
-        errors: [error],
-    });
-    /**
-     * Creates an invalid Validation from multiple errors.
-     *
-     * @example
-     * ```ts
-     * Validation.invalidAll(["Invalid input"]);
-     * ```
-     */
-    Validation.invalidAll = (errors) => ({
-        kind: "Invalid",
-        errors,
-    });
-    /**
-     * Type guard that checks if a Validation is valid.
-     */
-    Validation.isValid = (data) => data.kind === "Valid";
-    /**
-     * Type guard that checks if a Validation is invalid.
-     */
-    Validation.isInvalid = (data) => data.kind === "Invalid";
-    /**
-     * Transforms the success value inside a Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.valid(5), Validation.map(n => n * 2)); // Valid(10)
-     * pipe(Validation.invalid("oops"), Validation.map(n => n * 2)); // Invalid(["oops"])
-     * ```
-     */
-    Validation.map = (f) => (data) => Validation.isValid(data) ? Validation.valid(f(data.value)) : data;
-    /**
-     * Applies a function wrapped in a Validation to a value wrapped in a Validation.
-     * Accumulates errors from both sides.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Validation.valid(add),
-     *   Validation.ap(Validation.valid(5)),
-     *   Validation.ap(Validation.valid(3))
-     * ); // Valid(8)
-     *
-     * pipe(
-     *   Validation.valid(add),
-     *   Validation.ap(Validation.invalid<string, number>("bad a")),
-     *   Validation.ap(Validation.invalid<string, number>("bad b"))
-     * ); // Invalid(["bad a", "bad b"])
-     * ```
-     */
-    Validation.ap = (arg) => (data) => {
-        if (Validation.isValid(data) && Validation.isValid(arg))
-            return Validation.valid(data.value(arg.value));
-        const errors = [
-            ...(Validation.isInvalid(data) ? data.errors : []),
-            ...(Validation.isInvalid(arg) ? arg.errors : []),
-        ];
-        return Validation.invalidAll(errors);
-    };
-    /**
-     * Extracts the value from a Validation by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.valid(42),
-     *   Validation.fold(
-     *     errors => `Errors: ${errors.join(", ")}`,
-     *     value => `Value: ${value}`
-     *   )
-     * );
-     * ```
-     */
-    Validation.fold = (onInvalid, onValid) => (data) => Validation.isValid(data) ? onValid(data.value) : onInvalid(data.errors);
-    /**
-     * Pattern matches on a Validation, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   validation,
-     *   Validation.match({
-     *     valid: value => `Got ${value}`,
-     *     invalid: errors => `Failed: ${errors.join(", ")}`
-     *   })
-     * );
-     * ```
-     */
-    Validation.match = (cases) => (data) => Validation.isValid(data) ? cases.valid(data.value) : cases.invalid(data.errors);
-    /**
-     * Returns the success value or a default value if the Validation is invalid.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Validation.valid(5), Validation.getOrElse(() => 0)); // 5
-     * pipe(Validation.invalid("oops"), Validation.getOrElse(() => 0)); // 0
-     * pipe(Validation.invalid("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
-     * ```
-     */
-    Validation.getOrElse = (defaultValue) => (data) => Validation.isValid(data) ? data.value : defaultValue();
-    /**
-     * Executes a side effect on the success value without changing the Validation.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Validation.valid(5),
-     *   Validation.tap(n => console.log("Value:", n)),
-     *   Validation.map(n => n * 2)
-     * );
-     * ```
-     */
-    Validation.tap = (f) => (data) => {
-        if (Validation.isValid(data))
-            f(data.value);
-        return data;
-    };
-    /**
-     * Recovers from an Invalid state by providing a fallback Validation.
-     * The fallback receives the accumulated error list so callers can inspect which errors occurred.
-     * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
-     */
-    Validation.recover = (fallback) => (data) => Validation.isValid(data) ? data : fallback(data.errors);
-    /**
-     * Recovers from an Invalid state unless the errors contain any of the blocked errors.
-     * The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
-     */
-    Validation.recoverUnless = (blockedErrors, fallback) => (data) => Validation.isInvalid(data) &&
-        !data.errors.some((err) => blockedErrors.includes(err))
-        ? fallback()
-        : data;
-    /**
-     * Combines two independent Validation instances into a tuple.
-     * If both are Valid, returns Valid with both values as a tuple.
-     * If either is Invalid, accumulates errors from both sides.
-     *
-     * @example
-     * ```ts
-     * Validation.product(
-     *   Validation.valid("alice"),
-     *   Validation.valid(30)
-     * ); // Valid(["alice", 30])
-     *
-     * Validation.product(
-     *   Validation.invalid("Name required"),
-     *   Validation.invalid("Age must be >= 0")
-     * ); // Invalid(["Name required", "Age must be >= 0"])
-     * ```
-     */
-    Validation.product = (first, second) => {
-        if (Validation.isValid(first) && Validation.isValid(second))
-            return Validation.valid([first.value, second.value]);
-        const errors = [
-            ...(Validation.isInvalid(first) ? first.errors : []),
-            ...(Validation.isInvalid(second) ? second.errors : []),
-        ];
-        return Validation.invalidAll(errors);
-    };
-    /**
-     * Combines a non-empty list of Validation instances, accumulating all errors.
-     * If all are Valid, returns Valid with all values collected into an array.
-     * If any are Invalid, returns Invalid with all accumulated errors.
-     *
-     * @example
-     * ```ts
-     * Validation.productAll([
-     *   validateName(name),
-     *   validateEmail(email),
-     *   validateAge(age)
-     * ]);
-     * // Valid([name, email, age]) or Invalid([...all errors])
-     * ```
-     */
-    Validation.productAll = (data) => {
-        const values = [];
-        const errors = [];
-        for (const v of data) {
-            if (Validation.isValid(v))
-                values.push(v.value);
-            else
-                errors.push(...v.errors);
-        }
-        return errors.length > 0 ? Validation.invalidAll(errors) : Validation.valid(values);
-    };
-})(Validation || (Validation = {}));

package/esm/src/Core/index.js

@@ -1,18 +0,0 @@
-export * from "./Deferred.js";
-export * from "./Lens.js";
-export * from "./Logged.js";
-export * from "./Option.js";
-export * from "./Optional.js";
-export * from "./Predicate.js";
-export * from "./Reader.js";
-export * from "./Refinement.js";
-export * from "./RemoteData.js";
-export * from "./Result.js";
-export * from "./State.js";
-export * from "./Task.js";
-export * from "./TaskOption.js";
-export * from "./TaskResult.js";
-export * from "./TaskValidation.js";
-export * from "./These.js";
-export * from "./Tuple.js";
-export * from "./Validation.js";

package/esm/src/Types/Brand.js

@@ -1,28 +0,0 @@
-export var Brand;
-(function (Brand) {
-    /**
-     * Returns a constructor that wraps a value of type T in brand K.
-     * The resulting function performs an unchecked cast — only use when the raw
-     * value is known to satisfy the brand's invariants.
-     *
-     * @example
-     * ```ts
-     * type PositiveNumber = Brand<"PositiveNumber", number>;
-     * const toPositiveNumber = Brand.wrap<"PositiveNumber", number>();
-     *
-     * const n: PositiveNumber = toPositiveNumber(42);
-     * ```
-     */
-    Brand.wrap = () => (value) => value;
-    /**
-     * Strips the brand and returns the underlying value.
-     * Since Brand<K, T> extends T this is rarely needed, but can improve readability.
-     *
-     * @example
-     * ```ts
-     * const userId: UserId = toUserId("user-123");
-     * const raw: string = Brand.unwrap(userId); // "user-123"
-     * ```
-     */
-    Brand.unwrap = (branded) => branded;
-})(Brand || (Brand = {}));

package/esm/src/Types/NonEmptyList.js

@@ -1,14 +0,0 @@
-/**
- * Type guard that checks if an array is non-empty.
- *
- * @example
- * ```ts
- * const items: string[] = getItems();
- *
- * if (isNonEmptyList(items)) {
- *   // TypeScript knows items has at least one element
- *   const first = items[0]; // string, not string | undefined
- * }
- * ```
- */
-export const isNonEmptyList = (list) => list.length > 0;

package/esm/src/Types/index.js

@@ -1,2 +0,0 @@
-export * from "./Brand.js";
-export * from "./NonEmptyList.js";