@fluixi/utils 1.0.0-alpha.100

package/dist/lib/maths/parser.cjs

@@ -0,0 +1,75 @@
+"use strict";
+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 __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/maths/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  parseIntSafe: () => parseIntSafe,
+  toNumber: () => toNumber
+});
+module.exports = __toCommonJS(parser_exports);
+var toNumber = (value, fallback) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : fallback !== void 0 ? fallback : NaN;
+  }
+  if (value == null) {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return fallback !== void 0 ? fallback : NaN;
+    }
+    const num2 = Number(trimmed);
+    return Number.isFinite(num2) ? num2 : fallback !== void 0 ? fallback : NaN;
+  }
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback !== void 0 ? fallback : NaN;
+};
+var parseIntSafe = (value, radix = 10, fallback) => {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (radix === 16) {
+    const hexRegex = /^(-?)0?x?([0-9a-fA-F]+)$/;
+    const match = trimmed.match(hexRegex);
+    if (match) {
+      const sign = match[1] ? -1 : 1;
+      const hexStr = match[2];
+      const parsed2 = parseInt(hexStr, 16);
+      return !isNaN(parsed2) ? sign * parsed2 : fallback !== void 0 ? fallback : NaN;
+    }
+  }
+  const parsed = parseInt(trimmed, radix);
+  if (isNaN(parsed)) {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (radix !== 16 && radix !== 10) {
+    const validDigits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, radix);
+    const pattern = new RegExp(`^[-+]?[${validDigits}]+$`, "i");
+    if (!pattern.test(trimmed)) {
+      return fallback !== void 0 ? fallback : NaN;
+    }
+  }
+  return parsed;
+};

package/dist/lib/maths/parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Safely converts any value to a number with fallback
+ * @param value - The value to convert
+ * @param fallback - Fallback value if conversion fails (default: NaN)
+ * @returns The converted number or fallback
+ * @example
+* toNumber("42") // 42
+* toNumber("abc", 0) // 0
+* toNumber(null, 100) // 100
+*/
+export declare const toNumber: <T = number>(value: unknown, fallback?: T) => number | T;
+/**
+ * Parses a string to integer with validation
+ * Optimized: Regex check before parsing
+ * @param value - String to parse
+ * @param radix - Numeric base (default: 10)
+ * @returns Parsed integer or fallback
+ */
+export declare const parseIntSafe: <T = number>(value: string, radix?: number, fallback?: T) => number | T;
+//# sourceMappingURL=parser.d.ts.map

package/dist/lib/maths/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/lib/maths/parser.ts"],"names":[],"mappings":"AACA;;;;;;;;;EASE;AACF,eAAO,MAAM,QAAQ,GAAI,CAAC,GAAG,MAAM,EACjC,OAAO,OAAO,EACd,WAAW,CAAC,KACX,MAAM,GAAG,CA+BX,CAAC;AAGF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,GAAG,MAAM,EACrC,OAAO,MAAM,EACb,QAAO,MAAW,EAClB,WAAW,CAAC,KACX,MAAM,GAAG,CAqCX,CAAC"}

package/dist/lib/maths/parser.js

@@ -0,0 +1,78 @@
+/**
+ * Safely converts any value to a number with fallback
+ * @param value - The value to convert
+ * @param fallback - Fallback value if conversion fails (default: NaN)
+ * @returns The converted number or fallback
+ * @example
+* toNumber("42") // 42
+* toNumber("abc", 0) // 0
+* toNumber(null, 100) // 100
+*/
+export const toNumber = (value, fallback) => {
+    // Fast path: already a number
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : (fallback !== undefined ? fallback : NaN);
+    }
+    // Fast path: null/undefined
+    if (value == null) {
+        return fallback !== undefined ? fallback : NaN;
+    }
+    // Fast path: boolean
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    // Fast path: string
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return fallback !== undefined ? fallback : NaN;
+        }
+        // Use Number() for conversion (faster than parseFloat for our use case)
+        const num = Number(trimmed);
+        return Number.isFinite(num) ? num : (fallback !== undefined ? fallback : NaN);
+    }
+    // For other types, attempt conversion
+    const num = Number(value);
+    return Number.isFinite(num) ? num : (fallback !== undefined ? fallback : NaN);
+};
+/**
+ * Parses a string to integer with validation
+ * Optimized: Regex check before parsing
+ * @param value - String to parse
+ * @param radix - Numeric base (default: 10)
+ * @returns Parsed integer or fallback
+ */
+export const parseIntSafe = (value, radix = 10, fallback) => {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return fallback !== undefined ? fallback : NaN;
+    }
+    // Allow hex digits for radix 16
+    if (radix === 16) {
+        // Allow hex format: optional 0x prefix, then hex digits
+        const hexRegex = /^(-?)0?x?([0-9a-fA-F]+)$/;
+        const match = trimmed.match(hexRegex);
+        if (match) {
+            const sign = match[1] ? -1 : 1;
+            const hexStr = match[2];
+            const parsed = parseInt(hexStr, 16);
+            return !isNaN(parsed) ? sign * parsed : (fallback !== undefined ? fallback : NaN);
+        }
+    }
+    // For other radices, use standard parseInt with validation
+    const parsed = parseInt(trimmed, radix);
+    if (isNaN(parsed)) {
+        return fallback !== undefined ? fallback : NaN;
+    }
+    // Validate that the entire string was consumed for the given radix
+    // (except for hex which we already handled)
+    if (radix !== 16 && radix !== 10) {
+        // For other radices, ensure the string only contains valid digits
+        const validDigits = '0123456789abcdefghijklmnopqrstuvwxyz'.slice(0, radix);
+        const pattern = new RegExp(`^[-+]?[${validDigits}]+$`, 'i');
+        if (!pattern.test(trimmed)) {
+            return fallback !== undefined ? fallback : NaN;
+        }
+    }
+    return parsed;
+};

package/dist/lib/maths/parser.mjs

@@ -0,0 +1,54 @@
+// src/lib/maths/parser.ts
+var toNumber = (value, fallback) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : fallback !== void 0 ? fallback : NaN;
+  }
+  if (value == null) {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return fallback !== void 0 ? fallback : NaN;
+    }
+    const num2 = Number(trimmed);
+    return Number.isFinite(num2) ? num2 : fallback !== void 0 ? fallback : NaN;
+  }
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback !== void 0 ? fallback : NaN;
+};
+var parseIntSafe = (value, radix = 10, fallback) => {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (radix === 16) {
+    const hexRegex = /^(-?)0?x?([0-9a-fA-F]+)$/;
+    const match = trimmed.match(hexRegex);
+    if (match) {
+      const sign = match[1] ? -1 : 1;
+      const hexStr = match[2];
+      const parsed2 = parseInt(hexStr, 16);
+      return !isNaN(parsed2) ? sign * parsed2 : fallback !== void 0 ? fallback : NaN;
+    }
+  }
+  const parsed = parseInt(trimmed, radix);
+  if (isNaN(parsed)) {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (radix !== 16 && radix !== 10) {
+    const validDigits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, radix);
+    const pattern = new RegExp(`^[-+]?[${validDigits}]+$`, "i");
+    if (!pattern.test(trimmed)) {
+      return fallback !== void 0 ? fallback : NaN;
+    }
+  }
+  return parsed;
+};
+export {
+  parseIntSafe,
+  toNumber
+};

package/dist/lib/maths/random.cjs

@@ -0,0 +1,49 @@
+"use strict";
+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 __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/maths/random.ts
+var random_exports = {};
+__export(random_exports, {
+  randomBool: () => randomBool,
+  randomFloat: () => randomFloat,
+  randomInt: () => randomInt
+});
+module.exports = __toCommonJS(random_exports);
+var randomInt = (min, max) => {
+  const [realMin, realMax] = min <= max ? [min, max] : [max, min];
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const range = realMax - realMin + 1;
+    const maxSafe = 4294967295;
+    const byteArray = new Uint32Array(1);
+    let randomValue;
+    do {
+      crypto.getRandomValues(byteArray);
+      randomValue = byteArray[0] / (maxSafe + 1);
+    } while (randomValue >= 1 - 1 % range / 1);
+    return Math.floor(randomValue * range) + realMin;
+  }
+  return Math.floor(Math.random() * (realMax - realMin + 1)) + realMin;
+};
+var randomFloat = (min, max) => {
+  const [realMin, realMax] = min <= max ? [min, max] : [max, min];
+  return Math.random() * (realMax - realMin) + realMin;
+};
+var randomBool = (probability = 0.5) => {
+  return Math.random() < probability;
+};

package/dist/lib/maths/random.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Generates a random integer between min and max (inclusive)
+ * @function randomInt
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (inclusive)
+ * @returns Random integer
+ * Optimized: Single Math.random call with proper scaling
+ */
+export declare const randomInt: (min: number, max: number) => number;
+/**
+ * Generates a random float between min and max (exclusive of max)
+ * @function randomFloat
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (exclusive)
+ * @returns Random float
+ * Optimized: Single Math.random call
+ */
+export declare const randomFloat: (min: number, max: number) => number;
+/**
+ * Generates a random boolean with optional probability
+ * @function randomBool
+ * @param probability - Probability of returning true (default: 0.5)
+ * @returns Random boolean
+ * Optimized: Single comparison
+ */
+export declare const randomBool: (probability?: number) => boolean;
+//# sourceMappingURL=random.d.ts.map

package/dist/lib/maths/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../src/lib/maths/random.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAsBpD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAGtD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,cAAa,MAAY,KAAG,OAEtD,CAAC"}

package/dist/lib/maths/random.js

@@ -0,0 +1,49 @@
+/**
+ * Generates a random integer between min and max (inclusive)
+ * @function randomInt
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (inclusive)
+ * @returns Random integer
+ * Optimized: Single Math.random call with proper scaling
+ */
+export const randomInt = (min, max) => {
+    // Ensure min <= max
+    const [realMin, realMax] = min <= max ? [min, max] : [max, min];
+    // Use crypto.getRandomValues if available for better randomness
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+        const range = realMax - realMin + 1;
+        const maxSafe = 0xFFFFFFFF; // Max value for Uint32
+        const byteArray = new Uint32Array(1);
+        // Generate until we get a value in the safe range
+        let randomValue;
+        do {
+            crypto.getRandomValues(byteArray);
+            randomValue = byteArray[0] / (maxSafe + 1);
+        } while (randomValue >= 1 - (1 % range) / 1);
+        return Math.floor(randomValue * range) + realMin;
+    }
+    // Fallback to Math.random
+    return Math.floor(Math.random() * (realMax - realMin + 1)) + realMin;
+};
+/**
+ * Generates a random float between min and max (exclusive of max)
+ * @function randomFloat
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (exclusive)
+ * @returns Random float
+ * Optimized: Single Math.random call
+ */
+export const randomFloat = (min, max) => {
+    const [realMin, realMax] = min <= max ? [min, max] : [max, min];
+    return Math.random() * (realMax - realMin) + realMin;
+};
+/**
+ * Generates a random boolean with optional probability
+ * @function randomBool
+ * @param probability - Probability of returning true (default: 0.5)
+ * @returns Random boolean
+ * Optimized: Single comparison
+ */
+export const randomBool = (probability = 0.5) => {
+    return Math.random() < probability;
+};

package/dist/lib/maths/random.mjs

@@ -0,0 +1,28 @@
+// src/lib/maths/random.ts
+var randomInt = (min, max) => {
+  const [realMin, realMax] = min <= max ? [min, max] : [max, min];
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const range = realMax - realMin + 1;
+    const maxSafe = 4294967295;
+    const byteArray = new Uint32Array(1);
+    let randomValue;
+    do {
+      crypto.getRandomValues(byteArray);
+      randomValue = byteArray[0] / (maxSafe + 1);
+    } while (randomValue >= 1 - 1 % range / 1);
+    return Math.floor(randomValue * range) + realMin;
+  }
+  return Math.floor(Math.random() * (realMax - realMin + 1)) + realMin;
+};
+var randomFloat = (min, max) => {
+  const [realMin, realMax] = min <= max ? [min, max] : [max, min];
+  return Math.random() * (realMax - realMin) + realMin;
+};
+var randomBool = (probability = 0.5) => {
+  return Math.random() < probability;
+};
+export {
+  randomBool,
+  randomFloat,
+  randomInt
+};

package/dist/lib/maths/types/advanced.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/maths/types/advanced.ts
+var advanced_exports = {};
+module.exports = __toCommonJS(advanced_exports);