@fluixi/utils 1.0.0-alpha.53

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

@@ -0,0 +1,615 @@
+/**
+ * Boolean utilities collection for TypeScript
+ * Provides optimized methods for common boolean operations and conversions
+ */
+/**
+ * Checks if a value is a boolean (strict type guard)
+ * @param value - The value to check
+ * @returns True if value is exactly true or false
+ * @example
+ * isBoolean(true) // true
+ * isBoolean(false) // true
+ * isBoolean(1) // false
+ * isBoolean("true") // false
+ */
+export const isBoolean = (value) => {
+    return value === true || value === false;
+};
+/**
+ * Checks if a value is a boolean or boolean-like
+ * Accepts 0, 1, "true", "false", "0", "1" as boolean-like
+ * @param value - The value to check
+ * @returns True if value is boolean or boolean-like
+ * @example
+ * isBooleanLike(true) // true
+ * isBooleanLike(1) // true
+ * isBooleanLike("true") // true
+ * isBooleanLike("yes") // false
+ */
+export const 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;
+};
+/**
+ * Converts any value to boolean with various strategies
+ * @param value - The value to convert
+ * @param strategy - Conversion strategy (default: 'strict')
+ *   - 'strict': Only true/false, 1/0, "true"/"false", "1"/"0" are converted
+ *   - 'truthy': JavaScript truthy values become true
+ *   - 'falsy': JavaScript falsy values become false
+ *   - 'string': Parse string representations strictly
+ *   - 'number': Parse number representations strictly
+ * @returns Converted boolean
+ * @throws {Error} If value cannot be converted with strict strategy
+ * @example
+ * toBoolean("true") // true
+ * toBoolean(1) // true
+ * toBoolean("yes", "strict") // throws Error
+ * toBoolean("yes", "truthy") // true (non-empty string is truthy)
+ */
+export const toBoolean = (value, strategy = 'strict', debug = false) => {
+    // Handle null/undefined
+    // if (debug) {
+    //   console.log('null value', strategy, value);
+    // }
+    if (value === null) {
+        if (strategy === 'strict') {
+            throw new Error(`Cannot convert ${value} to boolean with strict strategy`);
+        }
+        // return false;
+    }
+    // Handle boolean directly
+    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);
+    }
+};
+/**
+ * Strict conversion for toBoolean
+ */
+const 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`);
+};
+/**
+ * Falsy conversion for toBoolean
+ */
+const 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);
+};
+/**
+ * String conversion for toBoolean
+ */
+const convertFromString = (value) => {
+    if (typeof value !== 'string') {
+        throw new Error(`String strategy requires string input, got ${typeof value}`);
+    }
+    const trimmed = value.trim().toLowerCase();
+    // True values
+    if (['true', 'yes', 'y', 'on', '1', 'enabled', 'enable', 'active'].includes(trimmed)) {
+        return true;
+    }
+    // False values
+    if ([
+        'false',
+        'no',
+        'n',
+        'off',
+        '0',
+        'disabled',
+        'disable',
+        'inactive',
+    ].includes(trimmed)) {
+        return false;
+    }
+    // Try to parse as number
+    if (!isNaN(Number(trimmed))) {
+        return Number(trimmed) !== 0;
+    }
+    throw new Error(`Cannot convert string "${value}" to boolean`);
+};
+/**
+ * Number conversion for toBoolean
+ */
+const 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;
+    // For other numbers, non-zero is truthy
+    return value !== 0;
+};
+/**
+ * Safely converts any value to boolean with fallback
+ * @param value - The value to convert
+ * @param fallback - Fallback value if conversion fails (default: false)
+ * @returns Converted boolean or fallback
+ * @example
+ * safeToBoolean("true") // true
+ * safeToBoolean("invalid", true) // true (fallback)
+ * safeToBoolean(null, false) // false
+ */
+export const safeToBoolean = (value, fallback) => {
+    try {
+        return toBoolean(value, 'strict');
+    }
+    catch {
+        return fallback !== undefined ? fallback : false;
+    }
+};
+/**
+ * Checks if all values are truthy (logical AND)
+ * @param values - Array of values to check
+ * @returns True if all values are truthy
+ * @example
+ * all([true, 1, "hello"]) // true
+ * all([true, false]) // false
+ */
+export const all = (values) => {
+    if (!Array.isArray(values) || values.length === 0) {
+        return false;
+    }
+    for (const value of values) {
+        if (!Boolean(value)) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Checks if any value is truthy (logical OR)
+ * @param values - Array of values to check
+ * @returns True if any value is truthy
+ * @example
+ * any([false, 0, "hello"]) // true
+ * any([false, 0, ""]) // false
+ */
+export const any = (values) => {
+    if (!Array.isArray(values) || values.length === 0) {
+        return false;
+    }
+    for (const value of values) {
+        if (Boolean(value)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Checks if no values are truthy (logical NOR)
+ * @param values - Array of values to check
+ * @returns True if no values are truthy
+ * @example
+ * none([false, 0, ""]) // true
+ * none([false, true]) // false
+ */
+export const none = (values) => {
+    return !any(values);
+};
+/**
+ * Logical NOT operation
+ * @param value - The value to negate
+ * @returns Negated boolean value
+ * @example
+ * not(true) // false
+ * not(false) // true
+ * not(1) // false (truthy becomes false)
+ */
+export const not = (value) => {
+    return !Boolean(value);
+};
+/**
+ * Logical XOR operation (exclusive OR)
+ * Returns true if exactly one of the values is truthy
+ * @param values - Array of values to check
+ * @returns True if exactly one value is truthy
+ * @example
+ * xor([true, false]) // true
+ * xor([true, true]) // false
+ * xor([false, false]) // false
+ */
+export const 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; // Early exit if more than one truthy
+            }
+        }
+    }
+    return truthyCount === 1;
+};
+/**
+ * Logical NAND operation (NOT AND)
+ * Returns true unless all values are truthy
+ * @param values - Array of values to check
+ * @returns True unless all values are truthy
+ * @example
+ * nand([true, true]) // false
+ * nand([true, false]) // true
+ */
+export const nand = (values) => {
+    return !all(values);
+};
+/**
+ * Logical NOR operation (NOT OR)
+ * Returns true only if all values are falsy
+ * @param values - Array of values to check
+ * @returns True only if all values are falsy
+ * @example
+ * nor([false, false]) // true
+ * nor([false, true]) // false
+ */
+export const nor = (values) => {
+    return none(values);
+};
+/**
+ * Logical XNOR operation (equivalence)
+ * Returns true if all values are the same truthiness
+ * @param values - Array of values to check
+ * @returns True if all values have same truthiness
+ * @example
+ * xnor([true, true]) // true
+ * xnor([true, false]) // false
+ * xnor([false, false, false]) // true
+ */
+export const 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;
+};
+/**
+ * Counts truthy values in an array
+ * @param values - Array of values to count
+ * @returns Number of truthy values
+ * @example
+ * countTruthy([true, false, 1, 0, "hello"]) // 3
+ */
+export const countTruthy = (values) => {
+    if (!Array.isArray(values)) {
+        return 0;
+    }
+    let count = 0;
+    for (const value of values) {
+        if (Boolean(value)) {
+            count++;
+        }
+    }
+    return count;
+};
+/**
+ * Counts falsy values in an array
+ * @param values - Array of values to count
+ * @returns Number of falsy values
+ * @example
+ * countFalsy([true, false, 0, "", null]) // 3
+ */
+export const countFalsy = (values) => {
+    if (!Array.isArray(values)) {
+        return 0;
+    }
+    return values.length - countTruthy(values);
+};
+/**
+ * Creates a boolean toggle function
+ * @param initialState - Initial state (default: false)
+ * @returns Function that toggles and returns current state
+ * @example
+ * const toggle = createToggle();
+ * toggle() // true
+ * toggle() // false
+ * toggle() // true
+ */
+export const createToggle = (initialState = false) => {
+    let state = initialState;
+    return () => {
+        state = !state;
+        return state;
+    };
+};
+/**
+ * Compares two values with various comparison operators
+ * @param a - First value
+ * @param b - Second value
+ * @param operator - Comparison operator
+ * @returns Result of comparison
+ * @example
+ * compare(5, 3, '>') // true
+ * compare(5, 5, '===') // false (different types)
+ * compare(5, '5', '==') // true
+ */
+export const 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}`);
+    }
+};
+/**
+ * Creates a boolean condition checker with multiple comparisons
+ * @param value - The value to check
+ * @param checks - Array of comparison checks
+ * @returns True if all checks pass
+ * @example
+ * checkConditions(5, [
+ *   { operator: '>', value: 0 },
+ *   { operator: '<', value: 10 }
+ * ]) // true
+ */
+export const checkConditions = (value, checks) => {
+    for (const check of checks) {
+        if (!compare(value, check.value, check.operator)) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Validates that a value is within a boolean constraint
+ * @param value - The value to validate
+ * @param constraint - Constraint type
+ * @returns True if value meets constraint
+ * @example
+ * validateBooleanConstraint(true, 'required') // true
+ * validateBooleanConstraint(false, 'required') // false
+ * validateBooleanConstraint(undefined, 'optional') // true
+ */
+export const 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;
+    }
+};
+/**
+ * Generates random boolean value
+ * @param probability - Probability of returning true (0 to 1, default: 0.5)
+ * @returns Random boolean
+ * @example
+ * randomBoolean() // true or false with 50% probability
+ * randomBoolean(0.8) // true 80% of the time
+ */
+export const 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;
+};
+/**
+ * Debounces a boolean function
+ * @param fn - Function that returns boolean
+ * @param delay - Debounce delay in ms
+ * @returns Debounced function
+ */
+export const debounceBoolean = (fn, delay) => {
+    let timeoutId;
+    let lastResult;
+    return (...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            lastResult = fn(...args);
+        }, delay);
+        return lastResult;
+    };
+};
+/**
+ * Memoizes a boolean function
+ * @param fn - Function that returns boolean
+ * @returns Memoized function
+ */
+export const memoizeBoolean = (fn) => {
+    const cache = new WeakMap();
+    return ((...args) => {
+        // Get a stable key for the cache
+        let keyObj = null;
+        let keyString = '';
+        // Find the first object argument to use as WeakMap key
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] !== null && typeof args[i] === 'object') {
+                keyObj = args[i];
+                break;
+            }
+        }
+        // Create a string key for the remaining arguments
+        keyString = JSON.stringify(args);
+        if (keyObj) {
+            // Use a two-level cache with WeakMap -> Map for object arguments
+            let objCache = cache.get(keyObj);
+            if (!objCache) {
+                objCache = 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 {
+            // Fallback to string-only cache for primitive arguments
+            const stringCache = cache.get(Object.prototype) || 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;
+        }
+    });
+};
+/**
+ * Creates a boolean pipeline (function composition)
+ * @param functions - Array of functions that return boolean
+ * @returns Function that applies all functions with AND logic
+ * @example
+ * const pipeline = createPipeline([
+ *   (x) => x > 0,
+ *   (x) => x < 10,
+ *   (x) => x % 2 === 0
+ * ]);
+ * pipeline(4) // true
+ * pipeline(5) // false
+ */
+export const createPipeline = (functions) => {
+    return (value) => {
+        for (const fn of functions) {
+            if (!fn(value)) {
+                return false;
+            }
+        }
+        return true;
+    };
+};
+/**
+ * Type guard for boolean array
+ * @param value - Value to check
+ * @returns True if value is a boolean array
+ */
+export const isBooleanArray = (value) => {
+    return (Array.isArray(value) &&
+        value.every((item) => item === true || item === false));
+};
+/**
+ * Type guard for boolean-like array
+ * @param value - Value to check
+ * @returns True if value is a boolean-like array
+ */
+export const isBooleanLikeArray = (value) => {
+    return Array.isArray(value) && value.every((item) => isBooleanLike(item));
+};
+export const compareBoolean = (value, newValue) => {
+    const o = toBoolean(value);
+    const n = toBoolean(newValue);
+    return o !== n;
+};
+// Export all utilities
+export default {
+    isBoolean,
+    isBooleanLike,
+    toBoolean,
+    safeToBoolean,
+    all,
+    any,
+    none,
+    not,
+    xor,
+    nand,
+    nor,
+    xnor,
+    countTruthy,
+    countFalsy,
+    createToggle,
+    compare,
+    checkConditions,
+    validateBooleanConstraint,
+    randomBoolean,
+    debounceBoolean,
+    memoizeBoolean,
+    createPipeline,
+    isBooleanArray,
+    isBooleanLikeArray,
+};

package/dist/lib/primitive/boolean/boolean.mjs

@@ -0,0 +1 @@
+var b=r=>r===!0||r===!1,i=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 w(r);case"truthy":return!!r;case"falsy":return m(r);case"string":return h(r);case"number":return d(r);default:return!!r}},w=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`)},m=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},h=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`)},d=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},g=(r,e)=>{try{return u(r,"strict")}catch{return e!==void 0?e:!1}},f=r=>{if(!Array.isArray(r)||r.length===0)return!1;for(let e of r)if(!e)return!1;return!0},l=r=>{if(!Array.isArray(r)||r.length===0)return!1;for(let e of r)if(e)return!0;return!1},c=r=>!l(r),k=r=>!r,x=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},B=r=>!f(r),C=r=>c(r),A=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},y=r=>{if(!Array.isArray(r))return 0;let e=0;for(let n of r)n&&e++;return e},T=r=>Array.isArray(r)?r.length-y(r):0,N=(r=!1)=>{let e=r;return()=>(e=!e,e)},p=(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}`)}},j=(r,e)=>{for(let n of e)if(!p(r,n.value,n.operator))return!1;return!0},S=(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}},E=(r=.5)=>{if(r<0||r>1)throw new Error("Probability must be between 0 and 1");return r===0?!1:Math.random()<=r},L=(r,e)=>{let n,o;return(...a)=>(n&&clearTimeout(n),n=setTimeout(()=>{o=r(...a)},e),o)},O=r=>{let e=new WeakMap;return((...n)=>{let o=null,a="";for(let t=0;t<n.length;t++)if(n[t]!==null&&typeof n[t]=="object"){o=n[t];break}if(a=JSON.stringify(n),o){let t=e.get(o);if(t||(t=new Map,e.set(o,t)),t.has(a))return t.get(a);let s=r(...n);return t.set(a,s),s}else{let t=e.get(Object.prototype)||new Map;if(e.has(Object.prototype)||e.set(Object.prototype,t),t.has(a))return t.get(a);let s=r(...n);return t.set(a,s),s}})},$=r=>e=>{for(let n of r)if(!n(e))return!1;return!0},M=r=>Array.isArray(r)&&r.every(e=>e===!0||e===!1),q=r=>Array.isArray(r)&&r.every(e=>i(e)),F=(r,e)=>{let n=u(r),o=u(e);return n!==o},K={isBoolean:b,isBooleanLike:i,toBoolean:u,safeToBoolean:g,all:f,any:l,none:c,not:k,xor:x,nand:B,nor:C,xnor:A,countTruthy:y,countFalsy:T,createToggle:N,compare:p,checkConditions:j,validateBooleanConstraint:S,randomBoolean:E,debounceBoolean:L,memoizeBoolean:O,createPipeline:$,isBooleanArray:M,isBooleanLikeArray:q};export{f as all,l as any,j as checkConditions,p as compare,F as compareBoolean,T as countFalsy,y as countTruthy,$ as createPipeline,N as createToggle,L as debounceBoolean,K as default,b as isBoolean,M as isBooleanArray,i as isBooleanLike,q as isBooleanLikeArray,O as memoizeBoolean,B as nand,c as none,C as nor,k as not,E as randomBoolean,g as safeToBoolean,u as toBoolean,S as validateBooleanConstraint,A as xnor,x as xor};

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

@@ -0,0 +1 @@
+"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};

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';

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

@@ -0,0 +1 @@
+var d=r=>r===!0||r===!1,i=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 f(r);case"truthy":return!!r;case"falsy":return l(r);case"string":return c(r);case"number":return y(r);default:return!!r}},f=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`)},l=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},c=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`)},y=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},g=(r,e)=>{try{return u(r,"strict")}catch{return e!==void 0?e:!1}},p=r=>{if(!Array.isArray(r)||r.length===0)return!1;for(let e of r)if(!e)return!1;return!0},b=r=>{if(!Array.isArray(r)||r.length===0)return!1;for(let e of r)if(e)return!0;return!1},w=r=>!b(r),x=r=>!r,k=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},B=r=>!p(r),C=r=>w(r),A=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},m=r=>{if(!Array.isArray(r))return 0;let e=0;for(let n of r)n&&e++;return e},T=r=>Array.isArray(r)?r.length-m(r):0,N=(r=!1)=>{let e=r;return()=>(e=!e,e)},h=(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}`)}},j=(r,e)=>{for(let n of e)if(!h(r,n.value,n.operator))return!1;return!0},S=(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}},E=(r=.5)=>{if(r<0||r>1)throw new Error("Probability must be between 0 and 1");return r===0?!1:Math.random()<=r},L=(r,e)=>{let n,o;return(...a)=>(n&&clearTimeout(n),n=setTimeout(()=>{o=r(...a)},e),o)},O=r=>{let e=new WeakMap;return((...n)=>{let o=null,a="";for(let t=0;t<n.length;t++)if(n[t]!==null&&typeof n[t]=="object"){o=n[t];break}if(a=JSON.stringify(n),o){let t=e.get(o);if(t||(t=new Map,e.set(o,t)),t.has(a))return t.get(a);let s=r(...n);return t.set(a,s),s}else{let t=e.get(Object.prototype)||new Map;if(e.has(Object.prototype)||e.set(Object.prototype,t),t.has(a))return t.get(a);let s=r(...n);return t.set(a,s),s}})},$=r=>e=>{for(let n of r)if(!n(e))return!1;return!0},M=r=>Array.isArray(r)&&r.every(e=>e===!0||e===!1),q=r=>Array.isArray(r)&&r.every(e=>i(e)),F=(r,e)=>{let n=u(r),o=u(e);return n!==o};export{p as all,b as any,j as checkConditions,h as compare,F as compareBoolean,T as countFalsy,m as countTruthy,$ as createPipeline,N as createToggle,L as debounceBoolean,d as isBoolean,M as isBooleanArray,i as isBooleanLike,q as isBooleanLikeArray,O as memoizeBoolean,B as nand,w as none,C as nor,x as not,E as randomBoolean,g as safeToBoolean,u as toBoolean,S as validateBooleanConstraint,A as xnor,k as xor};

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

@@ -0,0 +1 @@
+"use strict";var a=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var u=(e,o,n,t)=>{if(o&&typeof o=="object"||typeof o=="function")for(let r of l(o))!i.call(e,r)&&r!==n&&a(e,r,{get:()=>o[r],enumerable:!(t=p(o,r))||t.enumerable});return e};var b=e=>u(a({},"__esModule",{value:!0}),e);var C={};module.exports=b(C);

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

@@ -0,0 +1,14 @@
+/**
+ * Type for truthy values that can be converted to boolean
+ */
+export type BooleanConvertible = string | number | boolean | null | undefined | object | any[];
+/**
+ * Type for strict boolean values
+ */
+export type StrictBoolean = boolean | 0 | 1 | 'true' | 'false' | '0' | '1';
+export type ComparatorOperator = '>' | '<' | '>=' | '<=' | '==' | '===' | '!=' | '!==';
+export interface ComparatorCondition {
+    value: unknown;
+    operator: ComparatorOperator;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/lib/primitive/boolean/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,MAAM,GACN,GAAG,EAAE,CAAC;AAEV;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,OAAO,GAAG,GAAG,GAAG,GAAG,CAAC;AAE3E,MAAM,MAAM,kBAAkB,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAA;AACtF,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,kBAAkB,CAAC;CAC9B"}

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

@@ -0,0 +1 @@
+export {};