@talex-touch/tuffex 0.3.3 → 0.3.4

package/dist/es/select/src/TxSelect.vue2.js

@@ -1,14 +1,15 @@
-import { defineComponent, ref, computed, provide, onMounted, onBeforeUnmount, watch, nextTick, createElementBlock, openBlock, normalizeClass, createElementVNode, createBlock, createVNode, withCtx, Teleport, Transition, withDirectives, normalizeStyle, unref, createCommentVNode, renderSlot, vShow } from 'vue';
-import { useFloating, offset, flip, shift, size, autoUpdate } from '@floating-ui/vue';
-import TxCard from '../../card/src/TxCard.vue.js';
+import { defineComponent, ref, useSlots, computed, provide, onMounted, watch, nextTick, createElementBlock, openBlock, normalizeClass, createVNode, withCtx, createElementVNode, normalizeStyle, createCommentVNode, renderSlot } from 'vue';
 import TuffInput from '../../input/src/TxInput.vue.js';
+import TxPopover from '../../popover/src/TxPopover.vue.js';
 import TxSearchInput from '../../search-input/src/TxSearchInput.vue.js';
+import { SELECT_KEY } from './types.js';
 
-const _hoisted_1 = {
+const _hoisted_1 = { class: "tuff-select__trigger" };
+const _hoisted_2 = {
   key: 0,
   class: "tuff-select__search"
 };
-const _hoisted_2 = { class: "tuff-select__list" };
+const _hoisted_3 = { class: "tuff-select__list" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{
     name: "TuffSelect"
@@ -18,23 +19,31 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     modelValue: { default: "" },
     placeholder: { default: "请选择" },
     disabled: { type: Boolean, default: false },
+    eager: { type: Boolean, default: false },
     searchable: { type: Boolean, default: false },
     searchPlaceholder: { default: "Search" },
     editable: { type: Boolean, default: false },
     remote: { type: Boolean, default: false },
     dropdownMaxHeight: { default: 280 },
-    dropdownOffset: { default: 6 }
+    dropdownOffset: { default: 6 },
+    panelVariant: { default: "solid" },
+    panelBackground: { default: "refraction" },
+    panelShadow: { default: "soft" },
+    panelRadius: { default: 18 },
+    panelPadding: { default: 4 },
+    panelCard: {}
   },
   emits: ["update:modelValue", "change", "search"],
   setup(__props, { expose: __expose, emit: __emit }) {
     const props = __props;
     const emit = __emit;
     const isOpen = ref(false);
-    const selectRef = ref(null);
     const selectedLabel = ref("");
     const searchInputRef = ref(null);
     const searchQuery = ref("");
     const triggerInputRef = ref(null);
+    const panelRef = ref(null);
+    const slots = useSlots();
     const isEditable = computed(() => props.editable || props.remote);
     const triggerText = computed({
       get: () => isEditable.value ? searchQuery.value : selectedLabel.value,
@@ -42,35 +51,92 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         if (!isEditable.value)
           return;
         searchQuery.value = v;
-        if (props.remote)
-          emit("search", v);
+        if (!isOpen.value && !props.disabled)
+          isOpen.value = true;
       }
     });
-    const dropdownRef = ref(null);
-    const cleanupAutoUpdate = ref(null);
     const optionLabelMap = ref(/* @__PURE__ */ new Map());
-    const { floatingStyles, update } = useFloating(selectRef, dropdownRef, {
-      placement: "bottom-start",
-      strategy: "fixed",
-      middleware: [
-        offset(() => props.dropdownOffset),
-        flip({ padding: 8 }),
-        shift({ padding: 8 }),
-        size({
-          padding: 8,
-          apply({ rects, availableHeight, elements }) {
-            const h = Math.min(availableHeight, props.dropdownMaxHeight);
-            Object.assign(elements.floating.style, {
-              minWidth: `${rects.reference.width}px`,
-              maxWidth: `${rects.reference.width}px`,
-              height: `${h}px`,
-              maxHeight: `${h}px`,
-              overflow: "hidden"
-            });
+    function isSelectValueEqual(optionValue, currentValue2) {
+      if (optionValue === currentValue2)
+        return true;
+      if ((typeof optionValue === "string" || typeof optionValue === "number") && (typeof currentValue2 === "string" || typeof currentValue2 === "number")) {
+        const optionNumber = Number(optionValue);
+        const currentNumber = Number(currentValue2);
+        if (Number.isFinite(optionNumber) && Number.isFinite(currentNumber)) {
+          return optionNumber === currentNumber;
+        }
+      }
+      return false;
+    }
+    function resolveLabelByValue(value) {
+      const direct = optionLabelMap.value.get(value);
+      if (direct !== void 0)
+        return direct;
+      for (const [optionValue, optionLabel] of optionLabelMap.value.entries()) {
+        if (isSelectValueEqual(optionValue, value))
+          return optionLabel;
+      }
+      const slotLabel = resolveLabelFromSlot(value);
+      if (slotLabel !== void 0)
+        return slotLabel;
+      return void 0;
+    }
+    function resolveChildrenText(children) {
+      if (children == null || typeof children === "boolean")
+        return "";
+      if (typeof children === "string" || typeof children === "number")
+        return String(children);
+      if (Array.isArray(children))
+        return children.map((item) => resolveChildrenText(item)).join("");
+      if (typeof children === "object") {
+        if ("children" in children) {
+          return resolveChildrenText(children.children);
+        }
+        if ("default" in children) {
+          const maybeSlot = children.default;
+          if (typeof maybeSlot === "function")
+            return resolveChildrenText(maybeSlot());
+        }
+      }
+      return "";
+    }
+    function resolveLabelFromSlot(value) {
+      const queue = [...slots.default?.() ?? []];
+      while (queue.length > 0) {
+        const node = queue.shift();
+        if (!node)
+          continue;
+        if (Array.isArray(node)) {
+          queue.push(...node);
+          continue;
+        }
+        if (typeof node !== "object")
+          continue;
+        const vnode = node;
+        const props2 = vnode.props;
+        if (props2 && Object.prototype.hasOwnProperty.call(props2, "value")) {
+          const optionValue = props2.value;
+          if (isSelectValueEqual(optionValue, value)) {
+            const rawLabel = typeof props2.label === "string" ? props2.label : resolveChildrenText(vnode.children);
+            const normalizedLabel = rawLabel.replace(/\s+/g, " ").trim();
+            return normalizedLabel || String(optionValue);
           }
-        })
-      ]
-    });
+        }
+        if (Array.isArray(vnode.children)) {
+          queue.push(...vnode.children);
+          continue;
+        }
+        if (typeof vnode.children === "object" && vnode.children !== null) {
+          const defaultSlot = vnode.children.default;
+          if (typeof defaultSlot === "function") {
+            const slotNodes = defaultSlot();
+            if (Array.isArray(slotNodes))
+              queue.push(...slotNodes);
+          }
+        }
+      }
+      return void 0;
+    }
     const currentValue = computed({
       get: () => props.modelValue,
       set: (val) => {
@@ -99,40 +165,27 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     }
     function registerOption(value, label) {
       optionLabelMap.value.set(value, label);
-      if (currentValue.value === value && !selectedLabel.value) {
-        selectedLabel.value = label;
+      const currentLabel = resolveLabelByValue(currentValue.value);
+      if (currentLabel !== void 0 && !selectedLabel.value) {
+        selectedLabel.value = currentLabel;
       }
     }
-    function handleClickOutside(event) {
-      if (!isOpen.value)
+    function openFromFocus() {
+      if (props.disabled || !isEditable.value)
         return;
-      const target = event.target;
-      const inReference = !!selectRef.value && !!target && selectRef.value.contains(target);
-      const inFloating = !!dropdownRef.value && !!target && dropdownRef.value.contains(target);
-      if (!inReference && !inFloating)
-        close();
-    }
-    function handleEsc(event) {
-      if (event.key !== "Escape")
-        return;
-      if (!isOpen.value)
-        return;
-      close();
-    }
-    async function updatePosition() {
-      await update();
+      isOpen.value = true;
     }
     function scrollSelectedIntoView() {
-      if (!dropdownRef.value)
+      if (!panelRef.value)
         return;
-      const el = dropdownRef.value.querySelector(".tuff-select-item.is-selected");
+      const el = panelRef.value.querySelector(".tuff-select-item.is-selected");
       if (!el)
         return;
       requestAnimationFrame(() => {
         el.scrollIntoView({ block: "nearest" });
       });
     }
-    provide("tuffSelect", {
+    provide(SELECT_KEY, {
       currentValue,
       handleSelect,
       registerOption,
@@ -147,41 +200,36 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       clear
     });
     onMounted(() => {
-      document.addEventListener("click", handleClickOutside);
-      document.addEventListener("keydown", handleEsc);
-    });
-    onBeforeUnmount(() => {
-      document.removeEventListener("click", handleClickOutside);
-      document.removeEventListener("keydown", handleEsc);
+      const label = resolveLabelByValue(currentValue.value);
+      if (label !== void 0) {
+        selectedLabel.value = label;
+        if (isEditable.value && !isOpen.value)
+          searchQuery.value = label;
+      }
     });
     watch(
       () => props.modelValue,
       (val) => {
-        currentValue.value = val;
-        const label = optionLabelMap.value.get(val);
-        if (label)
+        const label = resolveLabelByValue(val);
+        if (label !== void 0) {
           selectedLabel.value = label;
+          if (isEditable.value && !isOpen.value)
+            searchQuery.value = label;
+          return;
+        }
+        if (val === "" || val == null) {
+          selectedLabel.value = "";
+          if (isEditable.value && !isOpen.value)
+            searchQuery.value = "";
+        }
       },
       { immediate: true }
     );
     watch(
       isOpen,
       async (open) => {
-        if (!open) {
-          cleanupAutoUpdate.value?.();
-          cleanupAutoUpdate.value = null;
-          if (isEditable.value)
-            searchQuery.value = selectedLabel.value;
-          else
-            searchQuery.value = "";
+        if (!open)
           return;
-        }
-        await nextTick();
-        await updatePosition();
-        if (selectRef.value && dropdownRef.value) {
-          cleanupAutoUpdate.value?.();
-          cleanupAutoUpdate.value = autoUpdate(selectRef.value, dropdownRef.value, () => updatePosition());
-        }
         if (props.searchable)
           searchInputRef.value?.focus?.();
         if (isEditable.value)
@@ -191,6 +239,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       },
       { flush: "post" }
     );
+    watch(
+      () => props.disabled,
+      (disabled) => {
+        if (disabled)
+          isOpen.value = false;
+      }
+    );
     watch(
       searchQuery,
       (v) => {
@@ -199,14 +254,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       },
       { flush: "post" }
     );
-    onBeforeUnmount(() => {
-      cleanupAutoUpdate.value?.();
-      cleanupAutoUpdate.value = null;
-    });
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("div", {
-        ref_key: "selectRef",
-        ref: selectRef,
         class: normalizeClass(["tuff-select", [
           {
             "is-open": isOpen.value,
@@ -214,77 +263,79 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           }
         ]])
       }, [
-        createElementVNode("div", {
-          class: "tuff-select__trigger",
-          onClick: _cache[2] || (_cache[2] = ($event) => !isEditable.value && toggle())
-        }, [
-          createVNode(TuffInput, {
-            ref_key: "triggerInputRef",
-            ref: triggerInputRef,
-            modelValue: triggerText.value,
-            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => triggerText.value = $event),
-            placeholder: __props.placeholder,
-            readonly: !isEditable.value,
-            disabled: __props.disabled,
-            onFocus: _cache[1] || (_cache[1] = ($event) => !__props.disabled && (isOpen.value = true))
-          }, {
-            suffix: withCtx(() => [..._cache[4] || (_cache[4] = [
-              createElementVNode("span", { class: "tuff-select__arrow" }, [
-                createElementVNode("svg", {
-                  viewBox: "0 0 24 24",
-                  width: "16",
-                  height: "16"
-                }, [
-                  createElementVNode("path", {
-                    fill: "currentColor",
-                    d: "M12 15.0006L7.75732 10.758L9.17154 9.34375L12 12.1722L14.8284 9.34375L16.2426 10.758L12 15.0006Z"
-                  })
-                ])
-              ], -1)
-            ])]),
-            _: 1
-          }, 8, ["modelValue", "placeholder", "readonly", "disabled"])
-        ]),
-        (openBlock(), createBlock(Teleport, { to: "body" }, [
-          createVNode(Transition, { name: "tuff-select-dropdown" }, {
-            default: withCtx(() => [
-              withDirectives(createElementVNode("div", {
-                ref_key: "dropdownRef",
-                ref: dropdownRef,
-                class: "tuff-select__dropdown",
-                style: normalizeStyle(unref(floatingStyles))
-              }, [
-                createVNode(TxCard, {
-                  class: "tuff-select__panel",
-                  variant: "solid",
-                  background: "glass",
-                  shadow: "soft",
-                  radius: 18,
-                  padding: 4
-                }, {
-                  default: withCtx(() => [
-                    __props.searchable && !isEditable.value ? (openBlock(), createElementBlock("div", _hoisted_1, [
-                      createVNode(TxSearchInput, {
-                        ref_key: "searchInputRef",
-                        ref: searchInputRef,
-                        modelValue: searchQuery.value,
-                        "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => searchQuery.value = $event),
-                        placeholder: __props.searchPlaceholder
-                      }, null, 8, ["modelValue", "placeholder"])
-                    ])) : createCommentVNode("", true),
-                    createElementVNode("div", _hoisted_2, [
-                      renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        createVNode(TxPopover, {
+          modelValue: isOpen.value,
+          "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => isOpen.value = $event),
+          disabled: __props.disabled,
+          eager: __props.eager,
+          placement: "bottom-start",
+          offset: __props.dropdownOffset,
+          width: 0,
+          "max-width": 9999,
+          "reference-full-width": true,
+          "show-arrow": false,
+          trigger: "click",
+          "toggle-on-reference-click": !isEditable.value,
+          "panel-variant": __props.panelVariant,
+          "panel-background": __props.panelBackground,
+          "panel-shadow": __props.panelShadow,
+          "panel-radius": __props.panelRadius,
+          "panel-padding": __props.panelPadding,
+          "panel-card": __props.panelCard
+        }, {
+          reference: withCtx(() => [
+            createElementVNode("div", _hoisted_1, [
+              createVNode(TuffInput, {
+                ref_key: "triggerInputRef",
+                ref: triggerInputRef,
+                modelValue: triggerText.value,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => triggerText.value = $event),
+                placeholder: __props.placeholder,
+                readonly: !isEditable.value,
+                disabled: __props.disabled,
+                onFocus: openFromFocus
+              }, {
+                suffix: withCtx(() => [..._cache[3] || (_cache[3] = [
+                  createElementVNode("span", { class: "tuff-select__arrow" }, [
+                    createElementVNode("svg", {
+                      viewBox: "0 0 24 24",
+                      width: "16",
+                      height: "16"
+                    }, [
+                      createElementVNode("path", {
+                        fill: "currentColor",
+                        d: "M12 15.0006L7.75732 10.758L9.17154 9.34375L12 12.1722L14.8284 9.34375L16.2426 10.758L12 15.0006Z"
+                      })
                     ])
-                  ]),
-                  _: 3
-                })
-              ], 4), [
-                [vShow, isOpen.value]
+                  ], -1)
+                ])]),
+                _: 1
+              }, 8, ["modelValue", "placeholder", "readonly", "disabled"])
+            ])
+          ]),
+          default: withCtx(() => [
+            createElementVNode("div", {
+              ref_key: "panelRef",
+              ref: panelRef,
+              class: "tuff-select__panel",
+              style: normalizeStyle({ maxHeight: `${__props.dropdownMaxHeight}px` })
+            }, [
+              __props.searchable && !isEditable.value ? (openBlock(), createElementBlock("div", _hoisted_2, [
+                createVNode(TxSearchInput, {
+                  ref_key: "searchInputRef",
+                  ref: searchInputRef,
+                  modelValue: searchQuery.value,
+                  "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => searchQuery.value = $event),
+                  placeholder: __props.searchPlaceholder
+                }, null, 8, ["modelValue", "placeholder"])
+              ])) : createCommentVNode("", true),
+              createElementVNode("div", _hoisted_3, [
+                renderSlot(_ctx.$slots, "default", {}, void 0, true)
               ])
-            ]),
-            _: 3
-          })
-        ]))
+            ], 4)
+          ]),
+          _: 3
+        }, 8, ["modelValue", "disabled", "eager", "offset", "toggle-on-reference-click", "panel-variant", "panel-background", "panel-shadow", "panel-radius", "panel-padding", "panel-card"])
       ], 2);
     };
   }

package/dist/es/select/src/TxSelectItem.vue.js

@@ -2,6 +2,6 @@ import _sfc_main from './TxSelectItem.vue2.js';
 /* empty css                  */
 import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
 
-const TuffSelectItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4b9e3f13"]]);
+const TxSelectItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2253b518"]]);
 
-export { TuffSelectItem as default };
+export { TxSelectItem as default };

package/dist/es/select/src/TxSelectItem.vue2.js

@@ -1,5 +1,6 @@
-import { defineComponent, inject, onMounted, computed, withDirectives, createBlock, openBlock, normalizeClass, withCtx, renderSlot, createTextVNode, toDisplayString, vShow } from 'vue';
+import { defineComponent, inject, useSlots, computed, onMounted, watch, withDirectives, createBlock, openBlock, normalizeClass, withCtx, renderSlot, createTextVNode, toDisplayString, vShow } from 'vue';
 import TxCardItem from '../../card-item/src/TxCardItem.vue.js';
+import { SELECT_KEY } from './types.js';
 
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{
@@ -13,11 +14,47 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   },
   setup(__props) {
     const props = __props;
-    const txSelect = inject("tuffSelect");
+    const txSelect = inject(SELECT_KEY);
+    const slots = useSlots();
+    function resolveChildrenText(children) {
+      if (children == null || typeof children === "boolean")
+        return "";
+      if (typeof children === "string" || typeof children === "number")
+        return String(children);
+      if (Array.isArray(children))
+        return children.map((item) => resolveChildrenText(item)).join("");
+      if (typeof children === "object") {
+        const maybeSlot = children.default;
+        if (typeof maybeSlot === "function") {
+          return resolveChildrenText(maybeSlot());
+        }
+        if ("children" in children) {
+          return resolveChildrenText(children.children);
+        }
+      }
+      return "";
+    }
+    const resolvedLabel = computed(() => {
+      if (props.label)
+        return props.label;
+      const slotContent = slots.default?.();
+      const extracted = resolveChildrenText(slotContent).replace(/\s+/g, " ").trim();
+      if (extracted)
+        return extracted;
+      return String(props.value);
+    });
+    function registerCurrentOption() {
+      txSelect?.registerOption(props.value, resolvedLabel.value);
+    }
     onMounted(() => {
-      const label = props.label || String(props.value);
-      txSelect?.registerOption?.(props.value, label);
+      registerCurrentOption();
     });
+    watch(
+      () => resolvedLabel.value,
+      () => {
+        registerCurrentOption();
+      }
+    );
     const isSelected = computed(() => {
       return txSelect?.currentValue.value === props.value;
     });
@@ -25,13 +62,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       const q = (txSelect?.searchQuery?.value ?? "").trim().toLowerCase();
       if (!q)
         return true;
-      const label = (props.label || String(props.value)).toLowerCase();
+      const label = resolvedLabel.value.toLowerCase();
       return label.includes(q);
     });
     function handleClick() {
       if (props.disabled)
         return;
-      txSelect?.handleSelect(props.value, props.label || String(props.value));
+      txSelect?.handleSelect(props.value, resolvedLabel.value);
     }
     return (_ctx, _cache) => {
       return withDirectives((openBlock(), createBlock(TxCardItem, {
@@ -43,7 +80,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }, {
         title: withCtx(() => [
           renderSlot(_ctx.$slots, "default", {}, () => [
-            createTextVNode(toDisplayString(__props.label || __props.value), 1)
+            createTextVNode(toDisplayString(resolvedLabel.value), 1)
           ], true)
         ]),
         _: 3

package/dist/es/select/src/types.d.ts

@@ -0,0 +1,34 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { BaseAnchorPanelCardProps } from '../../base-anchor/src/types';
+
+export type TxSelectValue = string | number;
+export interface TxSelectProps {
+    modelValue?: TxSelectValue;
+    placeholder?: string;
+    disabled?: boolean;
+    eager?: boolean;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    editable?: boolean;
+    remote?: boolean;
+    dropdownMaxHeight?: number;
+    dropdownOffset?: number;
+    panelVariant?: 'solid' | 'dashed' | 'plain';
+    panelBackground?: 'pure' | 'mask' | 'blur' | 'glass' | 'refraction';
+    panelShadow?: 'none' | 'soft' | 'medium';
+    panelRadius?: number;
+    panelPadding?: number;
+    panelCard?: BaseAnchorPanelCardProps;
+}
+export interface TxSelectItemProps {
+    value: TxSelectValue;
+    label?: string;
+    disabled?: boolean;
+}
+export interface TxSelectContext {
+    currentValue: ComputedRef<TxSelectValue>;
+    handleSelect: (value: TxSelectValue, label: string) => void;
+    registerOption: (value: TxSelectValue, label: string) => void;
+    searchQuery: ComputedRef<string>;
+}
+export declare const SELECT_KEY: InjectionKey<TxSelectContext>;

package/dist/es/select/src/types.js

@@ -0,0 +1,3 @@
+const SELECT_KEY = Symbol("TxSelect");
+
+export { SELECT_KEY };

package/dist/es/skeleton/index.d.ts

@@ -1,4 +1,4 @@
-import { SkeletonProps } from './src/types.ts';
+import { SkeletonProps } from './src/types';
 import { default as TxCardSkeleton } from './src/TxCardSkeleton.vue';
 import { default as TxListItemSkeleton } from './src/TxListItemSkeleton.vue';
 import { default as TxSkeleton } from './src/TxSkeleton.vue';
@@ -18,7 +18,7 @@ declare const Skeleton: {
             default: number;
         };
         variant: {
-            type: import('vue').PropType<import('./src/types.ts').SkeletonVariant>;
+            type: import('vue').PropType<import('./src/types').SkeletonVariant>;
             default: string;
         };
         radius: {
@@ -37,7 +37,7 @@ declare const Skeleton: {
         loading: boolean;
         width: string | number;
         height: string | number;
-        variant: import('./src/types.ts').SkeletonVariant;
+        variant: import('./src/types').SkeletonVariant;
         radius: string | number;
         gap: string | number;
         lines: number;
@@ -62,7 +62,7 @@ declare const Skeleton: {
             default: number;
         };
         variant: {
-            type: import('vue').PropType<import('./src/types.ts').SkeletonVariant>;
+            type: import('vue').PropType<import('./src/types').SkeletonVariant>;
             default: string;
         };
         radius: {
@@ -81,7 +81,7 @@ declare const Skeleton: {
         loading: boolean;
         width: string | number;
         height: string | number;
-        variant: import('./src/types.ts').SkeletonVariant;
+        variant: import('./src/types').SkeletonVariant;
         radius: string | number;
         gap: string | number;
         lines: number;
@@ -103,7 +103,7 @@ declare const Skeleton: {
         default: number;
     };
     variant: {
-        type: import('vue').PropType<import('./src/types.ts').SkeletonVariant>;
+        type: import('vue').PropType<import('./src/types').SkeletonVariant>;
         default: string;
     };
     radius: {
@@ -122,7 +122,7 @@ declare const Skeleton: {
     loading: boolean;
     width: string | number;
     height: string | number;
-    variant: import('./src/types.ts').SkeletonVariant;
+    variant: import('./src/types').SkeletonVariant;
     radius: string | number;
     gap: string | number;
     lines: number;

package/dist/es/skeleton/index.js

@@ -1,4 +1,4 @@
-import { withInstall } from '../utils/withInstall.js';
+import { withInstall } from '../packages/tuffex/packages/utils/withInstall.js';
 import TxCardSkeleton from './src/TxCardSkeleton.vue.js';
 import TxListItemSkeleton from './src/TxListItemSkeleton.vue.js';
 import _sfc_main from './src/TxSkeleton.vue.js';