@talex-touch/tuffex 0.3.3 → 0.3.4

package/dist/es/card/src/TxCard.vue2.js

@@ -1,5 +1,7 @@
-import { defineComponent, toRefs, computed, ref, onBeforeUnmount, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, createCommentVNode, createElementVNode, renderSlot, createVNode } from 'vue';
-import _sfc_main$1 from '../../spinner/src/TxSpinner.vue.js';
+import { defineComponent, toRef, ref, computed, watch, onBeforeUnmount, createElementBlock, openBlock, normalizeStyle, normalizeClass, createVNode, createCommentVNode, createElementVNode, renderSlot } from 'vue';
+import _sfc_main$1 from '../../base-surface/src/TxBaseSurface.vue.js';
+/* empty css                                      */
+import _sfc_main$2 from '../../spinner/src/TxSpinner.vue.js';
 /* empty css                               */
 
 const _hoisted_1 = {
@@ -25,7 +27,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "TxCard",
   props: {
     variant: { default: "solid" },
-    background: { default: "blur" },
+    background: { default: "pure" },
     shadow: { default: "none" },
     size: { default: "medium" },
     radius: { default: void 0 },
@@ -33,7 +35,19 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     glassBlur: { type: Boolean, default: true },
     glassBlurAmount: { default: 22 },
     glassOverlay: { type: Boolean, default: true },
-    glassOverlayOpacity: { default: 0.22 },
+    glassOverlayOpacity: { default: 0.18 },
+    maskOpacity: { default: 0.75 },
+    fallbackMaskOpacity: { default: 0.26 },
+    surfaceMoving: { type: Boolean, default: false },
+    refractionStrength: { default: 62 },
+    refractionProfile: { default: "filmic" },
+    refractionTone: { default: "vivid" },
+    refractionAngle: { default: -24 },
+    refractionLightFollowMouse: { type: Boolean, default: false },
+    refractionLightFollowIntensity: { default: 0.45 },
+    refractionLightSpring: { type: Boolean, default: true },
+    refractionLightSpringStiffness: { default: 0.18 },
+    refractionLightSpringDamping: { default: 0.84 },
     clickable: { type: Boolean, default: false },
     loading: { type: Boolean, default: false },
     loadingSpinnerSize: { default: void 0 },
@@ -46,22 +60,37 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   setup(__props, { emit: __emit }) {
     const props = __props;
     const emit = __emit;
-    const {
-      variant,
-      background,
-      shadow,
-      size,
-      clickable,
-      loading,
-      disabled,
-      inertial,
-      inertialMaxOffset,
-      inertialRebound,
-      glassBlur,
-      glassBlurAmount,
-      glassOverlay,
-      glassOverlayOpacity
-    } = toRefs(props);
+    const variant = toRef(props, "variant");
+    const background = toRef(props, "background");
+    const shadow = toRef(props, "shadow");
+    const size = toRef(props, "size");
+    const clickable = toRef(props, "clickable");
+    const loading = toRef(props, "loading");
+    const disabled = toRef(props, "disabled");
+    const inertial = toRef(props, "inertial");
+    const glassBlur = toRef(props, "glassBlur");
+    const glassBlurAmount = toRef(props, "glassBlurAmount");
+    const glassOverlay = toRef(props, "glassOverlay");
+    const glassOverlayOpacity = toRef(props, "glassOverlayOpacity");
+    const maskOpacity = toRef(props, "maskOpacity");
+    const fallbackMaskOpacity = toRef(props, "fallbackMaskOpacity");
+    const externalSurfaceMoving = toRef(props, "surfaceMoving");
+    const refractionStrength = toRef(props, "refractionStrength");
+    const refractionProfile = toRef(props, "refractionProfile");
+    const refractionTone = toRef(props, "refractionTone");
+    const refractionAngle = toRef(props, "refractionAngle");
+    const refractionLightFollowMouse = toRef(props, "refractionLightFollowMouse");
+    const refractionLightFollowIntensity = toRef(props, "refractionLightFollowIntensity");
+    const refractionLightSpring = toRef(props, "refractionLightSpring");
+    const refractionLightSpringStiffness = toRef(props, "refractionLightSpringStiffness");
+    const refractionLightSpringDamping = toRef(props, "refractionLightSpringDamping");
+    const motionX = ref(0);
+    const motionY = ref(0);
+    const surfaceMoving = ref(false);
+    const lightPointX = ref(0.5);
+    const lightPointY = ref(0.5);
+    const lightRatioX = ref(0);
+    const lightRatioY = ref(0);
     const resolvedRadius = computed(() => {
       if (typeof props.radius === "number")
         return props.radius;
@@ -81,12 +110,89 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         return props.loadingSpinnerSize;
       return 12;
     });
-    const motionX = ref(0);
-    const motionY = ref(0);
+    const surfaceMode = computed(() => {
+      return background.value;
+    });
+    const surfaceRefractionProfile = computed(() => {
+      if (background.value !== "refraction")
+        return void 0;
+      return refractionProfile.value;
+    });
+    const surfaceRefractionTone = computed(() => {
+      if (background.value !== "refraction")
+        return void 0;
+      return refractionTone.value;
+    });
+    const surfaceBlur = computed(() => {
+      if (background.value === "blur")
+        return 30;
+      if (background.value === "glass" || background.value === "refraction")
+        return glassBlur.value ? glassBlurAmount.value : 0;
+      return 0;
+    });
+    const surfaceOverlayOpacity = computed(() => {
+      if (background.value !== "glass" && background.value !== "refraction")
+        return 0;
+      return glassOverlay.value ? glassOverlayOpacity.value : 0;
+    });
+    const surfaceRefractionStrength = computed(() => {
+      if (background.value !== "refraction")
+        return void 0;
+      const baseStrength = clamp(refractionStrength.value, 0, 100);
+      if (!refractionLightFollowMouse.value) {
+        return baseStrength;
+      }
+      const intensity = clamp(refractionLightFollowIntensity.value, 0, 1);
+      const distance = clamp(Math.hypot(lightRatioX.value, lightRatioY.value), 0, 1);
+      return clamp(baseStrength + distance * 16 * intensity, 0, 100);
+    });
+    const surfaceRefractionAngle = computed(() => {
+      if (background.value !== "refraction")
+        return void 0;
+      const baseAngle = normalizeAngleDeg(refractionAngle.value);
+      if (!refractionLightFollowMouse.value) {
+        return baseAngle;
+      }
+      if (Math.abs(lightRatioX.value) < 0.01 && Math.abs(lightRatioY.value) < 0.01) {
+        return baseAngle;
+      }
+      const intensity = clamp(refractionLightFollowIntensity.value, 0, 1);
+      const pointerAngle = Math.atan2(lightRatioY.value, lightRatioX.value) * (180 / Math.PI);
+      return lerpAngleDeg(baseAngle, pointerAngle, intensity);
+    });
+    const surfaceRefractionLightX = computed(() => {
+      if (background.value !== "refraction" || !refractionLightFollowMouse.value) {
+        return void 0;
+      }
+      return lightPointX.value;
+    });
+    const surfaceRefractionLightY = computed(() => {
+      if (background.value !== "refraction" || !refractionLightFollowMouse.value) {
+        return void 0;
+      }
+      return lightPointY.value;
+    });
+    const surfaceColor = computed(() => {
+      if (background.value !== "mask")
+        return void 0;
+      return "var(--tx-card-fake-background, var(--tx-bg-color-overlay, #fff))";
+    });
+    const surfaceOpacity = computed(() => {
+      if (background.value === "mask")
+        return clamp(maskOpacity.value, 0, 1);
+      return void 0;
+    });
+    const mergedSurfaceMoving = computed(() => {
+      return surfaceMoving.value || !!externalSurfaceMoving.value;
+    });
     let targetX = 0;
     let targetY = 0;
+    let lightTargetX = 0.5;
+    let lightTargetY = 0.5;
     let velocityX = 0;
     let velocityY = 0;
+    let lightVelocityX = 0;
+    let lightVelocityY = 0;
     let lastTs = 0;
     let rafId = null;
     let isReturning = false;
@@ -96,6 +202,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     function lerp(a, b, t) {
       return a + (b - a) * t;
     }
+    function normalizeAngleDeg(angle) {
+      return ((angle + 180) % 360 + 360) % 360 - 180;
+    }
+    function lerpAngleDeg(from, to, t) {
+      const delta = normalizeAngleDeg(to - from);
+      return normalizeAngleDeg(from + delta * t);
+    }
     function stopRaf() {
       if (rafId == null)
         return;
@@ -106,27 +219,60 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       const dtRaw = lastTs ? (ts - lastTs) / 16.6667 : 1;
       lastTs = ts;
       const dt = clamp(dtRaw, 0.5, 2);
-      const rebound = clamp(props.inertialRebound, 0, 1);
-      const followStiffness = 0.085;
-      const followDamping = 0.9;
-      const returnStiffness = lerp(0.06, 0.12, rebound);
-      const returnDamping = lerp(0.96, 0.84, rebound);
-      const stiffness = isReturning ? returnStiffness : followStiffness;
-      const damping = isReturning ? returnDamping : followDamping;
-      velocityX += (targetX - motionX.value) * stiffness * dt;
-      velocityY += (targetY - motionY.value) * stiffness * dt;
-      const damp = damping ** dt;
-      velocityX *= damp;
-      velocityY *= damp;
-      motionX.value += velocityX;
-      motionY.value += velocityY;
-      const closeX = Math.abs(targetX - motionX.value) < 0.08 && Math.abs(velocityX) < 0.08;
-      const closeY = Math.abs(targetY - motionY.value) < 0.08 && Math.abs(velocityY) < 0.08;
-      if (closeX && closeY) {
-        motionX.value = targetX;
-        motionY.value = targetY;
-        velocityX = 0;
-        velocityY = 0;
+      let motionSettled = true;
+      let lightSettled = true;
+      if (props.inertial) {
+        const rebound = clamp(props.inertialRebound, 0, 1);
+        const followStiffness = 0.085;
+        const followDamping = 0.9;
+        const returnStiffness = lerp(0.06, 0.12, rebound);
+        const returnDamping = lerp(0.96, 0.84, rebound);
+        const stiffness = isReturning ? returnStiffness : followStiffness;
+        const damping = isReturning ? returnDamping : followDamping;
+        velocityX += (targetX - motionX.value) * stiffness * dt;
+        velocityY += (targetY - motionY.value) * stiffness * dt;
+        const damp = damping ** dt;
+        velocityX *= damp;
+        velocityY *= damp;
+        motionX.value += velocityX;
+        motionY.value += velocityY;
+        const closeX = Math.abs(targetX - motionX.value) < 0.08 && Math.abs(velocityX) < 0.08;
+        const closeY = Math.abs(targetY - motionY.value) < 0.08 && Math.abs(velocityY) < 0.08;
+        motionSettled = closeX && closeY;
+        if (motionSettled) {
+          motionX.value = targetX;
+          motionY.value = targetY;
+          velocityX = 0;
+          velocityY = 0;
+        }
+      }
+      if (refractionLightFollowMouse.value && background.value === "refraction") {
+        if (refractionLightSpring.value) {
+          const springStiffness = clamp(refractionLightSpringStiffness.value, 0.01, 0.55);
+          const springDamping = clamp(refractionLightSpringDamping.value, 0.55, 0.99);
+          lightVelocityX += (lightTargetX - lightPointX.value) * springStiffness * dt;
+          lightVelocityY += (lightTargetY - lightPointY.value) * springStiffness * dt;
+          const lightDamp = springDamping ** dt;
+          lightVelocityX *= lightDamp;
+          lightVelocityY *= lightDamp;
+          lightPointX.value = clamp(lightPointX.value + lightVelocityX, 0, 1);
+          lightPointY.value = clamp(lightPointY.value + lightVelocityY, 0, 1);
+        } else {
+          lightPointX.value = lightTargetX;
+          lightPointY.value = lightTargetY;
+          lightVelocityX = 0;
+          lightVelocityY = 0;
+        }
+        lightRatioX.value = clamp(lightPointX.value * 2 - 1, -1, 1);
+        lightRatioY.value = clamp(lightPointY.value * 2 - 1, -1, 1);
+        const closeLightX = Math.abs(lightTargetX - lightPointX.value) < 2e-3 && Math.abs(lightVelocityX) < 2e-3;
+        const closeLightY = Math.abs(lightTargetY - lightPointY.value) < 2e-3 && Math.abs(lightVelocityY) < 2e-3;
+        lightSettled = closeLightX && closeLightY;
+      }
+      if (motionSettled && lightSettled) {
+        if (props.inertial) {
+          surfaceMoving.value = false;
+        }
         lastTs = 0;
         rafId = null;
         return;
@@ -138,11 +284,37 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         return;
       rafId = requestAnimationFrame(tickFrame);
     }
-    function onMouseMove(ev) {
-      if (!props.inertial)
+    function updateRefractionLight(ev) {
+      if (!refractionLightFollowMouse.value)
+        return;
+      if (background.value !== "refraction")
         return;
+      const el = ev.currentTarget;
+      if (!el)
+        return;
+      const rect = el.getBoundingClientRect();
+      if (!rect.width || !rect.height)
+        return;
+      const localX = clamp(ev.clientX - rect.left, 0, rect.width);
+      const localY = clamp(ev.clientY - rect.top, 0, rect.height);
+      lightTargetX = localX / rect.width;
+      lightTargetY = localY / rect.height;
+      if (!refractionLightSpring.value) {
+        lightPointX.value = lightTargetX;
+        lightPointY.value = lightTargetY;
+        lightRatioX.value = clamp(lightPointX.value * 2 - 1, -1, 1);
+        lightRatioY.value = clamp(lightPointY.value * 2 - 1, -1, 1);
+        lightVelocityX = 0;
+        lightVelocityY = 0;
+      }
+      ensureRaf();
+    }
+    function onMouseMove(ev) {
       if (props.disabled)
         return;
+      updateRefractionLight(ev);
+      if (!props.inertial)
+        return;
       const el = ev.currentTarget;
       if (!el)
         return;
@@ -159,14 +331,29 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       const easedX = Math.sign(ratioX) * Math.abs(ratioX) ** 0.85;
       const easedY = Math.sign(ratioY) * Math.abs(ratioY) ** 0.85;
       const max = props.inertialMaxOffset;
+      surfaceMoving.value = true;
       targetX = easedX * max;
       targetY = easedY * max;
       ensureRaf();
     }
     function onMouseLeave() {
+      if (refractionLightFollowMouse.value && background.value === "refraction") {
+        lightTargetX = 0.5;
+        lightTargetY = 0.5;
+        if (!refractionLightSpring.value) {
+          lightPointX.value = 0.5;
+          lightPointY.value = 0.5;
+          lightRatioX.value = 0;
+          lightRatioY.value = 0;
+          lightVelocityX = 0;
+          lightVelocityY = 0;
+        }
+        ensureRaf();
+      }
       if (!props.inertial)
         return;
       const rebound = clamp(props.inertialRebound, 0, 1);
+      surfaceMoving.value = true;
       isReturning = true;
       velocityX *= rebound;
       velocityY *= rebound;
@@ -174,6 +361,32 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       targetY = 0;
       ensureRaf();
     }
+    function resetRefractionLightState() {
+      lightTargetX = 0.5;
+      lightTargetY = 0.5;
+      lightPointX.value = 0.5;
+      lightPointY.value = 0.5;
+      lightRatioX.value = 0;
+      lightRatioY.value = 0;
+      lightVelocityX = 0;
+      lightVelocityY = 0;
+    }
+    watch([background, refractionLightFollowMouse], ([bg, follow]) => {
+      if (bg !== "refraction" || !follow) {
+        resetRefractionLightState();
+      }
+    });
+    watch(inertial, (enabled) => {
+      if (!enabled) {
+        surfaceMoving.value = false;
+        motionX.value = 0;
+        motionY.value = 0;
+        targetX = 0;
+        targetY = 0;
+        velocityX = 0;
+        velocityY = 0;
+      }
+    });
     onBeforeUnmount(() => {
       stopRaf();
     });
@@ -187,15 +400,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("div", {
         class: normalizeClass(["tx-card", [
-          `is-${unref(variant)}`,
-          `is-bg-${unref(background)}`,
-          `is-shadow-${unref(shadow)}`,
-          `is-${unref(size)}`,
+          `is-${variant.value}`,
+          `is-bg-${background.value}`,
+          `is-shadow-${shadow.value}`,
+          `is-${size.value}`,
           {
-            "is-clickable": unref(clickable),
-            "is-loading": unref(loading),
-            "is-disabled": unref(disabled),
-            "is-inertial": unref(inertial)
+            "is-clickable": clickable.value,
+            "is-loading": loading.value,
+            "is-disabled": disabled.value,
+            "is-inertial": inertial.value
           }
         ]]),
         style: normalizeStyle({
@@ -203,13 +416,31 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           "--tx-card-padding": `${resolvedPadding.value}px`,
           "--tx-card-dx": `${motionX.value}px`,
           "--tx-card-dy": `${motionY.value}px`,
-          "--tx-card-glass-blur": `${unref(glassBlur) ? unref(glassBlurAmount) : 0}px`,
-          "--tx-card-glass-overlay-opacity": `${unref(glassOverlay) ? unref(glassOverlayOpacity) : 0}`
+          "--tx-surface-refraction-mask-color": "var(--tx-card-fake-background, var(--tx-bg-color-overlay, #fff))"
         }),
         onClick,
         onMousemove: onMouseMove,
         onMouseleave: onMouseLeave
       }, [
+        createVNode(_sfc_main$1, {
+          class: "tx-card__surface",
+          mode: surfaceMode.value,
+          preset: "card",
+          moving: mergedSurfaceMoving.value,
+          "fallback-mask-opacity": fallbackMaskOpacity.value,
+          radius: resolvedRadius.value,
+          color: surfaceColor.value,
+          opacity: surfaceOpacity.value,
+          blur: surfaceBlur.value,
+          "overlay-opacity": surfaceOverlayOpacity.value,
+          "refraction-strength": surfaceRefractionStrength.value,
+          "refraction-profile": surfaceRefractionProfile.value,
+          "refraction-tone": surfaceRefractionTone.value,
+          "refraction-angle": surfaceRefractionAngle.value,
+          "refraction-light-x": surfaceRefractionLightX.value,
+          "refraction-light-y": surfaceRefractionLightY.value,
+          "aria-hidden": "true"
+        }, null, 8, ["mode", "moving", "fallback-mask-opacity", "radius", "color", "opacity", "blur", "overlay-opacity", "refraction-strength", "refraction-profile", "refraction-tone", "refraction-angle", "refraction-light-x", "refraction-light-y"]),
         _ctx.$slots.cover ? (openBlock(), createElementBlock("div", _hoisted_1, [
           renderSlot(_ctx.$slots, "cover", {}, void 0, true)
         ])) : createCommentVNode("", true),
@@ -222,8 +453,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         _ctx.$slots.footer ? (openBlock(), createElementBlock("div", _hoisted_4, [
           renderSlot(_ctx.$slots, "footer", {}, void 0, true)
         ])) : createCommentVNode("", true),
-        unref(loading) ? (openBlock(), createElementBlock("div", _hoisted_5, [
-          createVNode(_sfc_main$1, { size: resolvedSpinnerSize.value }, null, 8, ["size"])
+        loading.value ? (openBlock(), createElementBlock("div", _hoisted_5, [
+          createVNode(_sfc_main$2, { size: resolvedSpinnerSize.value }, null, 8, ["size"])
         ])) : createCommentVNode("", true)
       ], 38);
     };

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

@@ -1,7 +1,8 @@
 export type TxCardVariant = 'solid' | 'dashed' | 'plain';
-export type TxCardBackground = 'blur' | 'glass' | 'mask';
+export type TxCardBackground = 'pure' | 'mask' | 'blur' | 'glass' | 'refraction';
 export type TxCardShadow = 'none' | 'soft' | 'medium';
 export type TxCardSize = 'small' | 'medium' | 'large';
+export type TxCardRefractionTone = 'mist' | 'balanced' | 'vivid';
 export interface TxCardProps {
     variant?: TxCardVariant;
     background?: TxCardBackground;
@@ -13,6 +14,18 @@ export interface TxCardProps {
     glassBlurAmount?: number;
     glassOverlay?: boolean;
     glassOverlayOpacity?: number;
+    maskOpacity?: number;
+    fallbackMaskOpacity?: number;
+    surfaceMoving?: boolean;
+    refractionStrength?: number;
+    refractionProfile?: 'soft' | 'filmic' | 'cinematic';
+    refractionTone?: TxCardRefractionTone;
+    refractionAngle?: number;
+    refractionLightFollowMouse?: boolean;
+    refractionLightFollowIntensity?: number;
+    refractionLightSpring?: boolean;
+    refractionLightSpringStiffness?: number;
+    refractionLightSpringDamping?: number;
     clickable?: boolean;
     loading?: boolean;
     loadingSpinnerSize?: number;

package/dist/es/card-item/index.d.ts

@@ -1,4 +1,4 @@
-import { CardItemProps } from './src/types.ts';
+import { CardItemProps } from './src/types';
 import { default as TxCardItem } from './src/TxCardItem.vue';
 
 declare const CardItem: {
@@ -36,7 +36,7 @@ declare const CardItem: {
             default: number;
         };
         avatarShape: {
-            type: import('vue').PropType<import('./src/types.ts').CardItemAvatarShape>;
+            type: import('vue').PropType<import('./src/types').CardItemAvatarShape>;
             default: string;
         };
         clickable: {
@@ -64,7 +64,7 @@ declare const CardItem: {
         avatarText: string;
         avatarUrl: string;
         avatarSize: number;
-        avatarShape: import('./src/types.ts').CardItemAvatarShape;
+        avatarShape: import('./src/types').CardItemAvatarShape;
         clickable: boolean;
         active: boolean;
         disabled: boolean;
@@ -109,7 +109,7 @@ declare const CardItem: {
             default: number;
         };
         avatarShape: {
-            type: import('vue').PropType<import('./src/types.ts').CardItemAvatarShape>;
+            type: import('vue').PropType<import('./src/types').CardItemAvatarShape>;
             default: string;
         };
         clickable: {
@@ -135,7 +135,7 @@ declare const CardItem: {
         avatarText: string;
         avatarUrl: string;
         avatarSize: number;
-        avatarShape: import('./src/types.ts').CardItemAvatarShape;
+        avatarShape: import('./src/types').CardItemAvatarShape;
         clickable: boolean;
         active: boolean;
         disabled: boolean;
@@ -177,7 +177,7 @@ declare const CardItem: {
         default: number;
     };
     avatarShape: {
-        type: import('vue').PropType<import('./src/types.ts').CardItemAvatarShape>;
+        type: import('vue').PropType<import('./src/types').CardItemAvatarShape>;
         default: string;
     };
     clickable: {
@@ -205,7 +205,7 @@ declare const CardItem: {
     avatarText: string;
     avatarUrl: string;
     avatarSize: number;
-    avatarShape: import('./src/types.ts').CardItemAvatarShape;
+    avatarShape: import('./src/types').CardItemAvatarShape;
     clickable: boolean;
     active: boolean;
     disabled: boolean;

package/dist/es/card-item/index.js

@@ -1,4 +1,4 @@
-import { withInstall } from '../utils/withInstall.js';
+import { withInstall } from '../packages/tuffex/packages/utils/withInstall.js';
 import TxCardItem from './src/TxCardItem.vue.js';
 
 const CardItem = withInstall(TxCardItem);

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

@@ -26,6 +26,10 @@ declare const Cascader: {
             type: import('vue').PropType<CascaderNode[]>;
             default: () => never[];
         };
+        multiple: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
         clearable: {
             type: import('vue').PropType<boolean>;
             default: boolean;
@@ -36,10 +40,6 @@ declare const Cascader: {
         searchDebounce: {
             type: import('vue').PropType<number>;
         };
-        multiple: {
-            type: import('vue').PropType<boolean>;
-            default: boolean;
-        };
         searchable: {
             type: import('vue').PropType<boolean>;
             default: boolean;
@@ -100,8 +100,8 @@ declare const Cascader: {
         load: (node: CascaderNode | null, level: number) => Promise<CascaderNode[]>;
         placement: import('../popover/src/types').PopoverPlacement;
         options: CascaderNode[];
-        clearable: boolean;
         multiple: boolean;
+        clearable: boolean;
         searchable: boolean;
         dropdownOffset: number;
         dropdownWidth: number;
@@ -139,6 +139,10 @@ declare const Cascader: {
             type: import('vue').PropType<CascaderNode[]>;
             default: () => never[];
         };
+        multiple: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
         clearable: {
             type: import('vue').PropType<boolean>;
             default: boolean;
@@ -149,10 +153,6 @@ declare const Cascader: {
         searchDebounce: {
             type: import('vue').PropType<number>;
         };
-        multiple: {
-            type: import('vue').PropType<boolean>;
-            default: boolean;
-        };
         searchable: {
             type: import('vue').PropType<boolean>;
             default: boolean;
@@ -207,8 +207,8 @@ declare const Cascader: {
         load: (node: CascaderNode | null, level: number) => Promise<CascaderNode[]>;
         placement: import('../popover/src/types').PopoverPlacement;
         options: CascaderNode[];
-        clearable: boolean;
         multiple: boolean;
+        clearable: boolean;
         searchable: boolean;
         dropdownOffset: number;
         dropdownWidth: number;
@@ -243,6 +243,10 @@ declare const Cascader: {
         type: import('vue').PropType<CascaderNode[]>;
         default: () => never[];
     };
+    multiple: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
     clearable: {
         type: import('vue').PropType<boolean>;
         default: boolean;
@@ -253,10 +257,6 @@ declare const Cascader: {
     searchDebounce: {
         type: import('vue').PropType<number>;
     };
-    multiple: {
-        type: import('vue').PropType<boolean>;
-        default: boolean;
-    };
     searchable: {
         type: import('vue').PropType<boolean>;
         default: boolean;
@@ -317,8 +317,8 @@ declare const Cascader: {
     load: (node: CascaderNode | null, level: number) => Promise<CascaderNode[]>;
     placement: import('../popover/src/types').PopoverPlacement;
     options: CascaderNode[];
-    clearable: boolean;
     multiple: boolean;
+    clearable: boolean;
     searchable: boolean;
     dropdownOffset: number;
     dropdownWidth: number;

package/dist/es/cascader/index.js

@@ -1,4 +1,4 @@
-import { withInstall } from '../utils/withInstall.js';
+import { withInstall } from '../packages/tuffex/packages/utils/withInstall.js';
 import TxCascader from './src/TxCascader.vue.js';
 
 const Cascader = withInstall(TxCascader);

package/dist/es/cascader/src/TxCascader.vue.d.ts

@@ -57,8 +57,8 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     load: (node: CascaderNode | null, level: number) => Promise<CascaderNode[]>;
     placement: import('../../popover/src/types').PopoverPlacement;
     options: CascaderNode[];
-    clearable: boolean;
     multiple: boolean;
+    clearable: boolean;
     searchable: boolean;
     dropdownOffset: number;
     dropdownWidth: number;

package/dist/es/cascader/src/TxCascader.vue.js

@@ -2,6 +2,6 @@ import _sfc_main from './TxCascader.vue2.js';
 /* empty css                */
 import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
 
-const TxCascader = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-c3af99ed"]]);
+const TxCascader = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-904ab1b6"]]);
 
 export { TxCascader as default };