@nlozgachev/pipelined 0.12.0 → 0.14.0

package/esm/src/Core/Reader.js

@@ -1,134 +0,0 @@
-export var Reader;
-(function (Reader) {
-    /**
-     * Lifts a pure value into a Reader. The environment is ignored.
-     *
-     * @example
-     * ```ts
-     * const always42: Reader<Config, number> = Reader.resolve(42);
-     * always42(anyConfig); // 42
-     * ```
-     */
-    Reader.resolve = (value) => (_env) => value;
-    /**
-     * Returns the full environment as the result.
-     * The fundamental way to access the environment in a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Reader.ask<Config>(),
-     *   Reader.map(config => config.baseUrl)
-     * )(appConfig); // "https://api.example.com"
-     * ```
-     */
-    Reader.ask = () => (env) => env;
-    /**
-     * Projects a value from the environment using a selector function.
-     * Equivalent to `pipe(Reader.ask(), Reader.map(f))` but more direct.
-     *
-     * @example
-     * ```ts
-     * const getBaseUrl: Reader<Config, string> = Reader.asks(c => c.baseUrl);
-     * getBaseUrl(appConfig); // "https://api.example.com"
-     * ```
-     */
-    Reader.asks = (f) => (env) => f(env);
-    /**
-     * Transforms the value produced by a Reader.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   Reader.asks((c: Config) => c.baseUrl),
-     *   Reader.map(url => url.toUpperCase())
-     * )(appConfig); // "HTTPS://API.EXAMPLE.COM"
-     * ```
-     */
-    Reader.map = (f) => (data) => (env) => f(data(env));
-    /**
-     * Sequences two Readers. Both see the same environment.
-     * The output of the first is passed to `f`, which returns the next Reader.
-     *
-     * @example
-     * ```ts
-     * const buildUrl = (path: string): Reader<Config, string> =>
-     *   Reader.asks(c => `${c.baseUrl}${path}`);
-     *
-     * const addAuth = (url: string): Reader<Config, string> =>
-     *   Reader.asks(c => `${url}?key=${c.apiKey}`);
-     *
-     * pipe(
-     *   buildUrl("/items"),
-     *   Reader.chain(addAuth)
-     * )(appConfig); // "https://api.example.com/items?key=secret"
-     * ```
-     */
-    Reader.chain = (f) => (data) => (env) => f(data(env))(env);
-    /**
-     * Applies a function wrapped in a Reader to a value wrapped in a Reader.
-     * Both Readers see the same environment.
-     *
-     * @example
-     * ```ts
-     * const add = (a: number) => (b: number) => a + b;
-     * pipe(
-     *   Reader.resolve<Config, typeof add>(add),
-     *   Reader.ap(Reader.asks(c => c.timeout)),
-     *   Reader.ap(Reader.resolve(5))
-     * )(appConfig);
-     * ```
-     */
-    Reader.ap = (arg) => (data) => (env) => data(env)(arg(env));
-    /**
-     * Executes a side effect on the produced value without changing the Reader.
-     * Useful for logging or debugging inside a pipeline.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   buildUrl("/users"),
-     *   Reader.tap(url => console.log("Requesting:", url)),
-     *   Reader.chain(addAuth)
-     * )(appConfig);
-     * ```
-     */
-    Reader.tap = (f) => (data) => (env) => {
-        const a = data(env);
-        f(a);
-        return a;
-    };
-    /**
-     * Adapts a Reader to work with a different (typically wider) environment
-     * by transforming the environment before passing it to the Reader.
-     * This lets you compose Readers that expect different environments.
-     *
-     * @example
-     * ```ts
-     * type AppEnv = { db: DbPool; config: Config; logger: Logger };
-     *
-     * // buildUrl only needs Config
-     * const buildUrl: Reader<Config, string> = Reader.asks(c => c.baseUrl);
-     *
-     * // Zoom in from AppEnv to Config
-     * const buildUrlFromApp: Reader<AppEnv, string> =
-     *   pipe(buildUrl, Reader.local((env: AppEnv) => env.config));
-     *
-     * buildUrlFromApp(appEnv); // works with the full AppEnv
-     * ```
-     */
-    Reader.local = (f) => (data) => (env) => data(f(env));
-    /**
-     * Runs a Reader by supplying the environment. Use this at the edge of your
-     * program where the environment is available.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   buildEndpoint("/users"),
-     *   Reader.run(appConfig)
-     * ); // "https://api.example.com/users?key=secret"
-     * ```
-     */
-    Reader.run = (env) => (data) => data(env);
-})(Reader || (Reader = {}));

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 = {}));