@nlozgachev/pipelined 0.63.0 → 0.64.0

package/dist/data.cjs

@@ -3,9 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -22,6 +22,7 @@ var Data_exports = {};
 __export(Data_exports, {
   Arr: () => Arr,
   BigNum: () => BigNum,
+  Bool: () => Bool,
   Dict: () => Dict,
   Json: () => Json,
   Num: () => Num,
@@ -1749,6 +1750,60 @@ var Arr = {
 
 // src/Data/BigNum.ts
 var 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) => b === 0n,
+    /**
+     * Returns `true` when the bigint is an even integer.
+     *
+     * @example
+     * ```ts
+     * BigNum.is.even(4n); // true
+     * BigNum.is.even(3n); // false
+     * ```
+     */
+    even: (b) => b % 2n === 0n,
+    /**
+     * Returns `true` when the bigint is an odd integer.
+     *
+     * @example
+     * ```ts
+     * BigNum.is.odd(3n); // true
+     * BigNum.is.odd(4n); // false
+     * ```
+     */
+    odd: (b) => b % 2n !== 0n,
+    /**
+     * 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) => b > 0n,
+    /**
+     * 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) => b < 0n
+  },
   // --- from ---
   from: {
     /**
@@ -1898,6 +1953,345 @@ var BigNum = {
   max: (b) => (a) => a > b ? a : b
 };
 
+// src/Data/Bool.ts
+var isBoolean = (u) => typeof u === "boolean";
+var isTrue = (u) => u === true;
+var isFalse = (u) => u === false;
+var isTruthy = (u) => Boolean(u);
+var isFalsy = (u) => !u;
+var not = (b) => !b;
+var and = (that) => (self) => self && that;
+var or = (that) => (self) => self || that;
+var xor = (that) => (self) => self !== that;
+var andLazy = (that) => (self) => self && that();
+var orLazy = (that) => (self) => self || that();
+var all = (booleans) => {
+  for (let i = 0; i < booleans.length; i++) {
+    if (!booleans[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+var any = (booleans) => {
+  for (let i = 0; i < booleans.length; i++) {
+    if (booleans[i]) {
+      return true;
+    }
+  }
+  return false;
+};
+var fold = (onFalse, onTrue) => (b) => b ? onTrue() : onFalse();
+var match = (cases) => (b) => b ? cases.true() : cases.false();
+var fromString = (s) => {
+  const trimmed = s.trim().toLowerCase();
+  if (trimmed === "true") {
+    return Maybe.make.some(true);
+  }
+  if (trimmed === "false") {
+    return Maybe.make.some(false);
+  }
+  return Maybe.make.none();
+};
+var fromNumber = (n) => {
+  if (n === 1) {
+    return Maybe.make.some(true);
+  }
+  if (n === 0) {
+    return Maybe.make.some(false);
+  }
+  return Maybe.make.none();
+};
+var fromTruthy = (value) => Boolean(value);
+var toMaybe = (onTrue) => (b) => b ? Maybe.make.some(onTrue()) : Maybe.make.none();
+var toResult2 = (onErr, onOk) => (b) => b ? Result.make.ok(onOk()) : Result.make.err(onErr());
+var toNumber = (b) => b ? 1 : 0;
+var toString = (b) => b ? "true" : "false";
+var 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: isBoolean,
+    /**
+     * Narrowing guard — checks if a value is strictly `true`.
+     *
+     * @example
+     * ```ts
+     * Bool.is.true(true);  // true
+     * Bool.is.true(false); // false
+     * ```
+     */
+    true: isTrue,
+    /**
+     * Narrowing guard — checks if a value is strictly `false`.
+     *
+     * @example
+     * ```ts
+     * Bool.is.false(false); // true
+     * Bool.is.false(true);  // false
+     * ```
+     */
+    false: isFalse,
+    /**
+     * 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: isTruthy,
+    /**
+     * 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: isFalsy
+  },
+  /**
+   * Unary boolean negation: inverts the given boolean value.
+   *
+   * @example
+   * ```ts
+   * Bool.not(true);  // false
+   * Bool.not(false); // true
+   * ```
+   */
+  not,
+  /**
+   * 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,
+  /**
+   * 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,
+  /**
+   * 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,
+  /**
+   * 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,
+  /**
+   * 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,
+  /**
+   * 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,
+  /**
+   * 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,
+  /**
+   * 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,
+  /**
+   * Pattern matching on boolean using named cases `{ true, false }`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   isEnabled,
+   *   Bool.match({
+   *     true: () => "Feature Active",
+   *     false: () => "Feature Disabled",
+   *   })
+   * );
+   * ```
+   */
+  match,
+  // --- from ---
+  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: fromString,
+    /**
+     * 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: fromNumber,
+    /**
+     * 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: fromTruthy
+  },
+  // --- to ---
+  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: toMaybe,
+    /**
+     * 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: toResult2,
+    /**
+     * Converts a boolean to numeric `1` or `0`.
+     *
+     * @example
+     * ```ts
+     * Bool.to.number(true);  // 1
+     * Bool.to.number(false); // 0
+     * ```
+     */
+    number: toNumber,
+    /**
+     * Converts a boolean to literal string `"true"` or `"false"`.
+     *
+     * @example
+     * ```ts
+     * Bool.to.string(true);  // "true"
+     * Bool.to.string(false); // "false"
+     * ```
+     */
+    string: toString
+  }
+};
+
 // src/Data/Dict.ts
 var DictIs = {
   empty: (m) => m.size === 0,
@@ -3287,6 +3681,7 @@ var Uniq = {
 0 && (module.exports = {
   Arr,
   BigNum,
+  Bool,
   Dict,
   Json,
   Num,