@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.84

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

@@ -1 +1,382 @@
-"use strict";var i=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var h=Object.prototype.hasOwnProperty;var d=(r,e)=>{for(var n in e)i(r,n,{get:e[n],enumerable:!0})},g=(r,e,n,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of m(e))!h.call(r,o)&&o!==n&&i(r,o,{get:()=>e[o],enumerable:!(a=w(e,o))||a.enumerable});return r};var x=r=>g(i({},"__esModule",{value:!0}),r);var U={};d(U,{all:()=>l,any:()=>c,checkConditions:()=>q,compare:()=>b,compareBoolean:()=>R,countFalsy:()=>$,countTruthy:()=>p,createPipeline:()=>V,createToggle:()=>M,debounceBoolean:()=>J,isBoolean:()=>k,isBooleanArray:()=>z,isBooleanLike:()=>f,isBooleanLikeArray:()=>I,memoizeBoolean:()=>P,nand:()=>E,none:()=>y,nor:()=>L,not:()=>j,randomBoolean:()=>K,safeToBoolean:()=>N,toBoolean:()=>u,validateBooleanConstraint:()=>F,xnor:()=>O,xor:()=>S});module.exports=x(U);var k=r=>r===!0||r===!1,f=r=>{if(r===!0||r===!1||r===0||r===1)return!0;if(typeof r=="string"){let e=r.toLowerCase().trim();return e==="true"||e==="false"||e==="0"||e==="1"}return!1},u=(r,e="strict",n=!1)=>{if(r===null&&e==="strict")throw new Error(`Cannot convert ${r} to boolean with strict strategy`);if(typeof r=="boolean")return r;switch(e){case"strict":return B(r);case"truthy":return!!r;case"falsy":return C(r);case"string":return A(r);case"number":return T(r);default:return!!r}},B=r=>{let e=typeof r=="string"?r.trim().toLowerCase():r;if(e===1||e==="1")return!0;if(e===0||e==="0")return!1;if(typeof e=="string"){let n=e.trim().toLowerCase();if(n==="true")return!0;if(n==="false")return!1;throw new Error(`Cannot convert string "${e}" to boolean with strict strategy`)}if(e===!0)return!0;if(e===!1)return!1;throw new Error(`Cannot convert ${typeof e} to boolean with strict strategy`)},C=r=>{if(typeof r=="string"){let e=r.trim().toLowerCase();return!(e===""||e==="0"||e==="false"||e==="null"||e==="undefined"||e==="nan")}return typeof r=="number"?!(r===0||isNaN(r)):!!r},A=r=>{if(typeof r!="string")throw new Error(`String strategy requires string input, got ${typeof r}`);let e=r.trim().toLowerCase();if(["true","yes","y","on","1","enabled","enable","active"].includes(e))return!0;if(["false","no","n","off","0","disabled","disable","inactive"].includes(e))return!1;if(!isNaN(Number(e)))return Number(e)!==0;throw new Error(`Cannot convert string "${r}" to boolean`)},T=r=>{if(typeof r!="number")throw new Error(`Number strategy requires number input, got ${typeof r}`);return isNaN(r)||r===0?!1:r===1?!0:r!==0},N=(r,e)=>{try{return u(r,"strict")}catch{return e!==void 0?e:!1}},l=r=>{if(!Array.isArray(r)||r.length===0)return!1;for(let e of r)if(!e)return!1;return!0},c=r=>{if(!Array.isArray(r)||r.length===0)return!1;for(let e of r)if(e)return!0;return!1},y=r=>!c(r),j=r=>!r,S=r=>{if(!Array.isArray(r))return!1;let e=0;for(let n of r)if(n&&(e++,e>1))return!1;return e===1},E=r=>!l(r),L=r=>y(r),O=r=>{if(!Array.isArray(r)||r.length===0)return!0;let e=!!r[0];for(let n=1;n<r.length;n++)if(!!r[n]!==e)return!1;return!0},p=r=>{if(!Array.isArray(r))return 0;let e=0;for(let n of r)n&&e++;return e},$=r=>Array.isArray(r)?r.length-p(r):0,M=(r=!1)=>{let e=r;return()=>(e=!e,e)},b=(r,e,n="===")=>{switch(n){case"==":return r==e;case"===":return r===e;case"!=":return r!=e;case"!==":return r!==e;case">":return r>e;case"<":return r<e;case">=":return r>=e;case"<=":return r<=e;default:throw new Error(`Unsupported operator: ${n}`)}},q=(r,e)=>{for(let n of e)if(!b(r,n.value,n.operator))return!1;return!0},F=(r,e)=>{switch(e){case"required":return r===!0;case"optional":return r===!0||r===!1;case"true":return r===!0;case"false":return r===!1;case"truthy":return!!r;case"falsy":return!r;default:return!1}},K=(r=.5)=>{if(r<0||r>1)throw new Error("Probability must be between 0 and 1");return r===0?!1:Math.random()<=r},J=(r,e)=>{let n,a;return(...o)=>(n&&clearTimeout(n),n=setTimeout(()=>{a=r(...o)},e),a)},P=r=>{let e=new WeakMap;return((...n)=>{let a=null,o="";for(let t=0;t<n.length;t++)if(n[t]!==null&&typeof n[t]=="object"){a=n[t];break}if(o=JSON.stringify(n),a){let t=e.get(a);if(t||(t=new Map,e.set(a,t)),t.has(o))return t.get(o);let s=r(...n);return t.set(o,s),s}else{let t=e.get(Object.prototype)||new Map;if(e.has(Object.prototype)||e.set(Object.prototype,t),t.has(o))return t.get(o);let s=r(...n);return t.set(o,s),s}})},V=r=>e=>{for(let n of r)if(!n(e))return!1;return!0},z=r=>Array.isArray(r)&&r.every(e=>e===!0||e===!1),I=r=>Array.isArray(r)&&r.every(e=>f(e)),R=(r,e)=>{let n=u(r),a=u(e);return n!==a};
+"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;
+};