vueless 0.0.761 → 0.0.763

package/package.json

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

package/ui.data-table/UTable.vue

@@ -38,7 +38,7 @@ import {
 import { COMPONENT_NAME } from "./constants.ts";
 
 import type { Cell, Row, RowId, UTableProps, UTableRowAttrs, Config } from "./types.ts";
-import type { Ref, ComputedRef, VNode } from "vue";
+import type { Ref, ComputedRef } from "vue";
 
 defineOptions({ inheritAttrs: false });
 
@@ -186,17 +186,6 @@ const isCheckedMoreOneTableItems = computed(() => {
 
 const tableRowWidthStyle = computed(() => ({ width: `${tableWidth.value / PX_IN_REM}rem` }));
 
-const hasSlotContentBeforeFirstRow = computed(() => {
-  if (
-    hasSlotContent(slots["before-first-row"]) &&
-    typeof slots["before-first-row"] === "function"
-  ) {
-    return (slots["before-first-row"]({}) as VNode[])?.some((item) => Boolean(item.type));
-  }
-
-  return false;
-});
-
 const flatTableRows = computed(() => getFlatRows(tableRows.value));
 
 const isSelectedAllRows = computed(() => {
@@ -345,19 +334,16 @@ function onKeyupEsc(event: KeyboardEvent) {
 
 function isShownDateDivider(rowIndex: number) {
   const prevIndex = rowIndex ? rowIndex - 1 : rowIndex;
-  const nextIndex = rowIndex ? rowIndex + 1 : rowIndex;
   const prevItem = tableRows.value[prevIndex];
-  const nextItem = tableRows.value[nextIndex];
   const currentItem = tableRows.value[rowIndex];
 
   if (rowIndex === 0) {
-    return hasSlotContentBeforeFirstRow.value;
+    return true;
   }
 
   const isPrevSameDate = prevItem?.rowDate === currentItem?.rowDate;
-  const isNextSameDate = nextItem?.rowDate === currentItem?.rowDate;
 
-  return !isPrevSameDate && isNextSameDate && props.dateDivider;
+  return !isPrevSameDate && props.dateDivider;
 }
 
 function onClickRow(row: Row) {

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("");
 }