@nlozgachev/pipelined 0.63.0 → 0.64.0

package/dist/data.d.cts

@@ -1,5 +1,5 @@
 import { a as NonEmptyArr, N as NonEmpty } from './InternalTypes-GFn4RTwD.cjs';
-import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Validation-KFUpea_k.cjs';
+import { M as Maybe, R as Result, E as Equality, b as Ordering, T as Task } from './Task-C_goFYQ1.cjs';
 import { B as Brand } from './Duration-DeyxG6VQ.cjs';
 import './types.cjs';
 
@@ -24,7 +24,7 @@ declare namespace ArrTaskResult {
      * )(); // Deferred<Err("non-positive")>
      * ```
      */
-    const traverse: <E, A, B>(f: (a: A) => Task<Result<E, B>>) => (data: readonly A[]) => Task<Result<E, readonly B[]>>;
+    const traverse: <E, A, B>(f: (a: A) => Task.Result<E, B>) => (data: readonly A[]) => Task.Result<E, readonly B[]>;
     /**
      * Collects an array of Task.Results into a Task.Result of array.
      * Returns the first Err if any element is Err, runs sequentially.
@@ -37,7 +37,7 @@ declare namespace ArrTaskResult {
      * )(); // Deferred<Ok([1, 2])>
      * ```
      */
-    const sequence: <E, A>(data: readonly Task<Result<E, A>>[]) => Task<Result<E, readonly A[]>>;
+    const sequence: <E, A>(data: readonly Task.Result<E, A>[]) => Task.Result<E, readonly A[]>;
 }
 interface TaskTraverse {
     <A, B>(f: (a: A) => Task<B>): (data: readonly A[]) => Task<readonly B[]>;
@@ -155,6 +155,60 @@ declare namespace Arr {
  * ```
  */
 declare const BigNum: {
+    is: {
+        /**
+         * Returns `true` when the bigint is equal to zero (`0n`).
+         *
+         * @example
+         * ```ts
+         * BigNum.is.zero(0n); // true
+         * BigNum.is.zero(5n); // false
+         * ```
+         */
+        zero: (b: bigint) => boolean;
+        /**
+         * Returns `true` when the bigint is an even integer.
+         *
+         * @example
+         * ```ts
+         * BigNum.is.even(4n); // true
+         * BigNum.is.even(3n); // false
+         * ```
+         */
+        even: (b: bigint) => boolean;
+        /**
+         * Returns `true` when the bigint is an odd integer.
+         *
+         * @example
+         * ```ts
+         * BigNum.is.odd(3n); // true
+         * BigNum.is.odd(4n); // false
+         * ```
+         */
+        odd: (b: bigint) => boolean;
+        /**
+         * Returns `true` when the bigint is strictly greater than zero (`0n`).
+         *
+         * @example
+         * ```ts
+         * BigNum.is.positive(5n);  // true
+         * BigNum.is.positive(0n);  // false
+         * BigNum.is.positive(-5n); // false
+         * ```
+         */
+        positive: (b: bigint) => boolean;
+        /**
+         * Returns `true` when the bigint is strictly less than zero (`0n`).
+         *
+         * @example
+         * ```ts
+         * BigNum.is.negative(-5n); // true
+         * BigNum.is.negative(0n);  // false
+         * BigNum.is.negative(5n);  // false
+         * ```
+         */
+        negative: (b: bigint) => boolean;
+    };
     from: {
         /**
          * Safely parses a string into a `bigint`. Returns `None` if parsing fails.
@@ -283,6 +337,293 @@ declare const BigNum: {
     max: (b: bigint) => (a: bigint) => bigint;
 };
 
+type BoolMatchCases<A, B> = {
+    readonly true: () => A;
+    readonly false: () => B;
+};
+declare const Bool: {
+    is: {
+        /**
+         * Type guard — checks if a value is a primitive boolean.
+         *
+         * @example
+         * ```ts
+         * Bool.is.boolean(true);      // true
+         * Bool.is.boolean(false);     // true
+         * Bool.is.boolean("true");    // false
+         * Bool.is.boolean(null);      // false
+         * ```
+         */
+        boolean: (u: unknown) => u is boolean;
+        /**
+         * Narrowing guard — checks if a value is strictly `true`.
+         *
+         * @example
+         * ```ts
+         * Bool.is.true(true);  // true
+         * Bool.is.true(false); // false
+         * ```
+         */
+        true: (u: unknown) => u is true;
+        /**
+         * Narrowing guard — checks if a value is strictly `false`.
+         *
+         * @example
+         * ```ts
+         * Bool.is.false(false); // true
+         * Bool.is.false(true);  // false
+         * ```
+         */
+        false: (u: unknown) => u is false;
+        /**
+         * Type guard — checks if a value is truthy (not `false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
+         *
+         * @example
+         * ```ts
+         * Bool.is.truthy("hello"); // true
+         * Bool.is.truthy(42);      // true
+         * Bool.is.truthy(0);       // false
+         * Bool.is.truthy(null);    // false
+         * ```
+         */
+        truthy: <T>(u: T) => u is Exclude<T, false | 0 | 0n | "" | null | undefined>;
+        /**
+         * Type guard — checks if a value is falsy (`false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
+         *
+         * @example
+         * ```ts
+         * Bool.is.falsy("");        // true
+         * Bool.is.falsy(null);      // true
+         * Bool.is.falsy("content"); // false
+         * ```
+         */
+        falsy: (u: unknown) => u is false | 0 | 0n | "" | null | undefined;
+    };
+    /**
+     * Unary boolean negation: inverts the given boolean value.
+     *
+     * @example
+     * ```ts
+     * Bool.not(true);  // false
+     * Bool.not(false); // true
+     * ```
+     */
+    not: (b: boolean) => boolean;
+    /**
+     * Logical AND combinator. Returns `true` only if both `self` and `that` are `true`.
+     *
+     * Data-last: `pipe(self, Bool.and(that))`.
+     *
+     * @example
+     * ```ts
+     * pipe(true, Bool.and(true));  // true
+     * pipe(true, Bool.and(false)); // false
+     * ```
+     */
+    and: (that: boolean) => (self: boolean) => boolean;
+    /**
+     * Logical OR combinator. Returns `true` if either `self` or `that` is `true`.
+     *
+     * Data-last: `pipe(self, Bool.or(that))`.
+     *
+     * @example
+     * ```ts
+     * pipe(false, Bool.or(true));  // true
+     * pipe(false, Bool.or(false)); // false
+     * ```
+     */
+    or: (that: boolean) => (self: boolean) => boolean;
+    /**
+     * Logical XOR (exclusive OR) combinator. Returns `true` if exactly one of `self` and `that` is `true`.
+     *
+     * Data-last: `pipe(self, Bool.xor(that))`.
+     *
+     * @example
+     * ```ts
+     * pipe(true, Bool.xor(false)); // true
+     * pipe(true, Bool.xor(true));  // false
+     * ```
+     */
+    xor: (that: boolean) => (self: boolean) => boolean;
+    /**
+     * Lazy logical AND combinator.
+     * If `self` is `false`, the `that` computation is never evaluated.
+     *
+     * Data-last: `pipe(self, Bool.andLazy(that))`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   isCached,
+     *   Bool.andLazy(() => checkPermissions())
+     * );
+     * ```
+     */
+    andLazy: (that: () => boolean) => (self: boolean) => boolean;
+    /**
+     * Lazy logical OR combinator.
+     * If `self` is `true`, the `that` computation is never evaluated.
+     *
+     * Data-last: `pipe(self, Bool.orLazy(that))`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   isAdmin,
+     *   Bool.orLazy(() => hasAccess(userId))
+     * );
+     * ```
+     */
+    orLazy: (that: () => boolean) => (self: boolean) => boolean;
+    /**
+     * N-ary AND aggregation across an array of booleans.
+     * Returns `true` if every boolean is `true`, or for an empty array (vacuous truth).
+     * Short-circuits on the first `false`.
+     *
+     * @example
+     * ```ts
+     * Bool.all([true, true, true]);  // true
+     * Bool.all([true, false, true]); // false
+     * Bool.all([]);                  // true
+     * ```
+     */
+    all: (booleans: readonly boolean[]) => boolean;
+    /**
+     * N-ary OR aggregation across an array of booleans.
+     * Returns `true` if at least one boolean is `true`. Returns `false` for an empty array.
+     * Short-circuits on the first `true`.
+     *
+     * @example
+     * ```ts
+     * Bool.any([false, true, false]); // true
+     * Bool.any([false, false]);       // false
+     * Bool.any([]);                   // false
+     * ```
+     */
+    any: (booleans: readonly boolean[]) => boolean;
+    /**
+     * Catamorphism for boolean: evaluates `onFalse()` when `false` and `onTrue()` when `true`.
+     *
+     * Positional ordering: `onFalse` first, `onTrue` second.
+     * Aligned with `Result.fold(onErr, onOk)` and `Maybe.fold(onNone, onSome)`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   isDarkMode,
+     *   Bool.fold(
+     *     () => "light-theme",
+     *     () => "dark-theme"
+     *   )
+     * );
+     * ```
+     */
+    fold: <A, B>(onFalse: () => A, onTrue: () => B) => (b: boolean) => A | B;
+    /**
+     * Pattern matching on boolean using named cases `{ true, false }`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   isEnabled,
+     *   Bool.match({
+     *     true: () => "Feature Active",
+     *     false: () => "Feature Disabled",
+     *   })
+     * );
+     * ```
+     */
+    match: <A, B>(cases: BoolMatchCases<A, B>) => (b: boolean) => A | B;
+    from: {
+        /**
+         * Parses a string into a `Maybe<boolean>`.
+         * Returns `Some(true)` for `"true"`, `Some(false)` for `"false"` (case-insensitive & trimmed),
+         * and `None` for any other string.
+         *
+         * @example
+         * ```ts
+         * Bool.from.string("true");  // Some(true)
+         * Bool.from.string("FALSE"); // Some(false)
+         * Bool.from.string("yes");   // None
+         * ```
+         */
+        string: (s: string) => Maybe<boolean>;
+        /**
+         * Converts a number into a `Maybe<boolean>`.
+         * Returns `Some(true)` for `1`, `Some(false)` for `0`, and `None` for any other number.
+         *
+         * @example
+         * ```ts
+         * Bool.from.number(1);  // Some(true)
+         * Bool.from.number(0);  // Some(false)
+         * Bool.from.number(42); // None
+         * ```
+         */
+        number: (n: number) => Maybe<boolean>;
+        /**
+         * Coerces any unknown value into a boolean via standard JS `Boolean(value)`.
+         *
+         * @example
+         * ```ts
+         * Bool.from.truthy("hello"); // true
+         * Bool.from.truthy(0);       // false
+         * ```
+         */
+        truthy: (value: unknown) => boolean;
+    };
+    to: {
+        /**
+         * Lifts a boolean condition into a `Maybe`.
+         * Returns `Some(onTrue())` when `true`, and `None` when `false`.
+         *
+         * @example
+         * ```ts
+         * pipe(
+         *   user.isVerified,
+         *   Bool.to.Maybe(() => user.profile)
+         * ); // Some(profile) or None
+         * ```
+         */
+        Maybe: <A>(onTrue: () => A) => (b: boolean) => Maybe<A>;
+        /**
+         * Lifts a boolean condition into a `Result`.
+         * Returns `Ok(onOk())` when `true`, and `Err(onErr())` when `false`.
+         *
+         * @example
+         * ```ts
+         * pipe(
+         *   hasPermission,
+         *   Bool.to.Result(
+         *     () => "Permission denied",
+         *     () => sessionData
+         *   )
+         * ); // Ok(sessionData) or Err("Permission denied")
+         * ```
+         */
+        Result: <E, A>(onErr: () => E, onOk: () => A) => (b: boolean) => Result<E, A>;
+        /**
+         * Converts a boolean to numeric `1` or `0`.
+         *
+         * @example
+         * ```ts
+         * Bool.to.number(true);  // 1
+         * Bool.to.number(false); // 0
+         * ```
+         */
+        number: (b: boolean) => 1 | 0;
+        /**
+         * Converts a boolean to literal string `"true"` or `"false"`.
+         *
+         * @example
+         * ```ts
+         * Bool.to.string(true);  // "true"
+         * Bool.to.string(false); // "false"
+         * ```
+         */
+        string: (b: boolean) => "true" | "false";
+    };
+};
+
 /**
  * A branded type representing a key-value dictionary with at least one entry.
  */
@@ -1124,4 +1465,4 @@ declare namespace Uniq {
     type NonEmpty<A> = NonEmptySet<A>;
 }
 
-export { Arr, BigNum, Dict, Json, type NonEmptyMap, type NonEmptyRecord, type NonEmptySet, type NonEmptyString, Num, Rec, Str, Uniq };
+export { Arr, BigNum, Bool, type BoolMatchCases, Dict, Json, type NonEmptyMap, type NonEmptyRecord, type NonEmptySet, type NonEmptyString, Num, Rec, Str, Uniq };