vueless 0.0.761 → 0.0.762

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vueless",
-  "version": "0.0.761",
+  "version": "0.0.762",
   "license": "MIT",
   "description": "Vue Styleless UI Component Library, powered by Tailwind CSS.",
   "keywords": [

package/ui.form-input-money/utilFormat.ts

@@ -2,7 +2,6 @@ import type { FormatOptions } from "./types.ts";
 
 const isNumberValueRegExp = /^[\d,.\s-]+$/;
 const rawDecimalMark = ".";
-const comma = ",";
 const minus = "-";
 
 export function getRawValue(value: string | number, options: FormatOptions): string {
@@ -14,7 +13,8 @@ export function getRawValue(value: string | number, options: FormatOptions): str
 
   const rawValueWithPrefix = value
     .replaceAll(thousandsSeparator, "")
-    .replace(decimalSeparator, ".");
+    .replaceAll(" ", "")
+    .replace(decimalSeparator, rawDecimalMark);
 
   return rawValueWithPrefix.replace(prefix, "");
 }
@@ -30,11 +30,14 @@ export function getFormattedValue(value: string | number, options: FormatOptions
   } = options;
 
   const invalidValuesRegExp = new RegExp("[^\\d,\\d.\\s-" + decimalSeparator + "]", "g");
-  const doubleValueRegExp = new RegExp("([,\\.\\s" + decimalSeparator + "])+", "g");
+  const doubleValueRegExp = new RegExp("([,\\.\\s\\-" + decimalSeparator + "])+", "g");
+
+  const actualMinFractionDigit =
+    minFractionDigits <= maxFractionDigits ? minFractionDigits : maxFractionDigits;
 
   // slice to first decimal mark
   value = String(value)
-    .replaceAll(comma, decimalSeparator)
+    .replaceAll(rawDecimalMark, decimalSeparator)
     .split(decimalSeparator)
     .slice(0, 2)
     .map((value: string, index: number) =>
@@ -51,14 +54,23 @@ export function getFormattedValue(value: string | number, options: FormatOptions
   const isNumber = isNumberValueRegExp.test(value);
   const isFloat = value.endsWith(rawDecimalMark) || value.endsWith(".0");
   const isMinus = value === minus;
-  const isMinusWithin = value.includes(minus) && !value.startsWith(minus);
 
   if (isMinus && positiveOnly) {
     value = "";
   }
 
-  if (isMinusWithin) {
-    value = value.replaceAll(minus, "");
+  if (value.includes(minus)) {
+    let isFirstMinus = value.startsWith(minus);
+
+    value = value.replaceAll(minus, (match) => {
+      if (isFirstMinus) {
+        isFirstMinus = false;
+
+        return match;
+      }
+
+      return "";
+    });
   }
 
   if (!value || !isNumber || isFloat || isMinus) {
@@ -66,9 +78,9 @@ export function getFormattedValue(value: string | number, options: FormatOptions
   }
 
   const intlNumberOptions: Intl.NumberFormatOptions = {
-    minimumFractionDigits:
-      minFractionDigits <= maxFractionDigits ? minFractionDigits : maxFractionDigits,
+    minimumFractionDigits: actualMinFractionDigit,
     maximumFractionDigits: maxFractionDigits,
+    roundingMode: "trunc",
   };
 
   if (positiveOnly) {
@@ -86,20 +98,26 @@ export function getFormattedValue(value: string | number, options: FormatOptions
     positiveOnly: false,
   });
 
-  const [integer, fraction = ""] = rawValue.split(rawDecimalMark);
-  const bigInteger = intlNumber.format(BigInt(integer));
+  const formattedValue = intlNumber
+    .formatToParts((rawValue || 0) as unknown as number)
+    .map((part) => {
+      if (part.type === "group") part.value = thousandsSeparator;
+      if (part.type === "decimal") part.value = decimalSeparator;
+
+      if (part.type === "fraction") {
+        const fraction = rawValue.split(rawDecimalMark).at(-1) || "";
+        const formattedFraction = fraction
+          .split("")
+          .slice(actualMinFractionDigit, maxFractionDigits)
+          .join("");
 
-  const formattedFraction = fraction
-    .slice(minFractionDigits, maxFractionDigits)
-    .padStart(maxFractionDigits, "0");
+        part.value = formattedFraction;
+      }
 
-  const formattedBigInt = fraction
-    ? bigInteger + `${rawDecimalMark}${formattedFraction}`
-    : bigInteger;
+      return part;
+    });
 
-  const formattedValue = formattedBigInt
-    .replaceAll(comma, thousandsSeparator)
-    .replaceAll(rawDecimalMark, decimalSeparator);
+  formattedValue.unshift({ value: prefix, type: "minusSign" });
 
-  return prefix + formattedValue;
+  return formattedValue.map((part) => part.value).join("");
 }