@nlozgachev/pipelined 0.11.0 → 0.13.0

package/esm/src/Core/Refinement.js

@@ -1,115 +0,0 @@
-import { Option } from "./Option.js";
-import { Result } from "./Result.js";
-export var Refinement;
-(function (Refinement) {
-    /**
-     * Creates a `Refinement<A, B>` from a plain boolean predicate.
-     *
-     * This is an unsafe cast — the caller is responsible for ensuring that the
-     * predicate truly characterises values of type `B`. Use this only when
-     * bootstrapping a new refinement; prefer `compose`, `and`, or `or` to build
-     * derived refinements from existing ones.
-     *
-     * @example
-     * ```ts
-     * type PositiveNumber = number & { readonly _tag: "PositiveNumber" };
-     *
-     * const isPositive: Refinement<number, PositiveNumber> =
-     *   Refinement.make(n => n > 0);
-     * ```
-     */
-    Refinement.make = (f) => f;
-    /**
-     * Chains two refinements: if `ab` narrows `A` to `B` and `bc` narrows `B` to `C`,
-     * the result narrows `A` directly to `C`.
-     *
-     * Data-last — the first refinement `ab` is the data being piped.
-     *
-     * @example
-     * ```ts
-     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
-     * type TrimmedString  = NonEmptyString & { readonly _tag: "Trimmed" };
-     *
-     * const isNonEmpty: Refinement<string, NonEmptyString> =
-     *   Refinement.make(s => s.length > 0);
-     * const isTrimmed: Refinement<NonEmptyString, TrimmedString> =
-     *   Refinement.make(s => s === s.trim());
-     *
-     * const isNonEmptyTrimmed: Refinement<string, TrimmedString> = pipe(
-     *   isNonEmpty,
-     *   Refinement.compose(isTrimmed)
-     * );
-     * ```
-     */
-    Refinement.compose = (bc) => (ab) => (a) => ab(a) && bc(a);
-    /**
-     * Intersects two refinements: the result narrows `A` to `B & C`, passing only
-     * when both refinements hold simultaneously.
-     *
-     * Data-last — the first refinement is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const isString: Refinement<unknown, string> = Refinement.make(x => typeof x === "string");
-     * const isNonEmpty: Refinement<unknown, { length: number }> =
-     *   Refinement.make(x => (x as any).length > 0);
-     *
-     * const isNonEmptyString = pipe(isString, Refinement.and(isNonEmpty));
-     * isNonEmptyString("hi");  // true
-     * isNonEmptyString("");    // false
-     * ```
-     */
-    Refinement.and = (second) => (first) => (a) => first(a) && second(a);
-    /**
-     * Unions two refinements: the result narrows `A` to `B | C`, passing when either
-     * refinement holds.
-     *
-     * Data-last — the first refinement is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const isString:  Refinement<unknown, string>  = Refinement.make(x => typeof x === "string");
-     * const isNumber:  Refinement<unknown, number>  = Refinement.make(x => typeof x === "number");
-     *
-     * const isStringOrNumber = pipe(isString, Refinement.or(isNumber));
-     * isStringOrNumber("hi"); // true
-     * isStringOrNumber(42);   // true
-     * isStringOrNumber(true); // false
-     * ```
-     */
-    Refinement.or = (second) => (first) => (a) => first(a) || second(a);
-    /**
-     * Converts a `Refinement<A, B>` into a function `(a: A) => Option<B>`.
-     *
-     * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
-     * integrating runtime validation into an `Option`-based pipeline.
-     *
-     * @example
-     * ```ts
-     * type PositiveNumber = number & { readonly _tag: "Positive" };
-     * const isPositive: Refinement<number, PositiveNumber> =
-     *   Refinement.make(n => n > 0);
-     *
-     * pipe(-1, Refinement.toFilter(isPositive)); // None
-     * pipe(42, Refinement.toFilter(isPositive)); // Some(42)
-     * ```
-     */
-    Refinement.toFilter = (r) => (a) => r(a) ? Option.some(a) : Option.none();
-    /**
-     * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
-     *
-     * Returns `Ok(a)` when the refinement holds, `Err(onFail(a))` otherwise. Use
-     * this to surface validation failures as typed errors inside a `Result` pipeline.
-     *
-     * @example
-     * ```ts
-     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
-     * const isNonEmpty: Refinement<string, NonEmptyString> =
-     *   Refinement.make(s => s.length > 0);
-     *
-     * pipe("", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Err(...)
-     * pipe("hi", Refinement.toResult(isNonEmpty, () => "must not be empty")); // Ok("hi")
-     * ```
-     */
-    Refinement.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
-})(Refinement || (Refinement = {}));

package/esm/src/Core/RemoteData.js

@@ -1,211 +0,0 @@
-import { Option } from "./Option.js";
-import { Result } from "./Result.js";
-const _notAsked = { kind: "NotAsked" };
-const _loading = { kind: "Loading" };
-export var RemoteData;
-(function (RemoteData) {
-    /**
-     * Creates a NotAsked RemoteData.
-     */
-    RemoteData.notAsked = () => _notAsked;
-    /**
-     * Creates a Loading RemoteData.
-     */
-    RemoteData.loading = () => _loading;
-    /**
-     * Creates a Failure RemoteData with the given error.
-     */
-    RemoteData.failure = (error) => ({
-        kind: "Failure",
-        error,
-    });
-    /**
-     * Creates a Success RemoteData with the given value.
-     */
-    RemoteData.success = (value) => ({
-        kind: "Success",
-        value,
-    });
-    /**
-     * Type guard that checks if a RemoteData is NotAsked.
-     */
-    RemoteData.isNotAsked = (data) => data.kind === "NotAsked";
-    /**
-     * Type guard that checks if a RemoteData is Loading.
-     */
-    RemoteData.isLoading = (data) => data.kind === "Loading";
-    /**
-     * Type guard that checks if a RemoteData is Failure.
-     */
-    RemoteData.isFailure = (data) => data.kind === "Failure";
-    /**
-     * Type guard that checks if a RemoteData is Success.
-     */
-    RemoteData.isSuccess = (data) => data.kind === "Success";
-    /**
-     * Transforms the success value inside a RemoteData.
-     *
-     * @example
-     * ```ts
-     * pipe(RemoteData.success(5), RemoteData.map(n => n * 2)); // Success(10)
-     * pipe(RemoteData.loading(), RemoteData.map(n => n * 2)); // Loading
-     * ```
-     */
-    RemoteData.map = (f) => (data) => RemoteData.isSuccess(data) ? RemoteData.success(f(data.value)) : data;
-    /**
-     * Transforms the error value inside a RemoteData.
-     *
-     * @example
-     * ```ts
-     * pipe(RemoteData.failure("oops"), RemoteData.mapError(e => e.toUpperCase())); // Failure("OOPS")
-     * ```
-     */
-    RemoteData.mapError = (f) => (data) => RemoteData.isFailure(data) ? RemoteData.failure(f(data.error)) : data;
-    /**
-     * Chains RemoteData computations. If the input is Success, passes the value to f.
-     * Otherwise, propagates the current state.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   RemoteData.success(5),
-     *   RemoteData.chain(n => n > 0 ? RemoteData.success(n) : RemoteData.failure("negative"))
-     * );
-     * ```
-     */
-    RemoteData.chain = (f) => (data) => RemoteData.isSuccess(data) ? f(data.value) : data;
-    /**
-     * Applies a function wrapped in a RemoteData to a value wrapped in a RemoteData.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   RemoteData.success(add),
-     *   RemoteData.ap(RemoteData.success(5)),
-     *   RemoteData.ap(RemoteData.success(3))
-     * ); // Success(8)
-     * ```
-     */
-    RemoteData.ap = (arg) => (data) => {
-        if (RemoteData.isSuccess(data) && RemoteData.isSuccess(arg)) {
-            return RemoteData.success(data.value(arg.value));
-        }
-        if (RemoteData.isFailure(data))
-            return data;
-        if (RemoteData.isFailure(arg))
-            return arg;
-        if (RemoteData.isLoading(data) || RemoteData.isLoading(arg))
-            return RemoteData.loading();
-        return RemoteData.notAsked();
-    };
-    /**
-     * Extracts the value from a RemoteData by providing handlers for all four cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   userData,
-     *   RemoteData.fold(
-     *     () => "Not asked",
-     *     () => "Loading...",
-     *     e => `Error: ${e}`,
-     *     value => `Got: ${value}`
-     *   )
-     * );
-     * ```
-     */
-    RemoteData.fold = (onNotAsked, onLoading, onFailure, onSuccess) => (data) => {
-        switch (data.kind) {
-            case "NotAsked":
-                return onNotAsked();
-            case "Loading":
-                return onLoading();
-            case "Failure":
-                return onFailure(data.error);
-            case "Success":
-                return onSuccess(data.value);
-        }
-    };
-    /**
-     * Pattern matches on a RemoteData, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   userData,
-     *   RemoteData.match({
-     *     notAsked: () => "Click to load",
-     *     loading: () => "Loading...",
-     *     failure: e => `Error: ${e}`,
-     *     success: user => `Hello, ${user.name}!`
-     *   })
-     * );
-     * ```
-     */
-    RemoteData.match = (cases) => (data) => {
-        switch (data.kind) {
-            case "NotAsked":
-                return cases.notAsked();
-            case "Loading":
-                return cases.loading();
-            case "Failure":
-                return cases.failure(data.error);
-            case "Success":
-                return cases.success(data.value);
-        }
-    };
-    /**
-     * Returns the success value or a default value if the RemoteData is not Success.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(RemoteData.success(5), RemoteData.getOrElse(() => 0)); // 5
-     * pipe(RemoteData.loading(), RemoteData.getOrElse(() => 0)); // 0
-     * pipe(RemoteData.loading<string, number>(), RemoteData.getOrElse(() => null)); // null — typed as number | null
-     * ```
-     */
-    RemoteData.getOrElse = (defaultValue) => (data) => RemoteData.isSuccess(data) ? data.value : defaultValue();
-    /**
-     * Executes a side effect on the success value without changing the RemoteData.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   RemoteData.success(5),
-     *   RemoteData.tap(n => console.log("Value:", n)),
-     *   RemoteData.map(n => n * 2)
-     * );
-     * ```
-     */
-    RemoteData.tap = (f) => (data) => {
-        if (RemoteData.isSuccess(data))
-            f(data.value);
-        return data;
-    };
-    /**
-     * Recovers from a Failure state by providing a fallback RemoteData.
-     * The fallback can produce a different success type, widening the result to `RemoteData<E, A | B>`.
-     */
-    RemoteData.recover = (fallback) => (data) => RemoteData.isFailure(data) ? fallback(data.error) : data;
-    /**
-     * Converts a RemoteData to an Option.
-     * Success becomes Some, all other states become None.
-     */
-    RemoteData.toOption = (data) => RemoteData.isSuccess(data) ? Option.some(data.value) : Option.none();
-    /**
-     * Converts a RemoteData to a Result.
-     * Success becomes Ok, Failure becomes Err.
-     * NotAsked and Loading become Err with the provided fallback error.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   RemoteData.success(42),
-     *   RemoteData.toResult(() => "not loaded")
-     * ); // Ok(42)
-     * ```
-     */
-    RemoteData.toResult = (onNotReady) => (data) => RemoteData.isSuccess(data) ? Result.ok(data.value) : Result.err(RemoteData.isFailure(data) ? data.error : onNotReady());
-})(RemoteData || (RemoteData = {}));

package/esm/src/Core/Result.js

@@ -1,170 +0,0 @@
-import { Option } from "./Option.js";
-export var Result;
-(function (Result) {
-    /**
-     * Creates a successful Result with the given value.
-     */
-    Result.ok = (value) => ({ kind: "Ok", value });
-    /**
-     * Creates a failed Result with the given error.
-     */
-    Result.err = (error) => ({ kind: "Error", error });
-    /**
-     * Type guard that checks if an Result is Ok.
-     */
-    Result.isOk = (data) => data.kind === "Ok";
-    /**
-     * Type guard that checks if an Result is Err.
-     */
-    Result.isErr = (data) => data.kind === "Error";
-    /**
-     * Creates an Result from a function that may throw.
-     * Catches any errors and transforms them using the onError function.
-     *
-     * @example
-     * ```ts
-     * const parseJson = (s: string): Result<string, unknown> =>
-     *   Result.tryCatch(
-     *     () => JSON.parse(s),
-     *     (e) => `Parse error: ${e}`
-     *   );
-     * ```
-     */
-    Result.tryCatch = (f, onError) => {
-        try {
-            return Result.ok(f());
-        }
-        catch (e) {
-            return Result.err(onError(e));
-        }
-    };
-    /**
-     * Transforms the success value inside an Result.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.ok(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
-     * ```
-     */
-    Result.map = (f) => (data) => Result.isOk(data) ? Result.ok(f(data.value)) : data;
-    /**
-     * Transforms the error value inside an Result.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
-     * ```
-     */
-    Result.mapError = (f) => (data) => Result.isErr(data) ? Result.err(f(data.error)) : data;
-    /**
-     * Chains Result computations. If the first is Ok, passes the value to f.
-     * If the first is Err, propagates the error.
-     *
-     * @example
-     * ```ts
-     * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
-     *
-     * pipe(Result.ok(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
-     * ```
-     */
-    Result.chain = (f) => (data) => Result.isOk(data) ? f(data.value) : data;
-    /**
-     * Extracts the value from an Result by providing handlers for both cases.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.ok(5),
-     *   Result.fold(
-     *     e => `Error: ${e}`,
-     *     n => `Value: ${n}`
-     *   )
-     * ); // "Value: 5"
-     * ```
-     */
-    Result.fold = (onErr, onOk) => (data) => Result.isOk(data) ? onOk(data.value) : onErr(data.error);
-    /**
-     * Pattern matches on a Result, returning the result of the matching case.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   result,
-     *   Result.match({
-     *     ok: value => `Got ${value}`,
-     *     err: error => `Failed: ${error}`
-     *   })
-     * );
-     * ```
-     */
-    Result.match = (cases) => (data) => Result.isOk(data) ? cases.ok(data.value) : cases.err(data.error);
-    /**
-     * Returns the success value or a default value if the Result is an error.
-     * The default is a thunk `() => B` — evaluated only when the Result is Err.
-     * The default can be a different type, widening the result to `A | B`.
-     *
-     * @example
-     * ```ts
-     * pipe(Result.ok(5), Result.getOrElse(() => 0)); // 5
-     * pipe(Result.err("error"), Result.getOrElse(() => 0)); // 0
-     * pipe(Result.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
-     * ```
-     */
-    Result.getOrElse = (defaultValue) => (data) => Result.isOk(data) ? data.value : defaultValue();
-    /**
-     * Executes a side effect on the success value without changing the Result.
-     * Useful for logging or debugging.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Result.ok(5),
-     *   Result.tap(n => console.log("Value:", n)),
-     *   Result.map(n => n * 2)
-     * );
-     * ```
-     */
-    Result.tap = (f) => (data) => {
-        if (Result.isOk(data))
-            f(data.value);
-        return data;
-    };
-    /**
-     * Recovers from an error by providing a fallback Result.
-     * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
-     */
-    Result.recover = (fallback) => (data) => Result.isOk(data) ? data : fallback(data.error);
-    /**
-     * Recovers from an error unless it matches the blocked error.
-     * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
-     */
-    Result.recoverUnless = (blockedErr, fallback) => (data) => Result.isErr(data) && data.error !== blockedErr ? fallback() : data;
-    /**
-     * Converts a Result to an Option.
-     * Ok becomes Some, Err becomes None (the error is discarded).
-     *
-     * @example
-     * ```ts
-     * Result.toOption(Result.ok(42)); // Some(42)
-     * Result.toOption(Result.err("oops")); // None
-     * ```
-     */
-    Result.toOption = (data) => Result.isOk(data) ? Option.some(data.value) : Option.none();
-    /**
-     * Applies a function wrapped in an Result to a value wrapped in an Result.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Result.ok(add),
-     *   Result.ap(Result.ok(5)),
-     *   Result.ap(Result.ok(3))
-     * ); // Ok(8)
-     * ```
-     */
-    Result.ap = (arg) => (data) => Result.isOk(data) && Result.isOk(arg) ? Result.ok(data.value(arg.value)) : Result.isErr(data) ? data : arg;
-})(Result || (Result = {}));

package/esm/src/Core/State.js

@@ -1,181 +0,0 @@
-export var State;
-(function (State) {
-    /**
-     * Lifts a pure value into a State computation. The state passes through unchanged.
-     *
-     * @example
-     * ```ts
-     * State.run(10)(State.resolve(42)); // [42, 10] — value 42, state unchanged
-     * ```
-     */
-    State.resolve = (value) => (s) => [value, s];
-    /**
-     * Produces the current state as the value, without modifying it.
-     *
-     * @example
-     * ```ts
-     * const readStack: State<string[], string[]> = State.get();
-     * State.run(["a", "b"])(readStack); // [["a", "b"], ["a", "b"]]
-     * ```
-     */
-    State.get = () => (s) => [s, s];
-    /**
-     * Reads a projection of the state without modifying it.
-     * Equivalent to `pipe(State.get(), State.map(f))` but more direct.
-     *
-     * @example
-     * ```ts
-     * type AppState = { count: number; label: string };
-     * const readCount: State<AppState, number> = State.gets(s => s.count);
-     * State.run({ count: 5, label: "x" })(readCount); // [5, { count: 5, label: "x" }]
-     * ```
-     */
-    State.gets = (f) => (s) => [f(s), s];
-    /**
-     * Replaces the current state with a new value. Produces no meaningful value.
-     *
-     * @example
-     * ```ts
-     * const reset: State<number, undefined> = State.put(0);
-     * State.run(99)(reset); // [undefined, 0]
-     * ```
-     */
-    State.put = (newState) => (_s) => [undefined, newState];
-    /**
-     * Applies a function to the current state to produce the next state.
-     * Produces no meaningful value.
-     *
-     * @example
-     * ```ts
-     * const push = (item: string): State<string[], undefined> =>
-     *   State.modify(stack => [...stack, item]);
-     *
-     * State.run(["a"])(push("b")); // [undefined, ["a", "b"]]
-     * ```
-     */
-    State.modify = (f) => (s) => [undefined, f(s)];
-    /**
-     * Transforms the value produced by a State computation.
-     * The state transformation is unchanged.
-     *
-     * @example
-     * ```ts
-     * const readLength: State<string[], number> = pipe(
-     *   State.get<string[]>(),
-     *   State.map(stack => stack.length),
-     * );
-     *
-     * State.run(["a", "b", "c"])(readLength); // [3, ["a", "b", "c"]]
-     * ```
-     */
-    State.map = (f) => (st) => (s) => {
-        const [a, s1] = st(s);
-        return [f(a), s1];
-    };
-    /**
-     * Sequences two State computations. The state output of the first is passed
-     * as the state input to the second.
-     *
-     * Data-last — the first computation is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const push = (item: string): State<string[], undefined> =>
-     *   State.modify(stack => [...stack, item]);
-     *
-     * const program = pipe(
-     *   push("a"),
-     *   State.chain(() => push("b")),
-     *   State.chain(() => State.get<string[]>()),
-     * );
-     *
-     * State.evaluate([])(program); // ["a", "b"]
-     * ```
-     */
-    State.chain = (f) => (st) => (s) => {
-        const [a, s1] = st(s);
-        return f(a)(s1);
-    };
-    /**
-     * Applies a function wrapped in a State to a value wrapped in a State.
-     * The function computation runs first; its output state is the input to the
-     * argument computation.
-     *
-     * @example
-     * ```ts
-     * const addCounted = (n: number) => (m: number) => n + m;
-     * const program = pipe(
-     *   State.resolve<number, typeof addCounted>(addCounted),
-     *   State.ap(State.gets((s: number) => s * 2)),
-     *   State.ap(State.gets((s: number) => s)),
-     * );
-     *
-     * State.evaluate(3)(program); // 6 + 3 = 9
-     * ```
-     */
-    State.ap = (arg) => (fn) => (s) => {
-        const [f, s1] = fn(s);
-        const [a, s2] = arg(s1);
-        return [f(a), s2];
-    };
-    /**
-     * Runs a side effect on the produced value without changing the State computation.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   State.get<number>(),
-     *   State.tap(n => console.log("current:", n)),
-     *   State.chain(() => State.modify(n => n + 1)),
-     * );
-     * ```
-     */
-    State.tap = (f) => (st) => (s) => {
-        const [a, s1] = st(s);
-        f(a);
-        return [a, s1];
-    };
-    /**
-     * Runs a State computation with an initial state, returning both the
-     * produced value and the final state as a pair.
-     *
-     * Data-last — the computation is the data being piped.
-     *
-     * @example
-     * ```ts
-     * const program = pipe(
-     *   State.modify<number>(n => n + 1),
-     *   State.chain(() => State.get<number>()),
-     * );
-     *
-     * State.run(0)(program); // [1, 1]
-     * ```
-     */
-    State.run = (initialState) => (st) => st(initialState);
-    /**
-     * Runs a State computation with an initial state, returning only the
-     * produced value (discarding the final state).
-     *
-     * @example
-     * ```ts
-     * State.evaluate([])(pipe(
-     *   State.modify<string[]>(s => [...s, "x"]),
-     *   State.chain(() => State.get<string[]>()),
-     * )); // ["x"]
-     * ```
-     */
-    State.evaluate = (initialState) => (st) => st(initialState)[0];
-    /**
-     * Runs a State computation with an initial state, returning only the
-     * final state (discarding the produced value).
-     *
-     * @example
-     * ```ts
-     * State.execute(0)(pipe(
-     *   State.modify<number>(n => n + 10),
-     *   State.chain(() => State.modify<number>(n => n * 2)),
-     * )); // 20
-     * ```
-     */
-    State.execute = (initialState) => (st) => st(initialState)[1];
-})(State || (State = {}));