@tsi-developpement/tsi-shared-ui 1.10.2 → 1.10.3

package/esm2022/lib/functions/index.mjs

@@ -1,5 +1,6 @@
 export * from './array.functions';
 export * from './library-initializer';
 export * from './common.functions';
+export * from './number.functions';
 // export * from './modal-open.function'
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90c2ktc2hhcmVkLXVpL3NyYy9saWIvZnVuY3Rpb25zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLHdDQUF3QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXJyYXkuZnVuY3Rpb25zJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWJyYXJ5LWluaXRpYWxpemVyJztcclxuZXhwb3J0ICogZnJvbSAnLi9jb21tb24uZnVuY3Rpb25zJztcclxuLy8gZXhwb3J0ICogZnJvbSAnLi9tb2RhbC1vcGVuLmZ1bmN0aW9uJyJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90c2ktc2hhcmVkLXVpL3NyYy9saWIvZnVuY3Rpb25zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsd0NBQXdDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hcnJheS5mdW5jdGlvbnMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYnJhcnktaW5pdGlhbGl6ZXInO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi5mdW5jdGlvbnMnO1xyXG5leHBvcnQgKiBmcm9tICcuL251bWJlci5mdW5jdGlvbnMnO1xyXG4vLyBleHBvcnQgKiBmcm9tICcuL21vZGFsLW9wZW4uZnVuY3Rpb24nIl19

package/esm2022/lib/functions/number.functions.mjs

@@ -0,0 +1,93 @@
+/**
+ * Numeric helpers that avoid IEEE 754 floating-point accumulation errors.
+ *
+ * JavaScript's `number` is an IEEE 754 double, so decimal fractions such as
+ * `0.1` or `0.2` have no exact binary representation. Summing them naively
+ * (`a + b + c ...`) lets each rounding error compound, producing artifacts like
+ * `0.1 + 0.2 === 0.30000000000000004`.
+ *
+ * These helpers use integer scaling: every value is scaled up to an integer by
+ * the largest number of decimal places present, the addition is performed in the
+ * (exact) integer domain, then the result is scaled back down. No third-party
+ * dependency is required.
+ *
+ * Boundary: integer scaling can exceed `Number.MAX_SAFE_INTEGER` when summing
+ * very large numbers at high decimal precision (e.g. 6-decimal values totalling
+ * into the billions). For currency (2 decimals) the safe headroom is ~9e13, so
+ * this is a non-issue in practice.
+ */
+/**
+ * Counts the number of significant decimal places in a finite number,
+ * correctly handling values serialized in exponential notation (e.g. `1e-7`).
+ *
+ * @param value - The number to inspect.
+ * @returns The count of decimal places (0 for integers and non-finite input).
+ */
+function decimalPlaces(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    const text = Math.abs(value).toString();
+    // Exponential notation, e.g. "1e-7" or "1.23e-4".
+    const exponentIndex = text.indexOf('e-');
+    if (exponentIndex >= 0) {
+        const mantissa = text.slice(0, exponentIndex);
+        const exponent = Number(text.slice(exponentIndex + 2));
+        const mantissaDecimals = mantissa.includes('.') ? mantissa.split('.')[1].length : 0;
+        return mantissaDecimals + exponent;
+    }
+    const dotIndex = text.indexOf('.');
+    return dotIndex >= 0 ? text.length - dotIndex - 1 : 0;
+}
+/**
+ * Sums an array of numbers without IEEE 754 accumulation error.
+ *
+ * Uses integer scaling for an exact decimal result. `null`, `undefined` and
+ * non-finite entries (`NaN`, `Infinity`) are ignored (contribute `0`) so a
+ * single missing/invalid cell cannot poison the whole total. An empty,
+ * `null` or `undefined` input returns `0`.
+ *
+ * @param values - The values to sum (may contain gaps).
+ * @returns The precise sum, or `0` when there is nothing to add.
+ *
+ * @example
+ * preciseSum([0.1, 0.2]);            // 0.3   (not 0.30000000000000004)
+ * preciseSum([1.005, 2.5, 3]);       // 6.505
+ * preciseSum([10, null, undefined]); // 10
+ * preciseSum([]);                    // 0
+ */
+export function preciseSum(values) {
+    if (values == null || values.length === 0)
+        return 0;
+    let maxDecimals = 0;
+    for (const value of values) {
+        if (value != null && Number.isFinite(value)) {
+            const decimals = decimalPlaces(value);
+            if (decimals > maxDecimals)
+                maxDecimals = decimals;
+        }
+    }
+    const scale = Math.pow(10, maxDecimals);
+    let scaledSum = 0;
+    for (const value of values) {
+        if (value != null && Number.isFinite(value)) {
+            scaledSum += Math.round(value * scale);
+        }
+    }
+    return scaledSum / scale;
+}
+/**
+ * Adds two numbers without IEEE 754 accumulation error.
+ *
+ * `null`, `undefined` and non-finite operands are treated as `0`.
+ *
+ * @param a - First operand.
+ * @param b - Second operand.
+ * @returns The precise sum of `a` and `b`.
+ *
+ * @example
+ * preciseAdd(0.1, 0.2); // 0.3 (not 0.30000000000000004)
+ */
+export function preciseAdd(a, b) {
+    return preciseSum([a, b]);
+}
+//# sourceMappingURL=data:application/json;base64,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