@nlozgachev/pipelined 0.12.0 → 0.14.0

package/types/src/Core/Optional.d.ts

@@ -1,158 +0,0 @@
-import { Option } from "./Option.js";
-import type { Lens } from "./Lens.js";
-/** Keys of T for which undefined is assignable (i.e. optional fields). */
-type OptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? K : never;
-}[keyof T];
-/**
- * Optional<S, A> focuses on a value A inside a structure S that may or may
- * not be present. Like a Lens, but get returns Option<A>.
- *
- * Compose with other Optionals via `andThen`, or with a Lens via `andThenLens`.
- * Convert a Lens to an Optional with `Lens.toOptional`.
- *
- * @example
- * ```ts
- * type Profile = { username: string; bio?: string };
- *
- * const bioOpt = Optional.prop<Profile>()("bio");
- *
- * pipe(profile, Optional.get(bioOpt));               // Some("hello") or None
- * pipe(profile, Optional.set(bioOpt)("hello"));      // new Profile with bio set
- * pipe(profile, Optional.modify(bioOpt)(s => s + "!")); // appends if present
- * ```
- */
-export type Optional<S, A> = {
-    readonly get: (s: S) => Option<A>;
-    readonly set: (a: A) => (s: S) => S;
-};
-export declare namespace 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,
-     * );
-     * ```
-     */
-    const make: <S, A>(get: (s: S) => Option<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
-    /**
-     * 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");
-     * ```
-     */
-    const prop: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
-    /**
-     * 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
-     * ```
-     */
-    const index: <A>(i: number) => Optional<A[], A>;
-    /**
-     * Reads the focused value from a structure, returning Option<A>.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
-     * ```
-     */
-    const get: <S, A>(opt: Optional<S, A>) => (s: S) => Option<A>;
-    /**
-     * 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"));
-     * ```
-     */
-    const set: <S, A>(opt: Optional<S, A>) => (a: A) => (s: S) => 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()));
-     * ```
-     */
-    const modify: <S, A>(opt: Optional<S, A>) => (f: (a: A) => A) => (s: S) => S;
-    /**
-     * Returns the focused value or a default when the focus is absent.
-     *
-     * @example
-     * ```ts
-     * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
-     * ```
-     */
-    const getOrElse: <S, A>(opt: Optional<S, A>) => (defaultValue: () => A) => (s: S) => A;
-    /**
-     * 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()));
-     * ```
-     */
-    const fold: <S, A>(opt: Optional<S, A>) => <B>(onNone: () => B, onSome: (a: A) => B) => (s: S) => B;
-    /**
-     * Pattern matches on an Optional focus using a named-case object.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   profile,
-     *   Optional.match(bioOpt)({ none: () => "no bio", some: (bio) => bio }),
-     * );
-     * ```
-     */
-    const match: <S, A>(opt: Optional<S, A>) => <B>(cases: {
-        none: () => B;
-        some: (a: A) => B;
-    }) => (s: S) => B;
-    /**
-     * 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")),
-     * );
-     * ```
-     */
-    const andThen: <A, B>(inner: Optional<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
-    /**
-     * 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")),
-     * );
-     * ```
-     */
-    const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
-}
-export {};
-//# sourceMappingURL=Optional.d.ts.map

package/types/src/Core/Optional.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Optional.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Optional.ts"],"names":[],"mappings":"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"}

package/types/src/Core/Predicate.d.ts

@@ -1,161 +0,0 @@
-import { Refinement } from "./Refinement.js";
-/**
- * A boolean-valued function over a type `A`.
- *
- * A `Predicate<A>` is the simpler sibling of `Refinement<A, B>`: it tests whether a
- * value satisfies a condition at runtime but carries no compile-time narrowing guarantee.
- * Use it when you need to combine, negate, or adapt boolean checks as first-class values
- * and do not require the extra type information that a `Refinement` provides.
- *
- * Every `Refinement<A, B>` is a `Predicate<A>` — convert with `Predicate.fromRefinement`
- * when you want to compose a narrowing check alongside plain predicates.
- *
- * @example
- * ```ts
- * const isAdult: Predicate<number> = n => n >= 18;
- * const isRetired: Predicate<number> = n => n >= 65;
- *
- * const isWorkingAge: Predicate<number> = pipe(
- *   isAdult,
- *   Predicate.and(Predicate.not(isRetired))
- * );
- *
- * isWorkingAge(30);  // true
- * isWorkingAge(15);  // false
- * isWorkingAge(70);  // false
- * ```
- */
-export type Predicate<A> = (a: A) => boolean;
-export declare namespace 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
-     * ```
-     */
-    const not: <A>(p: Predicate<A>) => Predicate<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
-     * ```
-     */
-    const and: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<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
-     * ```
-     */
-    const or: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<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
-     * ```
-     */
-    const using: <A, B>(f: (b: B) => A) => (p: Predicate<A>) => Predicate<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
-     * ```
-     */
-    const all: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<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
-     * ```
-     */
-    const any: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<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
-     * ```
-     */
-    const fromRefinement: <A, B extends A>(r: Refinement<A, B>) => Predicate<A>;
-}
-//# sourceMappingURL=Predicate.d.ts.map

package/types/src/Core/Predicate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Predicate.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Predicate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE7C,yBAAiB,SAAS,CAAC;IAC1B;;;;;;;;;;;OAWG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAiB,CAAC;IAEtE;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,QAAQ,SAAS,CAAC,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAiC,CAAC;IAEpH;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,EAAE,GAAI,CAAC,EAAE,QAAQ,SAAS,CAAC,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAiC,CAAC;IAEnH;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAmB,CAAC;IAEjG;;;;;;;;;;;;;;;;;OAiBG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,YAAY,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAyC,CAAC;IAEtH;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,YAAY,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAwC,CAAC;IAErH;;;;;;;;;;;;;;;;;;;OAmBG;IACI,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,SAAS,CAAC,CAAC,CAAM,CAAC;CACvF"}

package/types/src/Core/Reader.d.ts

@@ -1,156 +0,0 @@
-/**
- * A computation that reads from a shared environment `R` and produces a value `A`.
- * Use Reader to thread a dependency (config, logger, DB pool) through a pipeline
- * without passing it explicitly to every function.
- *
- * @example
- * ```ts
- * type Config = { baseUrl: string; apiKey: string };
- *
- * const buildUrl = (path: string): Reader<Config, string> =>
- *   (config) => `${config.baseUrl}${path}`;
- *
- * const withAuth = (url: string): Reader<Config, string> =>
- *   (config) => `${url}?key=${config.apiKey}`;
- *
- * const fetchEndpoint = (path: string): Reader<Config, string> =>
- *   pipe(
- *     buildUrl(path),
- *     Reader.chain(withAuth)
- *   );
- *
- * // Inject the config once at the edge
- * fetchEndpoint("/users")(appConfig); // "https://api.example.com/users?key=secret"
- * ```
- */
-export type Reader<R, A> = (env: R) => A;
-export declare namespace 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
-     * ```
-     */
-    const resolve: <R, A>(value: A) => Reader<R, A>;
-    /**
-     * 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"
-     * ```
-     */
-    const ask: <R>() => Reader<R, R>;
-    /**
-     * 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"
-     * ```
-     */
-    const asks: <R, A>(f: (env: R) => A) => Reader<R, A>;
-    /**
-     * 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"
-     * ```
-     */
-    const map: <R, A, B>(f: (a: A) => B) => (data: Reader<R, A>) => Reader<R, B>;
-    /**
-     * 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"
-     * ```
-     */
-    const chain: <R, A, B>(f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, B>;
-    /**
-     * 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);
-     * ```
-     */
-    const ap: <R, A>(arg: Reader<R, A>) => <B>(data: Reader<R, (a: A) => B>) => Reader<R, B>;
-    /**
-     * 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);
-     * ```
-     */
-    const tap: <R, A>(f: (a: A) => void) => (data: Reader<R, A>) => Reader<R, 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
-     * ```
-     */
-    const local: <R2, R>(f: (env: R2) => R) => <A>(data: Reader<R, A>) => Reader<R2, A>;
-    /**
-     * 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"
-     * ```
-     */
-    const run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
-}
-//# sourceMappingURL=Reader.d.ts.map

package/types/src/Core/Reader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Reader.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;AAEzC,yBAAiB,MAAM,CAAC;IACvB;;;;;;;;OAQG;IACI,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAoB,CAAC;IAEzE;;;;;;;;;;;OAWG;IACI,MAAM,GAAG,GAAI,CAAC,OAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAiB,CAAC;IAEvD;;;;;;;;;OASG;IACI,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAoB,CAAC;IAE9E;;;;;;;;;;OAUG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAA0B,CAAC;IAE5G;;;;;;;;;;;;;;;;;OAiBG;IACI,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAC5E,CAAC;IAEnB;;;;;;;;;;;;;OAaG;IACI,MAAM,EAAE,GAAI,CAAC,EAAE,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CACzE,CAAC;IAErB;;;;;;;;;;;;OAYG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAIhF,CAAC;IAEF;;;;;;;;;;;;;;;;;;OAkBG;IACI,MAAM,KAAK,GAAI,EAAE,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,EAAE,EAAE,CAAC,CAA0B,CAAC;IAEnH;;;;;;;;;;;OAWG;IACI,MAAM,GAAG,GAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,CAAc,CAAC;CAC1E"}

package/types/src/Core/Refinement.d.ts

@@ -1,138 +0,0 @@
-import { Option } from "./Option.js";
-import { Result } from "./Result.js";
-/**
- * A function from `A` to `A is B` — a type predicate paired with a runtime check.
- *
- * A `Refinement<A, B>` proves at compile time that a value of type `A` is actually
- * the narrower type `B extends A`, backed by a runtime boolean test. Use it to
- * express domain invariants (non-empty strings, positive numbers, valid emails) as
- * first-class, composable values rather than one-off type guards scattered across
- * the codebase.
- *
- * @example
- * ```ts
- * type NonEmptyString = string & { readonly _tag: "NonEmptyString" };
- *
- * const isNonEmpty: Refinement<string, NonEmptyString> =
- *   Refinement.make(s => s.length > 0);
- *
- * pipe(
- *   "hello",
- *   Refinement.toFilter(isNonEmpty)
- * ); // Some("hello")
- * ```
- */
-export type Refinement<A, B extends A> = (a: A) => a is B;
-export declare namespace 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);
-     * ```
-     */
-    const make: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
-    /**
-     * 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)
-     * );
-     * ```
-     */
-    const compose: <A, B extends A, C extends B>(bc: Refinement<B, C>) => (ab: Refinement<A, B>) => Refinement<A, C>;
-    /**
-     * 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
-     * ```
-     */
-    const and: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B & C>;
-    /**
-     * 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
-     * ```
-     */
-    const or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
-    /**
-     * 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)
-     * ```
-     */
-    const toFilter: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Option<B>;
-    /**
-     * 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")
-     * ```
-     */
-    const toResult: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
-}
-//# sourceMappingURL=Refinement.d.ts.map

package/types/src/Core/Refinement.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Refinement.d.ts","sourceRoot":"","sources":["../../../src/src/Core/Refinement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAE1D,yBAAiB,UAAU,CAAC;IAC3B;;;;;;;;;;;;;;;OAeG;IACI,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAA0B,CAAC;IAEtG;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,MAAM,OAAO,GAClB,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,IAAI,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,IAAI,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAC/E,CAAC;IAEjB;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,GAAG,GACd,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,MACxC,CAAC,SAAS,CAAC,EAAE,OAAO,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CACnB,CAAC;IAE1C;;;;;;;;;;;;;;;;OAgBG;IACI,MAAM,EAAE,GACb,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,QAAQ,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,MACxC,CAAC,SAAS,CAAC,EAAE,OAAO,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CACnB,CAAC;IAE1C;;;;;;;;;;;;;;;OAeG;IACI,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,KAAG,MAAM,CAAC,CAAC,CAC3C,CAAC;IAEvC;;;;;;;;;;;;;;;OAeG;IACI,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAChE,CAAC;CAC7C"}