@nlozgachev/pipelined 0.11.0 → 0.13.0

package/script/src/Core/Optional.js

@@ -1,163 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Optional = void 0;
-const Option_js_1 = require("./Option.js");
-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_js_1.Option.some(val) : Option_js_1.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_js_1.Option.some(arr[i]) : Option_js_1.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_js_1.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_js_1.Option.none() : Option_js_1.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 || (exports.Optional = Optional = {}));

package/script/src/Core/Predicate.js

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

package/script/src/Core/Reader.js

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

package/script/src/Core/Refinement.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Refinement = void 0;
-const Option_js_1 = require("./Option.js");
-const Result_js_1 = require("./Result.js");
-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_js_1.Option.some(a) : Option_js_1.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_js_1.Result.ok(a) : Result_js_1.Result.err(onFail(a));
-})(Refinement || (exports.Refinement = Refinement = {}));