@duetds/components 8.0.6 → 8.1.1

package/lib/collection/utils/language-utils.js

@@ -4,32 +4,32 @@
 import { Build } from "@stencil/core";
 import { convertHtmlQuotes } from "./string-utils";
 const localeLookUpTable = {
-  fi: "fi-FI",
-  en: "en-GB",
-  us: "en-US",
-  sv: "sv-SE",
+    fi: "fi-FI",
+    en: "en-GB",
+    us: "en-US",
+    sv: "sv-SE",
 };
 const localeMonetarySignifierLookUpTable = {
-  fi: "€",
-  en: "£",
-  us: "$",
-  sv: "€",
+    fi: "€",
+    en: "£",
+    us: "$",
+    sv: "€",
 };
 const defLanguageArray = ["fi", "en", "sv"];
 const defaultLanguage = "fi";
 export const getCurrentLanguage = () => {
-  return document.documentElement.lang ? document.documentElement.lang.toLowerCase() : defaultLanguage;
+    return document.documentElement.lang ? document.documentElement.lang.toLowerCase() : defaultLanguage;
 };
 export const isOfTypeLanguage = (keyInput) => {
-  return defLanguageArray.includes(keyInput);
+    return defLanguageArray.includes(keyInput);
 };
 const checkForLanguage = (languageString = getCurrentLanguage()) => {
-  if (isOfTypeLanguage(languageString)) {
-    return languageString;
-  }
-  else {
-    return defaultLanguage;
-  }
+    if (isOfTypeLanguage(languageString)) {
+        return languageString;
+    }
+    else {
+        return defaultLanguage;
+    }
 };
 /**
  * Returns the current language as a string representation (taken from html lang attribute)
@@ -46,29 +46,29 @@ export const getLanguage = (languageString = getCurrentLanguage()) => checkForLa
  * @default {object} {locale: "fi-FI", money: "€"}
  */
 export const getLocale = (lang) => {
-  const returnObj = {
-    locale: localeLookUpTable[lang],
-    money: localeMonetarySignifierLookUpTable[lang],
-  };
-  if (returnObj.locale && returnObj.money) {
-    return returnObj;
-  }
-  throw new Error(`Locale for "${lang}" not found`);
+    const returnObj = {
+        locale: localeLookUpTable[lang],
+        money: localeMonetarySignifierLookUpTable[lang],
+    };
+    if (returnObj.locale && returnObj.money) {
+        return returnObj;
+    }
+    throw new Error(`Locale for "${lang}" not found`);
 };
 /**
  * Takes any json object that is passed and/or htmlencoded and converts it to proper json
  */
 export const sanitizeString = (string) => {
-  const argIsString = typeof string === "string";
-  if (argIsString) {
-    try {
-      return JSON.parse(convertHtmlQuotes(string));
-    }
-    catch (e) {
-      console.log("sanitizeString received a string, that didnt parse to json object", string, e);
+    const argIsString = typeof string === "string";
+    if (argIsString) {
+        try {
+            return JSON.parse(convertHtmlQuotes(string));
+        }
+        catch (e) {
+            console.log("sanitizeString received a string, that didnt parse to json object", string, e);
+        }
     }
-  }
-  return string;
+    return string;
 };
 /**
  * Returns the current string / object from a given translation object
@@ -80,13 +80,13 @@ export const sanitizeString = (string) => {
  * @returns {(string|Object)} given example contains {fi:"something"} and language===fi this will return "something"
  */
 export const getLocaleString = (langObject, languageOverride) => {
-  const obj = sanitizeString(langObject);
-  if (languageOverride) {
-    return obj[checkForLanguage(languageOverride)];
-  }
-  else {
-    return obj[getLanguage()];
-  }
+    const obj = sanitizeString(langObject);
+    if (languageOverride) {
+        return obj[checkForLanguage(languageOverride)];
+    }
+    else {
+        return obj[getLanguage()];
+    }
 };
 /**
  * Language change observer
@@ -113,46 +113,46 @@ const languageChangeSubscribers = new Set();
  */
 const languageChangeTargets = new WeakMap();
 const languagaChangeObserverCallback = mutationList => {
-  let oldValue = defaultLanguage;
-  for (const mutation of mutationList) {
-    if (mutation.type === "attributes" && mutation.attributeName === "lang") {
-      oldValue = mutation.oldValue;
-      break;
+    let oldValue = defaultLanguage;
+    for (const mutation of mutationList) {
+        if (mutation.type === "attributes" && mutation.attributeName === "lang") {
+            oldValue = mutation.oldValue;
+            break;
+        }
     }
-  }
-  if (document.documentElement.dataset.duetLangObserve) {
-    languageChangeSubscribers.forEach((component) => {
-      if (component.language) {
-        component.language = getLanguage();
-      }
-      if (languageChangeTargets.has(component)) {
-        languageChangeTargets.get(component).forEach(target => {
-          if (component[target.defaults] && component[target.prop] === component[target.defaults][oldValue]) {
-            component[target.prop] = getLocaleString(component[target.defaults]);
-          }
+    if (document.documentElement.dataset.duetLangObserve) {
+        languageChangeSubscribers.forEach((component) => {
+            if (component.language) {
+                component.language = getLanguage();
+            }
+            if (languageChangeTargets.has(component)) {
+                languageChangeTargets.get(component).forEach(target => {
+                    if (component[target.defaults] && component[target.prop] === component[target.defaults][oldValue]) {
+                        component[target.prop] = getLocaleString(component[target.defaults]);
+                    }
+                });
+            }
         });
-      }
-    });
-  }
+    }
 };
 if (!Build.isServer) {
-  const languageChangeObserver = new MutationObserver(languagaChangeObserverCallback);
-  languageChangeObserver.observe(document.documentElement, { attributeFilter: ["lang"], attributeOldValue: true });
+    const languageChangeObserver = new MutationObserver(languagaChangeObserverCallback);
+    languageChangeObserver.observe(document.documentElement, { attributeFilter: ["lang"], attributeOldValue: true });
 }
 export const connectLanguageChangeObserver = (component, targets) => {
-  languageChangeSubscribers.add(component);
-  if (targets) {
-    if (!Array.isArray(targets)) {
-      targets = [targets];
-    }
-    if (targets.some(t => !(t.prop in component) || !(t.defaults in component))) {
-      console.error("connectLanguageChangeObserver: component must have target.prop and target.defaults properties");
-      targets = targets.filter(t => t.prop in component && t.defaults in component);
+    languageChangeSubscribers.add(component);
+    if (targets) {
+        if (!Array.isArray(targets)) {
+            targets = [targets];
+        }
+        if (targets.some(t => !(t.prop in component) || !(t.defaults in component))) {
+            console.error("connectLanguageChangeObserver: component must have target.prop and target.defaults properties");
+            targets = targets.filter(t => t.prop in component && t.defaults in component);
+        }
+        languageChangeTargets.set(component, targets);
     }
-    languageChangeTargets.set(component, targets);
-  }
 };
 export const disconnectLanguageChangeObserver = (component) => {
-  languageChangeSubscribers.delete(component);
-  languageChangeTargets.delete(component);
+    languageChangeSubscribers.delete(component);
+    languageChangeTargets.delete(component);
 };

package/lib/collection/utils/language-utils.spec.js

@@ -4,156 +4,156 @@
 import { getCurrentLanguage, getLanguage, getLocale, getLocaleString, isOfTypeLanguage } from "./language-utils";
 import { convertHtmlQuotes } from "./string-utils";
 describe("language-utils", () => {
-  describe("isOfTypeLanguage", () => {
-    it("return true is language if part of default languages", () => {
-      expect(isOfTypeLanguage("fi")).toBe(true);
-      expect(isOfTypeLanguage("en")).toBe(true);
-      expect(isOfTypeLanguage("sv")).toBe(true);
+    describe("isOfTypeLanguage", () => {
+        it("return true is language if part of default languages", () => {
+            expect(isOfTypeLanguage("fi")).toBe(true);
+            expect(isOfTypeLanguage("en")).toBe(true);
+            expect(isOfTypeLanguage("sv")).toBe(true);
+        });
+        it("return false is language if not part of default languages", () => {
+            expect(isOfTypeLanguage("su")).toBe(false);
+            expect(isOfTypeLanguage("uk")).toBe(false);
+            expect(isOfTypeLanguage("dk")).toBe(false);
+        });
+    });
+    describe("getLocaleString", () => {
+        it("return the correct string", () => {
+            const object = {
+                fi: "finnish",
+                sv: "swedish",
+                en: "english",
+            };
+            expect(getLocaleString(object)).toBe(object["fi"]);
+        });
+        it("return the correct string for wrong overrides", () => {
+            const object = {
+                fi: "finnish",
+                sv: "swedish",
+                en: "english",
+                dk: "denmark",
+            };
+            expect(getLocaleString(object, "dk")).toBe(object["fi"]);
+        });
+        it("works with urlencoded strings (passed from a html element)", () => {
+            const reference = {
+                fi: { error: "Tiedostot, joissa on virheitä", success: "Tiedostot" },
+                sv: { error: "Filer med fel", success: "Filer" },
+                en: { error: "Files with errors", success: "Files" },
+            };
+            const object = '{"fi":{"error":"Tiedostot, joissa on virheitä","success":"Tiedostot"},"sv":{"error":"Filer med fel","success":"Filer"},"en":{"error":"Files with errors","success":"Files"}}';
+            const objectWithQuotes = "{"fi":{"error":"Tiedostot, joissa on virheitä","success":"Tiedostot"},"sv":{"error":"Filer med fel","success":"Filer"},"en":{"error":"Files with errors","success":"Files"}}";
+            const objectWithApos = "{'fi':{'error':'Tiedostot, joissa on virheitä','success':'Tiedostot'},'sv':{'error':'Filer med fel','success':'Filer'},'en':{'error':'Files with errors','success':'Files'}}";
+            const parsedObject = JSON.parse(convertHtmlQuotes(object));
+            const parseObjectWithQuotes = JSON.parse(convertHtmlQuotes(objectWithQuotes));
+            const parseObjectWithApos = JSON.parse(convertHtmlQuotes(objectWithApos));
+            expect(JSON.stringify(parsedObject)).toEqual(JSON.stringify(parseObjectWithQuotes));
+            expect(getLocaleString(parsedObject, "fi")).toEqual(reference["fi"]);
+            expect(getLocaleString(parseObjectWithQuotes)).toEqual(reference["fi"]);
+            expect(getLocaleString(parseObjectWithApos)).toEqual(reference["fi"]);
+        });
+    });
+    describe("getLocale", () => {
+        it("return the correct locale for se", () => {
+            const object = {
+                locale: "sv-SE",
+                money: "€",
+            };
+            expect(getLocale("sv")).toMatchObject(object);
+        });
+        it("return the correct locale for en", () => {
+            const object = {
+                locale: "en-GB",
+                money: "£",
+            };
+            expect(getLocale("en")).toMatchObject(object);
+        });
+        it("return the correct locale for us", () => {
+            const object = {
+                locale: "en-US",
+                money: "$",
+            };
+            expect(getLocale("us")).toMatchObject(object);
+        });
+        it("return the correct locale for fi", () => {
+            const object = {
+                locale: "fi-FI",
+                money: "€",
+            };
+            expect(getLocale("fi")).toMatchObject(object);
+        });
+        it("throws error for unknown languages", () => {
+            expect(() => {
+                //@ts-ignore
+                getLocale("no");
+            }).toThrow();
+        });
+    });
+    describe("getLanguage", () => {
+        it("returns a valid language even when given a unsuitable string", () => {
+            expect(getLanguage("shouldFail")).toBe("fi");
+            expect(getLanguage("us")).toBe("fi");
+            expect(getLanguage("sv")).toBe("sv");
+            expect(getLanguage("en")).toBe("en");
+            expect(getLanguage("fi")).toBe("fi");
+            expect(getLanguage()).toBe("fi");
+        });
+        it("should return correct language when html Lang is NOT present", () => {
+            delete document.documentElement.lang;
+            expect(getCurrentLanguage()).toBe("fi");
+            expect(getLanguage()).toBe("fi");
+        });
+        it("should return correct language when html Lang is present and set to fi", () => {
+            Object.defineProperty(document.documentElement, "lang", { value: "fi", configurable: true });
+            expect(getCurrentLanguage()).toBe("fi");
+            expect(getLanguage()).toBe("fi");
+        });
+        it("should return correct language when html Lang is present and set to sv", () => {
+            Object.defineProperty(document.documentElement, "lang", { value: "sv", configurable: true });
+            expect(getCurrentLanguage()).toBe("sv");
+            expect(getLanguage()).toBe("sv");
+        });
+        it("should return correct language when html Lang is present and set to en", () => {
+            Object.defineProperty(document.documentElement, "lang", { value: "en", configurable: true });
+            expect(getCurrentLanguage()).toBe("en");
+            expect(getLanguage()).toBe("en");
+        });
+        it("should return correct language when html Lang is present and set to dk", () => {
+            Object.defineProperty(document.documentElement, "lang", { value: "dk", configurable: true });
+            expect(getCurrentLanguage()).toBe("dk");
+            expect(getLanguage()).toBe("fi");
+        });
+    });
+    describe("avoid introducing breaking changes where label as String mutates to Object", () => {
+        /**
+         * We want to make sure that no regressions or breaking changes are introduced when converting props such as
+          @Prop() accessibleLabel: string = "Sulje viesti"
+    
+         to
+    
+         @Prop() accessibleLabel: string = getLocaleString({
+                  fi: "default finnish",
+                  sv: "default swedish",
+                  en: "default english",
+                })
+         */
+        const somePresetObject = {
+            fi: "preset finnish",
+            sv: "preset swedish",
+            en: "preset english",
+        };
+        const mockStringAsProperty = (variable) => {
+            return variable ? variable : getLocaleString(somePresetObject);
+        };
+        it("should not fail when label is a string", () => {
+            const testString = "some thing that is a string";
+            const resultString = mockStringAsProperty(testString);
+            const resultStringUndef = mockStringAsProperty(undefined);
+            const resultStringEmpty = mockStringAsProperty();
+            const resultStringNull = mockStringAsProperty(null);
+            expect(resultString).toBe(testString);
+            expect(resultStringEmpty).toBe(somePresetObject.fi);
+            expect(resultStringNull).toBe(somePresetObject.fi);
+            expect(resultStringUndef).toBe(somePresetObject.fi);
+        });
     });
-    it("return false is language if not part of default languages", () => {
-      expect(isOfTypeLanguage("su")).toBe(false);
-      expect(isOfTypeLanguage("uk")).toBe(false);
-      expect(isOfTypeLanguage("dk")).toBe(false);
-    });
-  });
-  describe("getLocaleString", () => {
-    it("return the correct string", () => {
-      const object = {
-        fi: "finnish",
-        sv: "swedish",
-        en: "english",
-      };
-      expect(getLocaleString(object)).toBe(object["fi"]);
-    });
-    it("return the correct string for wrong overrides", () => {
-      const object = {
-        fi: "finnish",
-        sv: "swedish",
-        en: "english",
-        dk: "denmark",
-      };
-      expect(getLocaleString(object, "dk")).toBe(object["fi"]);
-    });
-    it("works with urlencoded strings (passed from a html element)", () => {
-      const reference = {
-        fi: { error: "Tiedostot, joissa on virheitä", success: "Tiedostot" },
-        sv: { error: "Filer med fel", success: "Filer" },
-        en: { error: "Files with errors", success: "Files" },
-      };
-      const object = '{"fi":{"error":"Tiedostot, joissa on virheitä","success":"Tiedostot"},"sv":{"error":"Filer med fel","success":"Filer"},"en":{"error":"Files with errors","success":"Files"}}';
-      const objectWithQuotes = "{"fi":{"error":"Tiedostot, joissa on virheitä","success":"Tiedostot"},"sv":{"error":"Filer med fel","success":"Filer"},"en":{"error":"Files with errors","success":"Files"}}";
-      const objectWithApos = "{'fi':{'error':'Tiedostot, joissa on virheitä','success':'Tiedostot'},'sv':{'error':'Filer med fel','success':'Filer'},'en':{'error':'Files with errors','success':'Files'}}";
-      const parsedObject = JSON.parse(convertHtmlQuotes(object));
-      const parseObjectWithQuotes = JSON.parse(convertHtmlQuotes(objectWithQuotes));
-      const parseObjectWithApos = JSON.parse(convertHtmlQuotes(objectWithApos));
-      expect(JSON.stringify(parsedObject)).toEqual(JSON.stringify(parseObjectWithQuotes));
-      expect(getLocaleString(parsedObject, "fi")).toEqual(reference["fi"]);
-      expect(getLocaleString(parseObjectWithQuotes)).toEqual(reference["fi"]);
-      expect(getLocaleString(parseObjectWithApos)).toEqual(reference["fi"]);
-    });
-  });
-  describe("getLocale", () => {
-    it("return the correct locale for se", () => {
-      const object = {
-        locale: "sv-SE",
-        money: "€",
-      };
-      expect(getLocale("sv")).toMatchObject(object);
-    });
-    it("return the correct locale for en", () => {
-      const object = {
-        locale: "en-GB",
-        money: "£",
-      };
-      expect(getLocale("en")).toMatchObject(object);
-    });
-    it("return the correct locale for us", () => {
-      const object = {
-        locale: "en-US",
-        money: "$",
-      };
-      expect(getLocale("us")).toMatchObject(object);
-    });
-    it("return the correct locale for fi", () => {
-      const object = {
-        locale: "fi-FI",
-        money: "€",
-      };
-      expect(getLocale("fi")).toMatchObject(object);
-    });
-    it("throws error for unknown languages", () => {
-      expect(() => {
-        //@ts-ignore
-        getLocale("no");
-      }).toThrow();
-    });
-  });
-  describe("getLanguage", () => {
-    it("returns a valid language even when given a unsuitable string", () => {
-      expect(getLanguage("shouldFail")).toBe("fi");
-      expect(getLanguage("us")).toBe("fi");
-      expect(getLanguage("sv")).toBe("sv");
-      expect(getLanguage("en")).toBe("en");
-      expect(getLanguage("fi")).toBe("fi");
-      expect(getLanguage()).toBe("fi");
-    });
-    it("should return correct language when html Lang is NOT present", () => {
-      delete document.documentElement.lang;
-      expect(getCurrentLanguage()).toBe("fi");
-      expect(getLanguage()).toBe("fi");
-    });
-    it("should return correct language when html Lang is present and set to fi", () => {
-      Object.defineProperty(document.documentElement, "lang", { value: "fi", configurable: true });
-      expect(getCurrentLanguage()).toBe("fi");
-      expect(getLanguage()).toBe("fi");
-    });
-    it("should return correct language when html Lang is present and set to sv", () => {
-      Object.defineProperty(document.documentElement, "lang", { value: "sv", configurable: true });
-      expect(getCurrentLanguage()).toBe("sv");
-      expect(getLanguage()).toBe("sv");
-    });
-    it("should return correct language when html Lang is present and set to en", () => {
-      Object.defineProperty(document.documentElement, "lang", { value: "en", configurable: true });
-      expect(getCurrentLanguage()).toBe("en");
-      expect(getLanguage()).toBe("en");
-    });
-    it("should return correct language when html Lang is present and set to dk", () => {
-      Object.defineProperty(document.documentElement, "lang", { value: "dk", configurable: true });
-      expect(getCurrentLanguage()).toBe("dk");
-      expect(getLanguage()).toBe("fi");
-    });
-  });
-  describe("avoid introducing breaking changes where label as String mutates to Object", () => {
-    /**
-     * We want to make sure that no regressions or breaking changes are introduced when converting props such as
-      @Prop() accessibleLabel: string = "Sulje viesti"
-
-     to
-
-     @Prop() accessibleLabel: string = getLocaleString({
-              fi: "default finnish",
-              sv: "default swedish",
-              en: "default english",
-            })
-     */
-    const somePresetObject = {
-      fi: "preset finnish",
-      sv: "preset swedish",
-      en: "preset english",
-    };
-    const mockStringAsProperty = (variable) => {
-      return variable ? variable : getLocaleString(somePresetObject);
-    };
-    it("should not fail when label is a string", () => {
-      const testString = "some thing that is a string";
-      const resultString = mockStringAsProperty(testString);
-      const resultStringUndef = mockStringAsProperty(undefined);
-      const resultStringEmpty = mockStringAsProperty();
-      const resultStringNull = mockStringAsProperty(null);
-      expect(resultString).toBe(testString);
-      expect(resultStringEmpty).toBe(somePresetObject.fi);
-      expect(resultStringNull).toBe(somePresetObject.fi);
-      expect(resultStringUndef).toBe(somePresetObject.fi);
-    });
-  });
 });

package/lib/collection/utils/math.utils.js

@@ -9,71 +9,71 @@
  *  - an example is that some locales use (number) as an indicator for negative values instead of -number
  */
 export function SafeParseFloat(value, locale) {
-  let results;
-  if (typeof value === "string") {
-    if (value === "") {
-      return null;
+    let results;
+    if (typeof value === "string") {
+        if (value === "") {
+            return null;
+        }
+        //the minuses are NOT the same characters, they differ in unicode for some languages
+        // "‐", "−", "–", and "—"
+        let convertedMinus = value.replace("−", "-").replace("‐", "-").replace("−", "-").replace("–", "-").replace("—", "-");
+        if (locale) {
+            convertedMinus = ConvertToEnUS(convertedMinus, locale, false);
+        }
+        // replace all possible spaces from the string
+        convertedMinus = convertedMinus.replace(/\s+/g, "");
+        convertedMinus = convertedMinus.replace(/(?!^-?\d*\.{0,1}\d+$)/g, "");
+        /*
+        example: https://regex101.com/r/np7FqS/1
+          /(?!^-?\d*\.{0,1}\d+$)/g
+          Negative Lookahead (?!^-?\d*\.{0,1}\d+$)
+          Assert that the Regex below does not match
+          ^ asserts position at start of a line
+          - matches the character - with index 4510 (2D16 or 558) literally (case sensitive)
+          ? matches the previous token between zero and one times, as many times as possible, giving back as needed (greedy)
+          \d matches a digit (equivalent to [0-9])
+          * matches the previous token between zero and unlimited times, as many times as possible, giving back as needed (greedy)
+          \. matches the character . with index 4610 (2E16 or 568) literally (case sensitive)
+          {0,1} matches the previous token between zero and one times, as many times as possible, giving back as needed (greedy)
+          \d matches a digit (equivalent to [0-9])
+          + matches the previous token between one and unlimited times, as many times as possible, giving back as needed (greedy)
+          $ asserts position at the end of a line
+          Global pattern flags
+          g modifier: global. All matches (don't return after first match)
+          m modifier: multi line. Causes ^ and $ to match the begin/end of each line (not only begin/end of string)
+        */
+        results = parseFloat(convertedMinus);
     }
-    //the minuses are NOT the same characters, they differ in unicode for some languages
-    // "‐", "−", "–", and "—"
-    let convertedMinus = value.replace("−", "-").replace("‐", "-").replace("−", "-").replace("–", "-").replace("—", "-");
-    if (locale) {
-      convertedMinus = ConvertToEnUS(convertedMinus, locale, false);
+    if (typeof value === "number") {
+        results = parseFloat(String(value));
     }
-    // replace all possible spaces from the string
-    convertedMinus = convertedMinus.replace(/\s+/g, "");
-    convertedMinus = convertedMinus.replace(/(?!^-?\d*\.{0,1}\d+$)/g, "");
-    /*
-    example: https://regex101.com/r/np7FqS/1
-      /(?!^-?\d*\.{0,1}\d+$)/g
-      Negative Lookahead (?!^-?\d*\.{0,1}\d+$)
-      Assert that the Regex below does not match
-      ^ asserts position at start of a line
-      - matches the character - with index 4510 (2D16 or 558) literally (case sensitive)
-      ? matches the previous token between zero and one times, as many times as possible, giving back as needed (greedy)
-      \d matches a digit (equivalent to [0-9])
-      * matches the previous token between zero and unlimited times, as many times as possible, giving back as needed (greedy)
-      \. matches the character . with index 4610 (2E16 or 568) literally (case sensitive)
-      {0,1} matches the previous token between zero and one times, as many times as possible, giving back as needed (greedy)
-      \d matches a digit (equivalent to [0-9])
-      + matches the previous token between one and unlimited times, as many times as possible, giving back as needed (greedy)
-      $ asserts position at the end of a line
-      Global pattern flags
-      g modifier: global. All matches (don't return after first match)
-      m modifier: multi line. Causes ^ and $ to match the begin/end of each line (not only begin/end of string)
-    */
-    results = parseFloat(convertedMinus);
-  }
-  if (typeof value === "number") {
-    results = parseFloat(String(value));
-  }
-  if (!isNaN(Number(results))) {
-    return Number(results);
-  }
-  if (value === null || value === undefined) {
-    return null;
-  }
-  throw new Error("Invalid value passed to SafeParseFloat");
+    if (!isNaN(Number(results))) {
+        return Number(results);
+    }
+    if (value === null || value === undefined) {
+        return null;
+    }
+    throw new Error("Invalid value passed to SafeParseFloat");
 }
 // string conversion function that takes a locale and coverts decimal indicator to en-US indicator
 // and takes the thousand separator for the given locale and transforms that to the en-US separator
 export function ConvertToEnUS(value, locale, replaceThousands = false) {
-  let replacedValue;
-  const localeSeparator = new Intl.NumberFormat(locale).format(1 / 2).replace(/[0-9]/g, "");
-  const enUSSeparator = new Intl.NumberFormat("en-US").format(1 / 2).replace(/[0-9]/g, "");
-  const thousandSeparator = new Intl.NumberFormat(locale).format(1000).replace(/[0-9]/g, "");
-  const enUSThousandSeparator = new Intl.NumberFormat("en-US").format(1000).replace(/[0-9]/g, "");
-  // double conversions to avoid ,->. and .->, at the same time resulting in a double conversion
-  replacedValue = value.replace(localeSeparator, "DECIMALSEPARATOR");
-  if (replaceThousands) {
-    replacedValue = replacedValue.replace(thousandSeparator, "THOUSANDSEPARATOR");
-  }
-  else {
-    replacedValue = replacedValue.replace(thousandSeparator, "");
-  }
-  replacedValue = replacedValue.replace("DECIMALSEPARATOR", enUSSeparator);
-  replacedValue = replacedValue.replace("THOUSANDSEPARATOR", enUSThousandSeparator);
-  return replacedValue;
+    let replacedValue;
+    const localeSeparator = new Intl.NumberFormat(locale).format(1 / 2).replace(/[0-9]/g, "");
+    const enUSSeparator = new Intl.NumberFormat("en-US").format(1 / 2).replace(/[0-9]/g, "");
+    const thousandSeparator = new Intl.NumberFormat(locale).format(1000).replace(/[0-9]/g, "");
+    const enUSThousandSeparator = new Intl.NumberFormat("en-US").format(1000).replace(/[0-9]/g, "");
+    // double conversions to avoid ,->. and .->, at the same time resulting in a double conversion
+    replacedValue = value.replace(localeSeparator, "DECIMALSEPARATOR");
+    if (replaceThousands) {
+        replacedValue = replacedValue.replace(thousandSeparator, "THOUSANDSEPARATOR");
+    }
+    else {
+        replacedValue = replacedValue.replace(thousandSeparator, "");
+    }
+    replacedValue = replacedValue.replace("DECIMALSEPARATOR", enUSSeparator);
+    replacedValue = replacedValue.replace("THOUSANDSEPARATOR", enUSThousandSeparator);
+    return replacedValue;
 }
 export const roundTo = (val, multiple) => Math.round(val / multiple) * multiple;
 export const clamp = (val, min, max) => Math.min(Math.max(val, min), max);