@fluixi/utils 1.0.0-alpha.100

package/dist/lib/primitive/boolean/index.cjs

@@ -0,0 +1,382 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/primitive/boolean/index.ts
+var index_exports = {};
+__export(index_exports, {
+  all: () => all,
+  any: () => any,
+  checkConditions: () => checkConditions,
+  compare: () => compare,
+  compareBoolean: () => compareBoolean,
+  countFalsy: () => countFalsy,
+  countTruthy: () => countTruthy,
+  createPipeline: () => createPipeline,
+  createToggle: () => createToggle,
+  debounceBoolean: () => debounceBoolean,
+  isBoolean: () => isBoolean,
+  isBooleanArray: () => isBooleanArray,
+  isBooleanLike: () => isBooleanLike,
+  isBooleanLikeArray: () => isBooleanLikeArray,
+  memoizeBoolean: () => memoizeBoolean,
+  nand: () => nand,
+  none: () => none,
+  nor: () => nor,
+  not: () => not,
+  randomBoolean: () => randomBoolean,
+  safeToBoolean: () => safeToBoolean,
+  toBoolean: () => toBoolean,
+  validateBooleanConstraint: () => validateBooleanConstraint,
+  xnor: () => xnor,
+  xor: () => xor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/primitive/boolean/boolean.ts
+var isBoolean = (value) => {
+  return value === true || value === false;
+};
+var isBooleanLike = (value) => {
+  if (value === true || value === false) return true;
+  if (value === 0 || value === 1) return true;
+  if (typeof value === "string") {
+    const lower = value.toLowerCase().trim();
+    return lower === "true" || lower === "false" || lower === "0" || lower === "1";
+  }
+  return false;
+};
+var toBoolean = (value, strategy = "strict", debug = false) => {
+  if (value === null) {
+    if (strategy === "strict") {
+      throw new Error(
+        `Cannot convert ${value} to boolean with strict strategy`
+      );
+    }
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  switch (strategy) {
+    case "strict":
+      return convertStrict(value);
+    case "truthy":
+      return Boolean(value);
+    case "falsy":
+      return convertFalsy(value);
+    // return !convertFalsy(value);
+    case "string":
+      return convertFromString(value);
+    case "number":
+      return convertFromNumber(value);
+    default:
+      return Boolean(value);
+  }
+};
+var convertStrict = (_value) => {
+  const value = typeof _value === "string" ? _value.trim().toLowerCase() : _value;
+  if (value === 1 || value === "1") return true;
+  if (value === 0 || value === "0") return false;
+  if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    throw new Error(
+      `Cannot convert string "${value}" to boolean with strict strategy`
+    );
+  }
+  if (value === true) return true;
+  if (value === false) return false;
+  throw new Error(
+    `Cannot convert ${typeof value} to boolean with strict strategy`
+  );
+};
+var convertFalsy = (value) => {
+  if (typeof value === "string") {
+    const trimmed = value.trim().toLowerCase();
+    if (trimmed === "" || trimmed === "0" || trimmed === "false" || trimmed === "null" || trimmed === "undefined" || trimmed === "nan") {
+      return false;
+    }
+    return true;
+  }
+  if (typeof value === "number") {
+    if (value === 0 || isNaN(value)) return false;
+    return true;
+  }
+  return Boolean(value);
+};
+var convertFromString = (value) => {
+  if (typeof value !== "string") {
+    throw new Error(
+      `String strategy requires string input, got ${typeof value}`
+    );
+  }
+  const trimmed = value.trim().toLowerCase();
+  if (["true", "yes", "y", "on", "1", "enabled", "enable", "active"].includes(
+    trimmed
+  )) {
+    return true;
+  }
+  if ([
+    "false",
+    "no",
+    "n",
+    "off",
+    "0",
+    "disabled",
+    "disable",
+    "inactive"
+  ].includes(trimmed)) {
+    return false;
+  }
+  if (!isNaN(Number(trimmed))) {
+    return Number(trimmed) !== 0;
+  }
+  throw new Error(`Cannot convert string "${value}" to boolean`);
+};
+var convertFromNumber = (value) => {
+  if (typeof value !== "number") {
+    throw new Error(
+      `Number strategy requires number input, got ${typeof value}`
+    );
+  }
+  if (isNaN(value)) return false;
+  if (value === 0) return false;
+  if (value === 1) return true;
+  return value !== 0;
+};
+var safeToBoolean = (value, fallback) => {
+  try {
+    return toBoolean(value, "strict");
+  } catch {
+    return fallback !== void 0 ? fallback : false;
+  }
+};
+var all = (values) => {
+  if (!Array.isArray(values) || values.length === 0) {
+    return false;
+  }
+  for (const value of values) {
+    if (!Boolean(value)) {
+      return false;
+    }
+  }
+  return true;
+};
+var any = (values) => {
+  if (!Array.isArray(values) || values.length === 0) {
+    return false;
+  }
+  for (const value of values) {
+    if (Boolean(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+var none = (values) => {
+  return !any(values);
+};
+var not = (value) => {
+  return !Boolean(value);
+};
+var xor = (values) => {
+  if (!Array.isArray(values)) {
+    return false;
+  }
+  let truthyCount = 0;
+  for (const value of values) {
+    if (Boolean(value)) {
+      truthyCount++;
+      if (truthyCount > 1) {
+        return false;
+      }
+    }
+  }
+  return truthyCount === 1;
+};
+var nand = (values) => {
+  return !all(values);
+};
+var nor = (values) => {
+  return none(values);
+};
+var xnor = (values) => {
+  if (!Array.isArray(values) || values.length === 0) {
+    return true;
+  }
+  const firstTruthy = Boolean(values[0]);
+  for (let i = 1; i < values.length; i++) {
+    if (Boolean(values[i]) !== firstTruthy) {
+      return false;
+    }
+  }
+  return true;
+};
+var countTruthy = (values) => {
+  if (!Array.isArray(values)) {
+    return 0;
+  }
+  let count = 0;
+  for (const value of values) {
+    if (Boolean(value)) {
+      count++;
+    }
+  }
+  return count;
+};
+var countFalsy = (values) => {
+  if (!Array.isArray(values)) {
+    return 0;
+  }
+  return values.length - countTruthy(values);
+};
+var createToggle = (initialState = false) => {
+  let state = initialState;
+  return () => {
+    state = !state;
+    return state;
+  };
+};
+var compare = (a, b, operator = "===") => {
+  switch (operator) {
+    case "==":
+      return a == b;
+    case "===":
+      return a === b;
+    case "!=":
+      return a != b;
+    case "!==":
+      return a !== b;
+    case ">":
+      return a > b;
+    case "<":
+      return a < b;
+    case ">=":
+      return a >= b;
+    case "<=":
+      return a <= b;
+    default:
+      throw new Error(`Unsupported operator: ${operator}`);
+  }
+};
+var checkConditions = (value, checks) => {
+  for (const check of checks) {
+    if (!compare(value, check.value, check.operator)) {
+      return false;
+    }
+  }
+  return true;
+};
+var validateBooleanConstraint = (value, constraint) => {
+  switch (constraint) {
+    case "required":
+      return value === true;
+    case "optional":
+      return value === true || value === false;
+    case "true":
+      return value === true;
+    case "false":
+      return value === false;
+    case "truthy":
+      return Boolean(value);
+    case "falsy":
+      return !Boolean(value);
+    default:
+      return false;
+  }
+};
+var randomBoolean = (probability = 0.5) => {
+  if (probability < 0 || probability > 1) {
+    throw new Error("Probability must be between 0 and 1");
+  }
+  if (probability === 0) return false;
+  return Math.random() <= probability;
+};
+var debounceBoolean = (fn, delay) => {
+  let timeoutId;
+  let lastResult;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      lastResult = fn(...args);
+    }, delay);
+    return lastResult;
+  };
+};
+var memoizeBoolean = (fn) => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return ((...args) => {
+    let keyObj = null;
+    let keyString = "";
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] !== null && typeof args[i] === "object") {
+        keyObj = args[i];
+        break;
+      }
+    }
+    keyString = JSON.stringify(args);
+    if (keyObj) {
+      let objCache = cache.get(keyObj);
+      if (!objCache) {
+        objCache = /* @__PURE__ */ new Map();
+        cache.set(keyObj, objCache);
+      }
+      if (objCache.has(keyString)) {
+        return objCache.get(keyString);
+      }
+      const result = fn(...args);
+      objCache.set(keyString, result);
+      return result;
+    } else {
+      const stringCache = cache.get(Object.prototype) || /* @__PURE__ */ new Map();
+      if (!cache.has(Object.prototype)) {
+        cache.set(Object.prototype, stringCache);
+      }
+      if (stringCache.has(keyString)) {
+        return stringCache.get(keyString);
+      }
+      const result = fn(...args);
+      stringCache.set(keyString, result);
+      return result;
+    }
+  });
+};
+var createPipeline = (functions) => {
+  return (value) => {
+    for (const fn of functions) {
+      if (!fn(value)) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+var isBooleanArray = (value) => {
+  return Array.isArray(value) && value.every((item) => item === true || item === false);
+};
+var isBooleanLikeArray = (value) => {
+  return Array.isArray(value) && value.every((item) => isBooleanLike(item));
+};
+var compareBoolean = (value, newValue) => {
+  const o = toBoolean(value);
+  const n = toBoolean(newValue);
+  return o !== n;
+};

package/dist/lib/primitive/boolean/index.d.ts

@@ -0,0 +1,3 @@
+export * from './boolean.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/primitive/boolean/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/primitive/boolean/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA"}

package/dist/lib/primitive/boolean/index.js

@@ -0,0 +1,2 @@
+export * from './boolean.js';
+export * from './types.js';