@uzum-tech/ui 2.0.1 → 2.0.2

package/es/chat/src/ChatParts/MainArea.mjs

@@ -246,6 +246,8 @@ export default defineComponent({
       const keyId = toKeyString(chat === null || chat === void 0 ? void 0 : chat.id);
       const keyTitle = toKeyString(chat === null || chat === void 0 ? void 0 : chat.title);
       return h("div", {
+        class: `${mergedClsPrefixRef.value}-chat-main__header`
+      }, h("div", {
         class: `${mergedClsPrefixRef.value}-chat-main__header-inner`
       }, h("div", {
         class: `${mergedClsPrefixRef.value}-chat-main__header-title-wrap`
@@ -344,7 +346,7 @@ export default defineComponent({
           }));
           return buttons;
         })
-      }));
+      })));
     };
     const renderMessages = () => {
       var _a;

package/es/components.d.ts

@@ -68399,6 +68399,10 @@ export declare const UInputNumber: import("vue").DefineComponent<import("vue").E
         type: BooleanConstructor;
         default: boolean;
     };
+    type: {
+        type: import("vue").PropType<"default" | "amount">;
+        default: string;
+    };
     parse: import("vue").PropType<(input: string) => number | null>;
     format: import("vue").PropType<(value: number | null) => string>;
     precision: NumberConstructor;
@@ -69355,6 +69359,7 @@ export declare const UInputNumber: import("vue").DefineComponent<import("vue").E
     displayedValue: import("vue").Ref<string, string>;
     addable: import("vue").ComputedRef<boolean>;
     minusable: import("vue").ComputedRef<boolean>;
+    showButton: import("vue").ComputedRef<boolean>;
     mergedStatus: import("vue").ComputedRef<import("./form/src/interface").FormValidationStatus | undefined>;
     handleFocus: (e: FocusEvent) => void;
     handleBlur: (e: FocusEvent) => void;
@@ -69733,6 +69738,10 @@ export declare const UInputNumber: import("vue").DefineComponent<import("vue").E
         type: BooleanConstructor;
         default: boolean;
     };
+    type: {
+        type: import("vue").PropType<"default" | "amount">;
+        default: string;
+    };
     parse: import("vue").PropType<(input: string) => number | null>;
     format: import("vue").PropType<(value: number | null) => string>;
     precision: NumberConstructor;
@@ -70628,6 +70637,7 @@ export declare const UInputNumber: import("vue").DefineComponent<import("vue").E
 }>> & Readonly<{}>, {
     bordered: boolean | undefined;
     disabled: boolean | undefined;
+    type: "default" | "amount";
     loading: boolean;
     clearable: boolean;
     defaultValue: number | null;
@@ -79156,6 +79166,7 @@ export declare const UMappingCardList: import("vue").DefineComponent<import("vue
         readonly type: NumberConstructor;
         readonly default: 16;
     };
+    readonly emptyProps: import("vue").PropType<Partial<import("./empty").EmptyProps>>;
 }>, {
     mergedClsPrefix: import("vue").Ref<string, string>;
     mergedPagination: import("vue").ComputedRef<import("./pagination").PaginationProps | null>;
@@ -79172,6 +79183,7 @@ export declare const UMappingCardList: import("vue").DefineComponent<import("vue
         readonly type: NumberConstructor;
         readonly default: 16;
     };
+    readonly emptyProps: import("vue").PropType<Partial<import("./empty").EmptyProps>>;
 }>> & Readonly<{}>, {
     readonly gap: number;
     readonly items: import(".").MappingCardProps[];
@@ -82082,6 +82094,23 @@ export declare const UModal: import("vue").DefineComponent<import("vue").Extract
     loading: BooleanConstructor;
     bordered: BooleanConstructor;
     iconPlacement: import("vue").PropType<import("./dialog/src/interface").IconPlacement>;
+    contentClass: StringConstructor;
+    contentScrollable: BooleanConstructor;
+    contentStyle: import("vue").PropType<import("vue").CSSProperties | string>;
+    headerStyle: import("vue").PropType<import("vue").CSSProperties | string>;
+    headerExtraStyle: import("vue").PropType<import("vue").CSSProperties | string>;
+    footerStyle: import("vue").PropType<import("vue").CSSProperties | string>;
+    embedded: BooleanConstructor;
+    segmented: {
+        readonly type: import("vue").PropType<boolean | import("./card").CardSegmented>;
+        readonly default: false;
+    };
+    hoverable: BooleanConstructor;
+    role: StringConstructor;
+    tag: {
+        readonly type: import("vue").PropType<keyof HTMLElementTagNameMap>;
+        readonly default: "div";
+    };
     show: BooleanConstructor;
     unstableShowMask: {
         type: BooleanConstructor;
@@ -83144,6 +83173,23 @@ export declare const UModal: import("vue").DefineComponent<import("vue").Extract
     loading: BooleanConstructor;
     bordered: BooleanConstructor;
     iconPlacement: import("vue").PropType<import("./dialog/src/interface").IconPlacement>;
+    contentClass: StringConstructor;
+    contentScrollable: BooleanConstructor;
+    contentStyle: import("vue").PropType<import("vue").CSSProperties | string>;
+    headerStyle: import("vue").PropType<import("vue").CSSProperties | string>;
+    headerExtraStyle: import("vue").PropType<import("vue").CSSProperties | string>;
+    footerStyle: import("vue").PropType<import("vue").CSSProperties | string>;
+    embedded: BooleanConstructor;
+    segmented: {
+        readonly type: import("vue").PropType<boolean | import("./card").CardSegmented>;
+        readonly default: false;
+    };
+    hoverable: BooleanConstructor;
+    role: StringConstructor;
+    tag: {
+        readonly type: import("vue").PropType<keyof HTMLElementTagNameMap>;
+        readonly default: "div";
+    };
     show: BooleanConstructor;
     unstableShowMask: {
         type: BooleanConstructor;
@@ -84140,9 +84186,14 @@ export declare const UModal: import("vue").DefineComponent<import("vue").Extract
     type: "default" | "error" | "warning" | "success" | "info";
     size: "small" | "medium" | "large";
     loading: boolean;
+    tag: keyof HTMLElementTagNameMap;
     showIcon: boolean;
     closable: boolean;
     show: boolean;
+    contentScrollable: boolean;
+    embedded: boolean;
+    segmented: boolean | import("./card").CardSegmented;
+    hoverable: boolean;
     displayDirective: "show" | "if";
     maskClosable: boolean;
     trapFocus: boolean;

package/es/input-number/src/InputNumber.d.ts

@@ -52,6 +52,10 @@ export declare const inputNumberProps: {
         type: BooleanConstructor;
         default: boolean;
     };
+    type: {
+        type: PropType<"default" | "amount">;
+        default: string;
+    };
     parse: PropType<(input: string) => number | null>;
     format: PropType<(value: number | null) => string>;
     precision: NumberConstructor;
@@ -1001,6 +1005,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
+    type: {
+        type: PropType<"default" | "amount">;
+        default: string;
+    };
     parse: PropType<(input: string) => number | null>;
     format: PropType<(value: number | null) => string>;
     precision: NumberConstructor;
@@ -1957,6 +1965,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     displayedValue: import("vue").Ref<string, string>;
     addable: import("vue").ComputedRef<boolean>;
     minusable: import("vue").ComputedRef<boolean>;
+    showButton: import("vue").ComputedRef<boolean>;
     mergedStatus: import("vue").ComputedRef<FormValidationStatus | undefined>;
     handleFocus: (e: FocusEvent) => void;
     handleBlur: (e: FocusEvent) => void;
@@ -2335,6 +2344,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: BooleanConstructor;
         default: boolean;
     };
+    type: {
+        type: PropType<"default" | "amount">;
+        default: string;
+    };
     parse: PropType<(input: string) => number | null>;
     format: PropType<(value: number | null) => string>;
     precision: NumberConstructor;
@@ -3230,6 +3243,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>> & Readonly<{}>, {
     bordered: boolean | undefined;
     disabled: boolean | undefined;
+    type: "default" | "amount";
     loading: boolean;
     clearable: boolean;
     defaultValue: number | null;

package/es/input-number/src/InputNumber.mjs

@@ -9,8 +9,9 @@ import { call, resolveSlot, resolveWrappedSlot, warnOnce } from "../../_utils/in
 import { UxButton } from "../../button/index.mjs";
 import { UInput } from "../../input/index.mjs";
 import { inputNumberLight } from "../styles/index.mjs";
+import { MAX_AMOUNT_INPUT_DIGITS } from "./constants.mjs";
+import { parse, validator, format, parseNumber, isWipValue, getPrecision, parseAmount, formatAmount, isValidAmountInput, isAmountInputWithinDigitLimit, isRawWipValue, mapSelectionAfterFormat, getRejectedSelectionRange } from "./utils.mjs";
 import style from "./styles/input-number.cssr.mjs";
-import { format, isWipValue, parse, parseNumber, validator } from "./utils.mjs";
 const HOLDING_CHANGE_THRESHOLD = 800;
 const HOLDING_CHANGE_INTERVAL = 100;
 export const inputNumberProps = Object.assign(Object.assign({}, useTheme.props), {
@@ -59,6 +60,10 @@ export const inputNumberProps = Object.assign(Object.assign({}, useTheme.props),
     type: Boolean,
     default: true
   },
+  type: {
+    type: String,
+    default: 'default'
+  },
   parse: Function,
   format: Function,
   precision: Number,
@@ -107,10 +112,6 @@ export default defineComponent({
     const controlledValueRef = toRef(props, 'value');
     const mergedValueRef = useMergedState(controlledValueRef, uncontrolledValueRef);
     const displayedValueRef = ref('');
-    const getPrecision = value => {
-      const fraction = String(value).split('.')[1];
-      return fraction ? fraction.length : 0;
-    };
     const getMaxPrecision = currentValue => {
       const precisions = [props.min, props.max, props.step, currentValue].map(value => {
         if (value === undefined) return 0;
@@ -140,6 +141,44 @@ export default defineComponent({
       const parsedNumber = parseNumber(props.max);
       if (parsedNumber !== null) return parsedNumber;else return null;
     });
+    const isAmountTypeRef = useMemo(() => props.type === 'amount');
+    const showButtonRef = useMemo(() => {
+      return isAmountTypeRef.value ? false : props.showButton;
+    });
+    const effectiveParse = input => {
+      if (props.parse) return props.parse(input);
+      if (isAmountTypeRef.value) return parseAmount(input);
+      return parse(input);
+    };
+    const effectiveFormat = (value, precision) => {
+      if (props.format && value !== undefined) return props.format(value);
+      if (isAmountTypeRef.value) return formatAmount(value, precision);
+      return format(value, precision);
+    };
+    const doUpdateValue = value => {
+      const {
+        value: mergedValue
+      } = mergedValueRef;
+      if (value === mergedValue) {
+        deriveDisplayedValueFromValue();
+        return;
+      }
+      const {
+        'onUpdate:value': _onUpdateValue,
+        onUpdateValue,
+        onChange
+      } = props;
+      const {
+        triggerFormInput,
+        triggerFormChange
+      } = formItem;
+      if (onChange) call(onChange, value);
+      if (onUpdateValue) call(onUpdateValue, value);
+      if (_onUpdateValue) call(_onUpdateValue, value);
+      uncontrolledValueRef.value = value;
+      triggerFormInput();
+      triggerFormChange();
+    };
     const deriveValueFromDisplayedValue = ({
       offset,
       doUpdateIfValid,
@@ -152,7 +191,7 @@ export default defineComponent({
       if (isInputing && isWipValue(displayedValue)) {
         return false;
       }
-      const parsedValue = (props.parse || parse)(displayedValue);
+      const parsedValue = effectiveParse(displayedValue);
       if (parsedValue === null) {
         if (doUpdateIfValid) doUpdateValue(null);
         return null;
@@ -196,51 +235,69 @@ export default defineComponent({
       } = mergedValueRef;
       if (validator(mergedValue)) {
         const {
-          format: formatProp,
           precision
         } = props;
-        if (formatProp) {
-          displayedValueRef.value = formatProp(mergedValue);
-        } else {
-          if (mergedValue === null || precision === undefined
-          // precision overflow
-          || getPrecision(mergedValue) > precision) {
-            displayedValueRef.value = format(mergedValue, undefined);
-          } else {
-            displayedValueRef.value = format(mergedValue, precision);
-          }
-        }
+        displayedValueRef.value = effectiveFormat(mergedValue, mergedValue === null ? undefined : precision);
       } else {
         // null can pass the validator check
         // so mergedValue is a number
         displayedValueRef.value = String(mergedValue);
       }
     };
-    deriveDisplayedValueFromValue();
-    function doUpdateValue(value) {
+    const computeValueToFormat = (prev, derived) => {
+      if (derived !== false && derived !== null) return derived;
+      if (!isAmountTypeRef.value) return null;
+      const parsed = effectiveParse(prev);
+      if (parsed === null || Number.isNaN(parsed)) return null;
+      return parsed;
+    };
+    const setInputValueSelection = (value, selectionStart, selectionEnd) => {
+      var _a;
+      const inputElement = (_a = inputInstRef.value) === null || _a === void 0 ? void 0 : _a.inputElRef;
+      if (!inputElement) return;
+      inputElement.value = value;
+      inputElement.setSelectionRange(selectionStart, selectionEnd);
+    };
+    const applyFormatted = (prev, valueNumber) => {
+      var _a, _b, _c;
+      const inputElement = (_a = inputInstRef.value) === null || _a === void 0 ? void 0 : _a.inputElRef;
+      const selectionStart = (_b = inputElement === null || inputElement === void 0 ? void 0 : inputElement.selectionStart) !== null && _b !== void 0 ? _b : prev.length;
+      const selectionEnd = (_c = inputElement === null || inputElement === void 0 ? void 0 : inputElement.selectionEnd) !== null && _c !== void 0 ? _c : selectionStart;
+      const newFormatted = effectiveFormat(valueNumber, props.precision);
+      displayedValueRef.value = newFormatted;
+      void nextTick(() => {
+        const {
+          start,
+          end
+        } = mapSelectionAfterFormat(prev, newFormatted, selectionStart, selectionEnd);
+        inputElement === null || inputElement === void 0 ? void 0 : inputElement.setSelectionRange(start, end);
+      });
+    };
+    const restoreRejectedAmountInput = (prevDisplayedValue, attemptedDisplayedValue) => {
+      var _a, _b, _c;
+      const inputElement = (_a = inputInstRef.value) === null || _a === void 0 ? void 0 : _a.inputElRef;
+      const selectionStart = (_b = inputElement === null || inputElement === void 0 ? void 0 : inputElement.selectionStart) !== null && _b !== void 0 ? _b : attemptedDisplayedValue.length;
+      const selectionEnd = (_c = inputElement === null || inputElement === void 0 ? void 0 : inputElement.selectionEnd) !== null && _c !== void 0 ? _c : selectionStart;
       const {
-        value: mergedValue
-      } = mergedValueRef;
-      if (value === mergedValue) {
-        deriveDisplayedValueFromValue();
-        return;
+        start,
+        end
+      } = getRejectedSelectionRange(prevDisplayedValue, attemptedDisplayedValue, selectionStart, selectionEnd);
+      displayedValueRef.value = prevDisplayedValue;
+      setInputValueSelection(prevDisplayedValue, start, end);
+      void nextTick(() => {
+        setInputValueSelection(prevDisplayedValue, start, end);
+      });
+    };
+    const shouldRejectAmountInput = value => {
+      if (!isValidAmountInput(value)) return true;
+      if (!isAmountInputWithinDigitLimit(value, MAX_AMOUNT_INPUT_DIGITS)) {
+        return true;
       }
-      const {
-        'onUpdate:value': _onUpdateValue,
-        onUpdateValue,
-        onChange
-      } = props;
-      const {
-        triggerFormInput,
-        triggerFormChange
-      } = formItem;
-      if (onChange) call(onChange, value);
-      if (onUpdateValue) call(onUpdateValue, value);
-      if (_onUpdateValue) call(_onUpdateValue, value);
-      uncontrolledValueRef.value = value;
-      triggerFormInput();
-      triggerFormChange();
-    }
+      if (props.precision === undefined) return false;
+      const parsedValue = effectiveParse(value);
+      return parsedValue !== null && !Number.isNaN(parsedValue) && getPrecision(parsedValue) > props.precision;
+    };
+    deriveDisplayedValueFromValue();
     const displayedValueInvalidRef = useMemo(() => {
       const derivedValue = deriveValueFromDisplayedValue({
         offset: 0,
@@ -532,15 +589,30 @@ export default defineComponent({
         }
       }
     }
+    const shouldTryFormat = () => props.updateValueOnInput && !props.format && !props.parse && (props.precision === undefined || isAmountTypeRef.value);
     function handleUpdateDisplayedValue(value) {
+      const prevDisplayedValue = displayedValueRef.value;
+      const prevFormatted = value;
+      if (isAmountTypeRef.value) {
+        if (shouldRejectAmountInput(value)) {
+          restoreRejectedAmountInput(prevDisplayedValue, value);
+          return;
+        }
+      }
       displayedValueRef.value = value;
-      if (props.updateValueOnInput && !props.format && !props.parse && props.precision === undefined) {
-        deriveValueFromDisplayedValue({
-          offset: 0,
-          doUpdateIfValid: true,
-          isInputing: true,
-          fixPrecision: false
-        });
+      if (!shouldTryFormat()) return;
+      if (isAmountTypeRef.value) {
+        if (isRawWipValue(prevFormatted)) return;
+      }
+      const derived = deriveValueFromDisplayedValue({
+        offset: 0,
+        doUpdateIfValid: true,
+        isInputing: true,
+        fixPrecision: false
+      });
+      const valueToFormat = computeValueToFormat(prevFormatted, derived);
+      if (valueToFormat !== null && isAmountTypeRef.value) {
+        applyFormatted(prevFormatted, valueToFormat);
       }
     }
     watch(mergedValueRef, () => {
@@ -577,6 +649,7 @@ export default defineComponent({
       displayedValue: displayedValueRef,
       addable: addableRef,
       minusable: minusableRef,
+      showButton: showButtonRef,
       mergedStatus: mergedStatusRef,
       handleFocus,
       handleBlur,

package/es/input-number/src/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const MAX_AMOUNT_INPUT_DIGITS = 16;
+export declare enum InputNumberRegex {
+    INPUT_WIP_VALUE = "^(-)?\\d+.*(\\.|0)$",
+    INPUT_LEADING_DOT_WIP_VALUE = "^\\.\\d+$",
+    AMOUNT_INPUT = "^-?[\\d\\s]*\\.?\\d*$",
+    AMOUNT_VALUE = "^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$",
+    AMOUNT_RAW_LEADING_DOT = "^-?\\.\\d*$",
+    WHITESPACE = "\\s",
+    NON_DIGIT = "\\D",
+    LEADING_ZEROS = "^0+(?=\\d)",
+    NON_ZERO_DIGIT = "[1-9]",
+    TRAILING_ZERO_FRACTION = "\\.?0+$",
+    THOUSANDS_SEPARATOR = "\\B(?=(\\d{3})+(?!\\d))"
+}

package/es/input-number/src/constants.mjs

@@ -0,0 +1,15 @@
+export const MAX_AMOUNT_INPUT_DIGITS = 16;
+export var InputNumberRegex;
+(function (InputNumberRegex) {
+  InputNumberRegex["INPUT_WIP_VALUE"] = "^(-)?\\d+.*(\\.|0)$";
+  InputNumberRegex["INPUT_LEADING_DOT_WIP_VALUE"] = "^\\.\\d+$";
+  InputNumberRegex["AMOUNT_INPUT"] = "^-?[\\d\\s]*\\.?\\d*$";
+  InputNumberRegex["AMOUNT_VALUE"] = "^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)$";
+  InputNumberRegex["AMOUNT_RAW_LEADING_DOT"] = "^-?\\.\\d*$";
+  InputNumberRegex["WHITESPACE"] = "\\s";
+  InputNumberRegex["NON_DIGIT"] = "\\D";
+  InputNumberRegex["LEADING_ZEROS"] = "^0+(?=\\d)";
+  InputNumberRegex["NON_ZERO_DIGIT"] = "[1-9]";
+  InputNumberRegex["TRAILING_ZERO_FRACTION"] = "\\.?0+$";
+  InputNumberRegex["THOUSANDS_SEPARATOR"] = "\\B(?=(\\d{3})+(?!\\d))";
+})(InputNumberRegex || (InputNumberRegex = {}));

package/es/input-number/src/interface.d.ts

@@ -4,3 +4,7 @@ export interface InputNumberInst {
     blur: () => void;
     select: () => void;
 }
+export interface InputSelectionRange {
+    start: number;
+    end: number;
+}

package/es/input-number/src/utils.d.ts

@@ -1,5 +1,17 @@
+import type { InputSelectionRange } from './interface';
 export declare function parse(value: string): number | null;
 export declare function isWipValue(value: string): boolean;
 export declare function validator(value: number | null): boolean;
 export declare function format(value: number | undefined | null, precision: number | undefined): string;
 export declare function parseNumber(number: number | null | undefined | string): number | null;
+export declare function getPrecision(value: string | number): number;
+export declare function stripAmountFormatting(value: string): string;
+export declare function isValidAmountInput(value: string): boolean;
+export declare function isAmountInputWithinDigitLimit(value: string, maxDigits?: number): boolean;
+export declare function getRejectedSelectionRange(prevDisplayedValue: string, attemptedDisplayedValue: string, selectionStart: number, selectionEnd: number): InputSelectionRange;
+export declare function parseAmount(input: string): number | null;
+export declare function formatAmount(value: number | undefined | null, precision: number | undefined): string;
+export declare function formattedToRawIndex(formatted: string, caret: number): number;
+export declare function rawIndexToCaret(formatted: string, rawIndex: number): number;
+export declare function isRawWipValue(formatted: string): boolean;
+export declare function mapSelectionAfterFormat(formatted: string, newFormatted: string, selectionStart: number, selectionEnd: number): InputSelectionRange;

package/es/input-number/src/utils.mjs

@@ -1,3 +1,5 @@
+import { InputNumberRegex, MAX_AMOUNT_INPUT_DIGITS } from "./constants.mjs";
+const MAX_SAFE_INTEGER_LIMIT = String(Number.MAX_SAFE_INTEGER);
 // string => string (expected, not implemented)
 // string => number (legacy)
 export function parse(value) {
@@ -9,7 +11,7 @@ export function parse(value) {
 // can be parsed to number but shouldn't be applied when inputing
 // when value includes `.`, ending with 0 and`.`, doesn't update, if 0 parse func will remove 0
 export function isWipValue(value) {
-  return value.includes('.') && (/^(-)?\d+.*(\.|0)$/.test(value) || /^\.\d+$/.test(value));
+  return value.includes('.') && (new RegExp(InputNumberRegex.INPUT_WIP_VALUE).test(value) || new RegExp(InputNumberRegex.INPUT_LEADING_DOT_WIP_VALUE).test(value));
 }
 // string => boolean (expected, not implemented)
 // number => boolean (legacy)
@@ -36,4 +38,90 @@ export function parseNumber(number) {
       return parsedNumber;
     }
   }
+}
+export function getPrecision(value) {
+  const fraction = String(value).split('.')[1];
+  return fraction ? fraction.length : 0;
+}
+export function stripAmountFormatting(value) {
+  return String(value).replace(new RegExp(InputNumberRegex.WHITESPACE, 'g'), '').trim();
+}
+export function isValidAmountInput(value) {
+  return value === '' || new RegExp(InputNumberRegex.AMOUNT_INPUT).test(value);
+}
+export function isAmountInputWithinDigitLimit(value, maxDigits = MAX_AMOUNT_INPUT_DIGITS) {
+  return value.replace(new RegExp(InputNumberRegex.NON_DIGIT, 'g'), '').length <= maxDigits;
+}
+export function getRejectedSelectionRange(prevDisplayedValue, attemptedDisplayedValue, selectionStart, selectionEnd) {
+  const removedLength = Math.max(0, attemptedDisplayedValue.length - prevDisplayedValue.length);
+  return {
+    start: Math.min(prevDisplayedValue.length, Math.max(0, selectionStart - removedLength)),
+    end: Math.min(prevDisplayedValue.length, Math.max(0, selectionEnd - removedLength))
+  };
+}
+function exceedsMaxSafeAmountValue(numberString) {
+  const normalized = numberString.startsWith('-') ? numberString.slice(1) : numberString;
+  const [integerPart = '0', fractionPart = ''] = normalized.split('.');
+  const normalizedIntegerPart = integerPart.replace(new RegExp(InputNumberRegex.LEADING_ZEROS), '');
+  return normalizedIntegerPart.length > MAX_SAFE_INTEGER_LIMIT.length || normalizedIntegerPart.length === MAX_SAFE_INTEGER_LIMIT.length && (normalizedIntegerPart > MAX_SAFE_INTEGER_LIMIT || normalizedIntegerPart === MAX_SAFE_INTEGER_LIMIT && new RegExp(InputNumberRegex.NON_ZERO_DIGIT).test(fractionPart));
+}
+export function parseAmount(input) {
+  if (input === undefined || input === null) return null;
+  const numberString = stripAmountFormatting(input);
+  if (new RegExp(InputNumberRegex.AMOUNT_VALUE).test(numberString)) {
+    if (exceedsMaxSafeAmountValue(numberString)) return Number.NaN;
+    return Number(numberString);
+  }
+  return numberString === '' ? null : Number.NaN;
+}
+export function formatAmount(value, precision) {
+  if (value === undefined || value === null) return '';
+  let stringValue = String(value);
+  if (precision !== undefined) {
+    stringValue = value.toFixed(precision).replace(new RegExp(InputNumberRegex.TRAILING_ZERO_FRACTION), '');
+  }
+  const negative = stringValue.startsWith('-');
+  if (negative) stringValue = stringValue.slice(1);
+  const [integerPart, fractionPart] = stringValue.split('.');
+  const integerWithSeparator = integerPart.replace(new RegExp(InputNumberRegex.THOUSANDS_SEPARATOR, 'g'), ' ');
+  return `${negative ? '-' : ''}${integerWithSeparator}${fractionPart ? `.${fractionPart}` : ''}`;
+}
+export function formattedToRawIndex(formatted, caret) {
+  let raw = 0;
+  for (let i = 0; i < Math.min(caret, formatted.length); i++) {
+    if (formatted[i] !== ' ') raw++;
+  }
+  return raw;
+}
+export function rawIndexToCaret(formatted, rawIndex) {
+  if (rawIndex <= 0) return 0;
+  let raw = 0;
+  for (let i = 0; i < formatted.length; i++) {
+    if (formatted[i] !== ' ') raw++;
+    if (raw === rawIndex) return i + 1;
+  }
+  return formatted.length;
+}
+export function isRawWipValue(formatted) {
+  return isWipValue(stripAmountFormatting(formatted));
+}
+export function mapSelectionAfterFormat(formatted, newFormatted, selectionStart, selectionEnd) {
+  const rawStart = formattedToRawIndex(formatted, selectionStart);
+  const rawEnd = formattedToRawIndex(formatted, selectionEnd);
+  const rawInput = stripAmountFormatting(formatted);
+  if (new RegExp(InputNumberRegex.AMOUNT_RAW_LEADING_DOT).test(rawInput)) {
+    const {
+      length
+    } = newFormatted;
+    return {
+      start: length,
+      end: length
+    };
+  }
+  const newStart = rawIndexToCaret(newFormatted, rawStart);
+  const newEnd = rawIndexToCaret(newFormatted, rawEnd);
+  return {
+    start: newStart,
+    end: newEnd
+  };
 }

package/es/mapping-card/src/MappingCardList.d.ts

@@ -12,6 +12,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         readonly type: NumberConstructor;
         readonly default: 16;
     };
+    readonly emptyProps: import("vue").PropType<Partial<import("../..").EmptyProps>>;
 }>, {
     mergedClsPrefix: import("vue").Ref<string, string>;
     mergedPagination: import("vue").ComputedRef<PaginationProps | null>;
@@ -28,6 +29,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         readonly type: NumberConstructor;
         readonly default: 16;
     };
+    readonly emptyProps: import("vue").PropType<Partial<import("../..").EmptyProps>>;
 }>> & Readonly<{}>, {
     readonly gap: number;
     readonly items: import("./interface").MappingCardProps[];

package/es/mapping-card/src/MappingCardList.mjs

@@ -1,5 +1,7 @@
 import { computed, defineComponent, h } from 'vue';
 import { useConfig } from "../../_mixins/index.mjs";
+import { resolveSlot } from "../../_utils/index.mjs";
+import { UEmpty } from "../../empty/index.mjs";
 import { UFlex } from "../../flex/index.mjs";
 import { UPagination } from "../../pagination/index.mjs";
 import { mappingCardListProps } from "./interface.mjs";
@@ -28,11 +30,18 @@ export default defineComponent({
       mergedClsPrefix,
       mergedPagination,
       gap,
-      items
+      items,
+      emptyProps,
+      $slots
     } = this;
+    const isEmpty = !items.length;
     return h("div", {
       class: `${mergedClsPrefix}-mapping-card-list`
-    }, h(UFlex, {
+    }, isEmpty ? h("div", {
+      class: `${mergedClsPrefix}-mapping-card-list__empty`
+    }, resolveSlot($slots.empty, () => [h(UEmpty, Object.assign({
+      size: "large"
+    }, emptyProps))])) : h(UFlex, {
       vertical: true,
       size: gap,
       class: `${mergedClsPrefix}-mapping-card-list__items`

package/es/mapping-card/src/interface.d.ts

@@ -2,6 +2,7 @@ import type { PropType, VNodeChild } from 'vue';
 import type { BuiltinType, BuiltinTypeMap, ComponentConfig } from '../../_internal/component-renderer';
 import type { ExtractPublicPropTypes } from '../../_utils';
 import type { ButtonProps } from '../../button';
+import type { EmptyProps } from '../../empty';
 import type { IconProps } from '../../icon';
 import type { PaginationProps } from '../../pagination';
 import type { SwitchProps } from '../../switch';
@@ -55,6 +56,7 @@ export interface MappingCardListInterface {
     items?: MappingCardProps[];
     pagination?: PaginationProps | false;
     gap?: number;
+    emptyProps?: Partial<EmptyProps>;
 }
 export declare const mappingCardProps: {
     readonly title: PropType<MappingCardInterface["title"]>;
@@ -104,6 +106,7 @@ export declare const mappingCardListProps: {
         readonly type: NumberConstructor;
         readonly default: 16;
     };
+    readonly emptyProps: PropType<Partial<EmptyProps>>;
 };
 export type MappingCardProps = ExtractPublicPropTypes<typeof mappingCardProps>;
 export type MappingCardListProps = ExtractPublicPropTypes<typeof mappingCardListProps>;

package/es/mapping-card/src/interface.mjs

@@ -45,5 +45,6 @@ export const mappingCardListProps = {
   gap: {
     type: Number,
     default: 16
-  }
+  },
+  emptyProps: Object
 };