@utiliread/primitives 1.0.0-146 → 1.0.0-148

package/src/number-formatter.ts

@@ -1,118 +1,126 @@
-export const invariantDecimalSeparator = (0.1).toString()[1];
-export const localeDecimalSeparator = (0.1).toLocaleString()[1];
-
-export interface Parts {
-    invariantPrecisionString: string;
-    invariantCoefficientString: string;
-    exponent: number;
-    noOfCoefficientDecimals: number;
-}
-
-class Formatter {
-    public toPrecision(value: number, precision: number, maxDecimals?: number) {
-        const absValue = Math.abs(value);
-        const noOfIntegerDigits = Math.round(absValue).toString().length;
-
-        // Adjust precision to maxDecimals
-        if (maxDecimals !== undefined) {
-            precision = Math.min(precision, noOfIntegerDigits + maxDecimals);
-        }
-
-        if (value === 0) {
-            // (0).toPrecision(1) == "0"
-            // (0).toPrecision(2) == "0.0"
-            // (0).toPrecision(3) == "0.00"
-            // However, we want:
-            // Formatter.toPrecision(0, 0) == "0"
-            // Formatter.toPrecision(0, 1) == "0.0"
-            // Formatter.toPrecision(0, 2) == "0.00"
-            return value.toPrecision(precision + 1);
-        }
-
-        if (absValue < 1) {
-            return value.toPrecision(precision);
-        }
-
-        return precision >= noOfIntegerDigits
-            ? value.toFixed(precision - noOfIntegerDigits)
-            : value.toPrecision(precision);
-    }
-
-    public toLocalePrecision(
-        value: number,
-        precision: number,
-        maxDecimals?: number,
-    ) {
-        return this.toPrecision(value, precision, maxDecimals).replace(
-            invariantDecimalSeparator,
-            localeDecimalSeparator,
-        );
-    }
-
-    public toFixed(value: number, precision: number, maxDecimals?: number) {
-        const parts = this.getParts(value, precision, maxDecimals);
-        if (parts.noOfCoefficientDecimals < parts.exponent) {
-            const number = parts.invariantCoefficientString.replace(
-                invariantDecimalSeparator,
-                "",
-            );
-            const zeros = parts.exponent - parts.noOfCoefficientDecimals;
-            return `${number}${"0".repeat(zeros)}`;
-        } else {
-            return parts.invariantPrecisionString;
-        }
-    }
-
-    public toLocaleFixed(
-        value: number,
-        precision: number,
-        maxDecimals?: number,
-    ) {
-        return this.toFixed(value, precision, maxDecimals).replace(
-            invariantDecimalSeparator,
-            localeDecimalSeparator,
-        );
-    }
-
-    public getParts(
-        value: number,
-        precision: number,
-        maxDecimals?: number,
-    ): Parts {
-        const precisionString = this.toPrecision(value, precision, maxDecimals);
-        if (precisionString.indexOf("e") >= 0) {
-            const match = /(.*)e([\+-]\d+)$/.exec(precisionString)!;
-            const coefficientString = match[1];
-            const exponent = parseInt(match[2]);
-            const decimalSeparatorIndex = coefficientString.indexOf(
-                invariantDecimalSeparator,
-            );
-            const noOfCoefficientDecimals =
-                decimalSeparatorIndex >= 0
-                    ? coefficientString.length - decimalSeparatorIndex - 1
-                    : 0;
-            return {
-                invariantPrecisionString: precisionString,
-                invariantCoefficientString: coefficientString,
-                exponent,
-                noOfCoefficientDecimals,
-            };
-        } else {
-            const decimalSeparatorIndex = precisionString.indexOf(
-                invariantDecimalSeparator,
-            );
-            const noOfCoefficientDecimals =
-                decimalSeparatorIndex >= 0
-                    ? precisionString.length - decimalSeparatorIndex - 1
-                    : 0;
-            return {
-                invariantPrecisionString: precisionString,
-                invariantCoefficientString: precisionString,
-                exponent: 0,
-                noOfCoefficientDecimals,
-            };
-        }
-    }
-}
-
-export const NumberFormatter = new Formatter();
+export const invariantDecimalSeparator = (0.1).toString()[1];
+export const localeDecimalSeparator = (0.1).toLocaleString()[1];
+
+export interface Parts {
+    invariantPrecisionString: string;
+    invariantCoefficientString: string;
+    exponent: number;
+    noOfCoefficientDecimals: number;
+}
+
+class Formatter {
+    public toPrecision(value: number, precision: number, maxDecimals?: number) {
+        if (value === 0) {
+            // By convention the precision of zero is its number of decimals.
+            // (0).toPrecision(1) == "0"
+            // (0).toPrecision(2) == "0.0"
+            // (0).toPrecision(3) == "0.00"
+            // However, we want:
+            // Formatter.toPrecision(0, 0) == "0"
+            // Formatter.toPrecision(0, 1) == "0.0"
+            // Formatter.toPrecision(0, 2) == "0.00"
+            const decimals =
+                maxDecimals !== undefined
+                    ? Math.min(precision, maxDecimals)
+                    : precision;
+            return (0).toPrecision(Math.max(decimals, 0) + 1);
+        }
+
+        const absValue = Math.abs(value);
+        const noOfIntegerDigits = Math.round(absValue).toString().length;
+
+        // Adjust precision to maxDecimals
+        if (maxDecimals !== undefined) {
+            precision = Math.min(precision, noOfIntegerDigits + maxDecimals);
+        }
+
+        // A precision of 0 is only valid for zero, use at least one significant digit for any other value
+        precision = Math.max(precision, 1);
+
+        if (absValue < 1) {
+            return value.toPrecision(precision);
+        }
+
+        return precision >= noOfIntegerDigits
+            ? value.toFixed(precision - noOfIntegerDigits)
+            : value.toPrecision(precision);
+    }
+
+    public toLocalePrecision(
+        value: number,
+        precision: number,
+        maxDecimals?: number,
+    ) {
+        return this.toPrecision(value, precision, maxDecimals).replace(
+            invariantDecimalSeparator,
+            localeDecimalSeparator,
+        );
+    }
+
+    public toFixed(value: number, precision: number, maxDecimals?: number) {
+        const parts = this.getParts(value, precision, maxDecimals);
+        if (parts.noOfCoefficientDecimals < parts.exponent) {
+            const number = parts.invariantCoefficientString.replace(
+                invariantDecimalSeparator,
+                "",
+            );
+            const zeros = parts.exponent - parts.noOfCoefficientDecimals;
+            return `${number}${"0".repeat(zeros)}`;
+        } else {
+            return parts.invariantPrecisionString;
+        }
+    }
+
+    public toLocaleFixed(
+        value: number,
+        precision: number,
+        maxDecimals?: number,
+    ) {
+        return this.toFixed(value, precision, maxDecimals).replace(
+            invariantDecimalSeparator,
+            localeDecimalSeparator,
+        );
+    }
+
+    public getParts(
+        value: number,
+        precision: number,
+        maxDecimals?: number,
+    ): Parts {
+        const precisionString = this.toPrecision(value, precision, maxDecimals);
+        if (precisionString.indexOf("e") >= 0) {
+            const match = /(.*)e([\+-]\d+)$/.exec(precisionString)!;
+            const coefficientString = match[1];
+            const exponent = parseInt(match[2]);
+            const decimalSeparatorIndex = coefficientString.indexOf(
+                invariantDecimalSeparator,
+            );
+            const noOfCoefficientDecimals =
+                decimalSeparatorIndex >= 0
+                    ? coefficientString.length - decimalSeparatorIndex - 1
+                    : 0;
+            return {
+                invariantPrecisionString: precisionString,
+                invariantCoefficientString: coefficientString,
+                exponent,
+                noOfCoefficientDecimals,
+            };
+        } else {
+            const decimalSeparatorIndex = precisionString.indexOf(
+                invariantDecimalSeparator,
+            );
+            const noOfCoefficientDecimals =
+                decimalSeparatorIndex >= 0
+                    ? precisionString.length - decimalSeparatorIndex - 1
+                    : 0;
+            return {
+                invariantPrecisionString: precisionString,
+                invariantCoefficientString: precisionString,
+                exponent: 0,
+                noOfCoefficientDecimals,
+            };
+        }
+    }
+}
+
+export const NumberFormatter = new Formatter();

package/src/optional.ts

@@ -1 +1 @@
-export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;