@esri/calcite-components 1.0.0-next.596 → 1.0.0-next.597

package/dist/collection/utils/label.spec.js

@@ -0,0 +1,188 @@
+import { connectLabel, disconnectLabel, getLabelText, labelClickEvent } from "./label";
+describe("label", () => {
+    function createFakeLabelable(overrides) {
+        const base = {
+            disabled: null,
+            el: null,
+            label: null,
+            labelEl: null,
+            onLabelClick: jest.fn()
+        };
+        return { ...base, ...overrides };
+    }
+    describe("connectLabel/disconnectLabel", () => {
+        describe("wires up the associated label", () => {
+            /**
+             * This util helps simulate calcite-label's behavior since we cannot use the component here
+             *
+             * @param label
+             */
+            function wireUpFakeLabel(label) {
+                label.addEventListener("click", (event) => {
+                    label.dispatchEvent(new CustomEvent(labelClickEvent, { detail: { sourceEvent: event } }));
+                });
+            }
+            it("ignores labelable with no associated label", () => {
+                document.body.innerHTML = `
+          <fake-labelable id="unlabeled"></fake-labelable>
+      `;
+                const fakeLabelableEl = document.querySelector("#unlabeled");
+                const nonLabelable = createFakeLabelable({
+                    el: fakeLabelableEl
+                });
+                connectLabel(nonLabelable);
+                expect(nonLabelable.labelEl).toBeNull();
+                disconnectLabel(nonLabelable);
+                expect(nonLabelable.labelEl).toBeNull();
+            });
+            it("prevents selecting disabled labeled element", () => {
+                document.body.innerHTML = `
+        <calcite-label for="for">label</calcite-label>
+        <fake-labelable id="for"></fake-labelable>
+      `;
+                const labelEl = document.querySelector("calcite-label");
+                const fakeLabelableEl = document.querySelector("#for");
+                wireUpFakeLabel(labelEl);
+                const labelable = createFakeLabelable({
+                    el: fakeLabelableEl,
+                    disabled: true
+                });
+                connectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(0);
+                disconnectLabel(labelable);
+            });
+            it("supports for attribute", () => {
+                document.body.innerHTML = `
+        <calcite-label for="for">label</calcite-label>
+        <fake-labelable id="for"></fake-labelable>
+      `;
+                const labelEl = document.querySelector("calcite-label");
+                const fakeLabelableEl = document.querySelector("#for");
+                wireUpFakeLabel(labelEl);
+                const labelable = createFakeLabelable({
+                    el: fakeLabelableEl
+                });
+                connectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
+                disconnectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
+            });
+            it("supports wrapped labelable", () => {
+                document.body.innerHTML = `
+        <calcite-label>
+          label
+          <fake-labelable></fake-labelable>
+        </calcite-label>
+      `;
+                const labelEl = document.querySelector("calcite-label");
+                const fakeLabelableEl = document.querySelector("fake-labelable");
+                wireUpFakeLabel(labelEl);
+                const labelable = createFakeLabelable({
+                    el: fakeLabelableEl
+                });
+                connectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
+                disconnectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
+            });
+            it("supports being rendered after labelable", () => {
+                document.body.innerHTML = `
+          <fake-labelable id="renderedFirst"></fake-labelable>
+        `;
+                const label = document.createElement("calcite-label");
+                label.setAttribute("for", "renderedFirst");
+                document.body.appendChild(label);
+                const labelEl = document.querySelector("calcite-label");
+                const fakeLabelableEl = document.querySelector("fake-labelable");
+                wireUpFakeLabel(labelEl);
+                const labelable = createFakeLabelable({
+                    el: fakeLabelableEl
+                });
+                connectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
+                disconnectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
+            });
+            it("works if reattached to labelable", () => {
+                document.body.innerHTML = `
+          <calcite-label for="for"></calcite-label>
+          <fake-labelable id="for"></fake-labelable>
+        `;
+                document.querySelector("calcite-label").remove();
+                const label = document.createElement("calcite-label");
+                label.setAttribute("for", "for");
+                document.body.appendChild(label);
+                const labelEl = document.querySelector("calcite-label");
+                const fakeLabelableEl = document.querySelector("fake-labelable");
+                wireUpFakeLabel(labelEl);
+                const labelable = createFakeLabelable({
+                    el: fakeLabelableEl
+                });
+                connectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
+                disconnectLabel(labelable);
+                expect(labelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(labelable.onLabelClick).toHaveBeenCalledTimes(1);
+            });
+            it("does not support nested labelables", () => {
+                document.body.innerHTML = `
+        <calcite-label>
+          label
+          <fake-labelable id="outer">
+            <fake-labelable id="inner"></fake-labelable>
+          </fake-labelable>
+        </calcite-label>
+      `;
+                const labelEl = document.querySelector("calcite-label");
+                const fakeInnerLabelableEl = document.querySelector("#inner");
+                const fakeOuterLabelableEl = document.querySelector("#outer");
+                wireUpFakeLabel(labelEl);
+                const innerLabelable = createFakeLabelable({
+                    el: fakeInnerLabelableEl
+                });
+                connectLabel(innerLabelable);
+                expect(innerLabelable.labelEl).toBeNull();
+                const outerLabelable = createFakeLabelable({
+                    el: fakeOuterLabelableEl
+                });
+                connectLabel(outerLabelable);
+                expect(outerLabelable.labelEl).toBe(labelEl);
+                labelEl.click();
+                expect(outerLabelable.onLabelClick).toHaveBeenCalledTimes(1);
+                disconnectLabel(outerLabelable);
+                labelEl.click();
+                expect(outerLabelable.onLabelClick).toHaveBeenCalledTimes(1);
+            });
+        });
+    });
+    it("getLabelText", () => {
+        const label = "from-label";
+        expect(getLabelText(createFakeLabelable({ label }))).toBe("from-label");
+        const labelEl = document.createElement("calcite-label");
+        labelEl.textContent = "from-text-content";
+        expect(getLabelText(createFakeLabelable({
+            labelEl
+        }))).toBe("from-text-content");
+        expect(getLabelText(createFakeLabelable({
+            label,
+            labelEl
+        }))).toBe("from-label");
+    });
+});

package/dist/collection/utils/locale.js

@@ -1,9 +1,12 @@
 /*!
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
  * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
- * v1.0.0-next.596
+ * v1.0.0-next.597
  */
-import { sanitizeDecimalString, sanitizeExponentialNumberString, isValidNumber, BigDecimal } from "./number";
+import { BigDecimal, isValidNumber, sanitizeExponentialNumberString } from "./number";
+import { createObserver } from "./observers";
+import { closestElementCrossShadowBoundary, containsCrossShadowBoundary } from "./dom";
+const defaultLocale = "en";
 export const locales = [
   "ar",
   "bg",
@@ -14,7 +17,7 @@ export const locales = [
   "de",
   "de-CH",
   "el",
-  "en",
+  defaultLocale,
   "en-AU",
   "en-CA",
   "en-GB",
@@ -55,78 +58,184 @@ export const locales = [
   "zh-HK",
   "zh-TW"
 ];
-const allDecimalsExceptLast = new RegExp(`[.](?=.*[.])`, "g");
-const everythingExceptNumbersDecimalsAndMinusSigns = new RegExp("[^0-9-.]", "g");
-const defaultGroupSeparator = new RegExp(",", "g");
+export const numberingSystems = [
+  "arab",
+  "arabext",
+  "bali",
+  "beng",
+  "deva",
+  "fullwide",
+  "gujr",
+  "guru",
+  "hanidec",
+  "khmr",
+  "knda",
+  "laoo",
+  "latn",
+  "limb",
+  "mlym",
+  "mong",
+  "mymr",
+  "orya",
+  "tamldec",
+  "telu",
+  "thai",
+  "tibt"
+];
+const isNumberingSystemSupported = (numberingSystem) => numberingSystems.includes(numberingSystem);
 const browserNumberingSystem = new Intl.NumberFormat().resolvedOptions().numberingSystem;
-const defaultNumberingSystem = browserNumberingSystem === "arab" ? "latn" : browserNumberingSystem;
-export function createLocaleNumberFormatter(locale, numberingSystem = defaultNumberingSystem) {
-  return new Intl.NumberFormat(locale, {
-    minimumFractionDigits: 0,
-    maximumFractionDigits: 20,
-    numberingSystem
-  });
-}
-export function delocalizeNumberString(numberString, locale) {
-  return sanitizeExponentialNumberString(numberString, (nonExpoNumString) => {
-    const delocalizedNumberString = nonExpoNumString
-      .replace(getMinusSign(locale), "-")
-      .replace(getGroupSeparator(locale), "")
-      .replace(getDecimalSeparator(locale), ".")
-      .replace(allDecimalsExceptLast, "")
-      .replace(everythingExceptNumbersDecimalsAndMinusSigns, "");
-    return isValidNumber(delocalizedNumberString) ? delocalizedNumberString : nonExpoNumString;
-  });
+export const defaultNumberingSystem = browserNumberingSystem === "arab" || !isNumberingSystemSupported(browserNumberingSystem)
+  ? "latn"
+  : browserNumberingSystem;
+export const getSupportedNumberingSystem = (numberingSystem) => isNumberingSystemSupported(numberingSystem) ? numberingSystem : defaultNumberingSystem;
+export function getSupportedLocale(locale) {
+  if (locales.indexOf(locale) > -1) {
+    return locale;
+  }
+  locale = locale.toLowerCase();
+  // we support both 'nb' and 'no' (BCP 47) for Norwegian
+  if (locale === "nb") {
+    return "no";
+  }
+  if (locale.includes("-")) {
+    locale = locale.replace(/(\w+)-(\w+)/, (_match, language, region) => `${language}-${region.toUpperCase()}`);
+    if (!locales.includes(locale)) {
+      locale = locale.split("-")[0];
+    }
+  }
+  return locales.includes(locale) ? locale : "en";
 }
-export function getGroupSeparator(locale) {
-  const formatter = createLocaleNumberFormatter(locale);
-  const parts = formatter.formatToParts(1234567);
-  const value = parts.find((part) => part.type === "group").value;
-  // change whitespace group characters that don't render correctly
-  return value.trim().length === 0 ? " " : value;
+const connectedComponents = new Set();
+/**
+ * This utility sets up internals for messages support.
+ *
+ * It needs to be called in `connectedCallback` before any logic that depends on locale
+ *
+ * @param component
+ */
+export function connectLocalized(component) {
+  updateEffectiveLocale(component);
+  if (connectedComponents.size === 0) {
+    mutationObserver.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["lang"],
+      subtree: true
+    });
+  }
+  connectedComponents.add(component);
 }
-export function getDecimalSeparator(locale) {
-  const formatter = createLocaleNumberFormatter(locale);
-  const parts = formatter.formatToParts(1.1);
-  return parts.find((part) => part.type === "decimal").value;
+/**
+ * This is only exported for components that implemented the now deprecated `locale` prop.
+ *
+ * Do not use this utils for new components.
+ *
+ * @param component
+ */
+export function updateEffectiveLocale(component) {
+  component.effectiveLocale = getLocale(component);
 }
-export function getMinusSign(locale) {
-  const formatter = createLocaleNumberFormatter(locale);
-  const parts = formatter.formatToParts(-9);
-  return parts.find((part) => part.type === "minusSign").value;
+/**
+ * This utility tears down internals for messages support.
+ *
+ * It needs to be called in `disconnectedCallback`
+ *
+ * @param component
+ */
+export function disconnectLocalized(component) {
+  connectedComponents.delete(component);
+  if (connectedComponents.size === 0) {
+    mutationObserver.disconnect();
+  }
 }
-export function localizeNumberString(numberString, locale, displayGroupSeparator = false, numberingSystem) {
-  return sanitizeExponentialNumberString(numberString, (nonExpoNumString) => {
-    if (nonExpoNumString) {
-      const sanitizedNumberString = sanitizeDecimalString(nonExpoNumString.replace(defaultGroupSeparator, ""));
-      if (isValidNumber(sanitizedNumberString)) {
-        const parts = new BigDecimal(sanitizedNumberString).formatToParts(locale, numberingSystem);
-        const localizedNumberString = parts
-          .map(({ type, value }) => {
-          switch (type) {
-            case "group":
-              return displayGroupSeparator ? getGroupSeparator(locale) : "";
-            case "decimal":
-              return getDecimalSeparator(locale);
-            case "minusSign":
-              return getMinusSign(locale);
-            default:
-              return value;
-          }
-        })
-          .reduce((string, part) => string + part);
-        return localizedNumberString;
+const mutationObserver = createObserver("mutation", (records) => {
+  records.forEach((record) => {
+    const el = record.target;
+    connectedComponents.forEach((component) => {
+      const hasOverridingLocale = !!(component.locale && !component.el.lang);
+      const inUnrelatedSubtree = !containsCrossShadowBoundary(el, component.el);
+      if (hasOverridingLocale || inUnrelatedSubtree) {
+        return;
       }
-    }
-    return nonExpoNumString;
+      const closestLangEl = closestElementCrossShadowBoundary(component.el, "[lang]");
+      if (!closestLangEl) {
+        component.effectiveLocale = defaultLocale;
+        return;
+      }
+      const closestLang = closestLangEl.lang;
+      component.effectiveLocale =
+        // user set lang="" means unknown language, so we use default
+        closestLangEl.hasAttribute("lang") && closestLang === "" ? defaultLocale : closestLang;
+    });
   });
-}
+});
 /**
  * This util helps resolve a component's locale.
  * It will also fall back on the deprecated `locale` if a component implemented this previously.
  *
  * @param component
  */
-export function getLocale(component) {
-  return component.el.lang || component.locale || document.documentElement.lang || "en";
+function getLocale(component) {
+  var _a;
+  return (component.el.lang ||
+    component.locale ||
+    ((_a = closestElementCrossShadowBoundary(component.el, "[lang]")) === null || _a === void 0 ? void 0 : _a.lang) ||
+    document.documentElement.lang ||
+    defaultLocale);
+}
+/**
+ * This util formats and parses numbers for localization
+ */
+class NumberStringFormat {
+  constructor() {
+    /**
+     * This method needs to be called before localize/delocalize to ensure the options are up to date
+     *
+     * @param options
+     */
+    this.setOptions = (options) => {
+      const locale = getSupportedLocale(options.locale);
+      const numberingSystem = getSupportedNumberingSystem(options.numberingSystem);
+      // cache formatter by only recreating when options change
+      if (numberingSystem === this.numberingSystem &&
+        locale === this.locale &&
+        (options === null || options === void 0 ? void 0 : options.useGrouping) === this.useGrouping) {
+        return;
+      }
+      this.locale = locale;
+      this.numberingSystem = numberingSystem;
+      this.useGrouping = options.useGrouping;
+      this.numberFormatter = new Intl.NumberFormat(this.locale, {
+        useGrouping: this.useGrouping,
+        numberingSystem: this.numberingSystem,
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 20
+      });
+      this.digits = [
+        ...new Intl.NumberFormat(this.locale, {
+          useGrouping: false,
+          numberingSystem: this.numberingSystem
+        }).format(9876543210)
+      ].reverse();
+      const index = new Map(this.digits.map((d, i) => [d, i]));
+      const parts = new Intl.NumberFormat(this.locale).formatToParts(-12345678.9);
+      this.actualGroup = parts.find((d) => d.type === "group").value;
+      // change whitespace group characters that don't render correctly
+      this.group = this.actualGroup.trim().length === 0 ? " " : this.actualGroup;
+      this.decimal = parts.find((d) => d.type === "decimal").value;
+      this.minusSign = parts.find((d) => d.type === "minusSign").value;
+      this.getDigitIndex = (d) => index.get(d);
+    };
+    this.delocalize = (numberString) => sanitizeExponentialNumberString(numberString, (nonExpoNumString) => nonExpoNumString
+      .trim()
+      .replace(new RegExp(`[${this.minusSign}]`, "g"), "-")
+      .replace(new RegExp(`[${this.group}]`, "g"), "")
+      .replace(new RegExp(`[${this.decimal}]`, "g"), ".")
+      .replace(new RegExp(`[${this.digits.join("")}]`, "g"), this.getDigitIndex));
+    this.localize = (numberString) => sanitizeExponentialNumberString(numberString, (nonExpoNumString) => isValidNumber(nonExpoNumString)
+      ? new BigDecimal(nonExpoNumString.trim())
+        .format(this.numberFormatter)
+        .replace(new RegExp(`[${this.actualGroup}]`, "g"), this.group)
+      : nonExpoNumString);
+  }
 }
+export const numberStringFormatter = new NumberStringFormat();

package/dist/collection/utils/locale.spec.js

@@ -0,0 +1,44 @@
+import { delocalizeNumberString, localizeNumberString, locales } from "./locale";
+const localesWithIssues = ["ar"]; // arabic has different numeral characters
+describe("localizeNumberString and delocalizeNumberString", () => {
+    locales
+        .filter((locale) => !localesWithIssues.includes(locale))
+        .forEach((locale) => {
+        it(`integers localize and delocalize in "${locale}"`, () => {
+            const numberString = "555";
+            const localizedNumberString = localizeNumberString(numberString, locale);
+            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
+            expect(delocalizedNumberString).toBe(numberString);
+        });
+        it(`negative numbers localize and delocalize in "${locale}"`, () => {
+            const numberString = "-123";
+            const localizedNumberString = localizeNumberString(numberString, locale);
+            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
+            expect(delocalizedNumberString).toBe(numberString);
+        });
+        it(`floating point numbers localize and delocalize in "${locale}"`, () => {
+            const numberString = "4.321";
+            const localizedNumberString = localizeNumberString(numberString, locale);
+            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
+            expect(delocalizedNumberString).toBe(numberString);
+        });
+        it(`exponential numbers localize and delocalize in "${locale}"`, () => {
+            const numberString = "2.5e-3";
+            const localizedNumberString = localizeNumberString(numberString, locale);
+            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
+            expect(delocalizedNumberString).toBe(numberString);
+        });
+        it(`numbers with group separators localize and delocalize in "${locale}"`, () => {
+            const numberString = "1,234";
+            const localizedNumberString = localizeNumberString(numberString, locale, true);
+            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
+            expect(delocalizedNumberString).toBe("1234");
+        });
+        it(`floating point numbers with group separators localize and delocalize in "${locale}"`, () => {
+            const numberString = "12,345,678.9";
+            const localizedNumberString = localizeNumberString(numberString, locale, true);
+            const delocalizedNumberString = delocalizeNumberString(localizedNumberString, locale);
+            expect(delocalizedNumberString).toBe("12345678.9");
+        });
+    });
+});

package/dist/collection/utils/math.js

@@ -1,7 +1,7 @@
 /*!
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
  * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
- * v1.0.0-next.596
+ * v1.0.0-next.597
  */
 export const clamp = (value, min, max) => Math.max(min, Math.min(value, max));
 export const decimalPlaces = (value) => {

package/dist/collection/utils/math.spec.js

@@ -0,0 +1,8 @@
+import { clamp } from "./math";
+describe("clamp", () => {
+    it("clamps numbers within min/max", () => {
+        expect(clamp(5, 0, 10)).toBe(5);
+        expect(clamp(-1, 0, 10)).toBe(0);
+        expect(clamp(11, 0, 10)).toBe(10);
+    });
+});

package/dist/collection/utils/number.js

@@ -1,15 +1,10 @@
 /*!
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
  * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
- * v1.0.0-next.596
+ * v1.0.0-next.597
  */
 import { numberKeys } from "./key";
-import { createLocaleNumberFormatter, getDecimalSeparator, getMinusSign } from "./locale";
-// regex for number sanitization
-const allLeadingZerosOptionallyNegative = /^([-0])0+(?=\d)/;
-const decimalOnlyAtEndOfString = /(?!^\.)\.$/;
-const allHyphensExceptTheStart = /(?!^-)-/g;
-const isNegativeDecimalOnlyZeros = /^-\b0\b\.?0*$/;
+import { numberStringFormatter } from "./locale";
 // adopted from https://stackoverflow.com/a/66939244
 export class BigDecimal {
   constructor(input) {
@@ -36,10 +31,9 @@ export class BigDecimal {
     const i = s.slice(0, -BigDecimal.DECIMALS);
     const d = s.slice(-BigDecimal.DECIMALS).replace(/\.?0+$/, "");
     const value = i.concat(d.length ? "." + d : "");
-    return (this.isNegative ? "-" : "").concat(value);
+    return `${this.isNegative ? "-" : ""}${value}`;
   }
-  formatToParts(locale, numberingSystem) {
-    const formatter = createLocaleNumberFormatter(locale, numberingSystem);
+  formatToParts(formatter) {
     const s = this.value
       .toString()
       .replace(new RegExp("-", "g"), "")
@@ -47,13 +41,24 @@ export class BigDecimal {
     const i = s.slice(0, -BigDecimal.DECIMALS);
     const d = s.slice(-BigDecimal.DECIMALS).replace(/\.?0+$/, "");
     const parts = formatter.formatToParts(BigInt(i));
-    this.isNegative && parts.unshift({ type: "minusSign", value: getMinusSign(locale) });
+    this.isNegative && parts.unshift({ type: "minusSign", value: numberStringFormatter.minusSign });
     if (d.length) {
-      parts.push({ type: "decimal", value: getDecimalSeparator(locale) });
+      parts.push({ type: "decimal", value: numberStringFormatter.decimal });
       d.split("").forEach((char) => parts.push({ type: "fraction", value: char }));
     }
     return parts;
   }
+  format(formatter) {
+    const s = this.value
+      .toString()
+      .replace(new RegExp("-", "g"), "")
+      .padStart(BigDecimal.DECIMALS + 1, "0");
+    const i = s.slice(0, -BigDecimal.DECIMALS);
+    const d = s.slice(-BigDecimal.DECIMALS).replace(/\.?0+$/, "");
+    const iFormatted = `${this.isNegative ? numberStringFormatter.minusSign : ""}${formatter.format(BigInt(i))}`;
+    const dFormatted = d.length ? `${numberStringFormatter.decimal}${formatter.format(BigInt(d))}` : "";
+    return `${iFormatted}${dFormatted}`;
+  }
   add(num) {
     return BigDecimal.fromBigInt(this.value + new BigDecimal(num).value);
   }
@@ -96,25 +101,22 @@ export function parseNumberString(numberString) {
     return isValidNumber(result) ? new BigDecimal(result).toString() : "";
   });
 }
-export function sanitizeDecimalString(decimalString) {
-  return decimalString.replace(decimalOnlyAtEndOfString, "");
-}
-export function sanitizeNegativeString(negativeString) {
-  return negativeString.replace(allHyphensExceptTheStart, "");
-}
-export function sanitizeLeadingZeroString(zeroString) {
-  return zeroString.replace(allLeadingZerosOptionallyNegative, "$1");
-}
-export function sanitizeNumberString(numberString) {
-  return sanitizeExponentialNumberString(numberString, (nonExpoNumString) => {
-    const sanitizedValue = sanitizeNegativeString(sanitizeDecimalString(sanitizeLeadingZeroString(nonExpoNumString)));
-    return isValidNumber(sanitizedValue)
-      ? isNegativeDecimalOnlyZeros.test(sanitizedValue)
-        ? sanitizedValue
-        : new BigDecimal(sanitizedValue).toString()
-      : nonExpoNumString;
-  });
-}
+// regex for number sanitization
+const allLeadingZerosOptionallyNegative = /^([-0])0+(?=\d)/;
+const decimalOnlyAtEndOfString = /(?!^\.)\.$/;
+const allHyphensExceptTheStart = /(?!^-)-/g;
+const isNegativeDecimalOnlyZeros = /^-\b0\b\.?0*$/;
+export const sanitizeNumberString = (numberString) => sanitizeExponentialNumberString(numberString, (nonExpoNumString) => {
+  const sanitizedValue = nonExpoNumString
+    .replace(allHyphensExceptTheStart, "")
+    .replace(decimalOnlyAtEndOfString, "")
+    .replace(allLeadingZerosOptionallyNegative, "$1");
+  return isValidNumber(sanitizedValue)
+    ? isNegativeDecimalOnlyZeros.test(sanitizedValue)
+      ? sanitizedValue
+      : new BigDecimal(sanitizedValue).toString()
+    : nonExpoNumString;
+});
 export function sanitizeExponentialNumberString(numberString, func) {
   if (!numberString) {
     return numberString;