@talex-touch/tuffex 0.3.3

package/dist/es/card/src/TxCard.vue.d.ts

@@ -0,0 +1,91 @@
+import { TxCardProps } from './types';
+
+declare function __VLS_template(): {
+    cover?(_: {}): any;
+    header?(_: {}): any;
+    default?(_: {}): any;
+    footer?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TxCardProps>, {
+    variant: string;
+    background: string;
+    shadow: string;
+    size: string;
+    glassBlur: boolean;
+    glassBlurAmount: number;
+    glassOverlay: boolean;
+    glassOverlayOpacity: number;
+    clickable: boolean;
+    loading: boolean;
+    disabled: boolean;
+    radius: undefined;
+    padding: undefined;
+    loadingSpinnerSize: undefined;
+    inertial: boolean;
+    inertialMaxOffset: number;
+    inertialRebound: number;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (ev: MouseEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TxCardProps>, {
+    variant: string;
+    background: string;
+    shadow: string;
+    size: string;
+    glassBlur: boolean;
+    glassBlurAmount: number;
+    glassOverlay: boolean;
+    glassOverlayOpacity: number;
+    clickable: boolean;
+    loading: boolean;
+    disabled: boolean;
+    radius: undefined;
+    padding: undefined;
+    loadingSpinnerSize: undefined;
+    inertial: boolean;
+    inertialMaxOffset: number;
+    inertialRebound: number;
+}>>> & Readonly<{
+    onClick?: ((ev: MouseEvent) => any) | undefined;
+}>, {
+    clickable: boolean;
+    disabled: boolean;
+    loading: boolean;
+    size: import('./types').TxCardSize;
+    variant: import('./types').TxCardVariant;
+    background: import('./types').TxCardBackground;
+    shadow: import('./types').TxCardShadow;
+    radius: number;
+    padding: number;
+    glassBlur: boolean;
+    glassBlurAmount: number;
+    glassOverlay: boolean;
+    glassOverlayOpacity: number;
+    loadingSpinnerSize: number;
+    inertial: boolean;
+    inertialMaxOffset: number;
+    inertialRebound: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,7 @@
+import _sfc_main from './TxCard.vue2.js';
+/* empty css            */
+import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
+
+const TxCard = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-cde4b58a"]]);
+
+export { TxCard as default };

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

@@ -0,0 +1,233 @@
+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';
+/* empty css                               */
+
+const _hoisted_1 = {
+  key: 0,
+  class: "tx-card__cover"
+};
+const _hoisted_2 = {
+  key: 1,
+  class: "tx-card__header"
+};
+const _hoisted_3 = { class: "tx-card__body" };
+const _hoisted_4 = {
+  key: 2,
+  class: "tx-card__footer"
+};
+const _hoisted_5 = {
+  key: 3,
+  class: "tx-card__loading",
+  "aria-hidden": "true"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "TxCard" },
+  __name: "TxCard",
+  props: {
+    variant: { default: "solid" },
+    background: { default: "blur" },
+    shadow: { default: "none" },
+    size: { default: "medium" },
+    radius: { default: void 0 },
+    padding: { default: void 0 },
+    glassBlur: { type: Boolean, default: true },
+    glassBlurAmount: { default: 22 },
+    glassOverlay: { type: Boolean, default: true },
+    glassOverlayOpacity: { default: 0.22 },
+    clickable: { type: Boolean, default: false },
+    loading: { type: Boolean, default: false },
+    loadingSpinnerSize: { default: void 0 },
+    disabled: { type: Boolean, default: false },
+    inertial: { type: Boolean, default: false },
+    inertialMaxOffset: { default: 22 },
+    inertialRebound: { default: 0.12 }
+  },
+  emits: ["click"],
+  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 resolvedRadius = computed(() => {
+      if (typeof props.radius === "number")
+        return props.radius;
+      return 18;
+    });
+    const resolvedPadding = computed(() => {
+      if (typeof props.padding === "number")
+        return props.padding;
+      if (props.size === "small")
+        return 10;
+      if (props.size === "large")
+        return 16;
+      return 12;
+    });
+    const resolvedSpinnerSize = computed(() => {
+      if (typeof props.loadingSpinnerSize === "number")
+        return props.loadingSpinnerSize;
+      return 12;
+    });
+    const motionX = ref(0);
+    const motionY = ref(0);
+    let targetX = 0;
+    let targetY = 0;
+    let velocityX = 0;
+    let velocityY = 0;
+    let lastTs = 0;
+    let rafId = null;
+    let isReturning = false;
+    function clamp(n, min, max) {
+      return Math.max(min, Math.min(max, n));
+    }
+    function lerp(a, b, t) {
+      return a + (b - a) * t;
+    }
+    function stopRaf() {
+      if (rafId == null)
+        return;
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+    function tickFrame(ts) {
+      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;
+        lastTs = 0;
+        rafId = null;
+        return;
+      }
+      rafId = requestAnimationFrame(tickFrame);
+    }
+    function ensureRaf() {
+      if (rafId != null)
+        return;
+      rafId = requestAnimationFrame(tickFrame);
+    }
+    function onMouseMove(ev) {
+      if (!props.inertial)
+        return;
+      if (props.disabled)
+        return;
+      const el = ev.currentTarget;
+      if (!el)
+        return;
+      isReturning = false;
+      const rect = el.getBoundingClientRect();
+      const halfW = rect.width / 2;
+      const halfH = rect.height / 2;
+      if (halfW <= 0 || halfH <= 0)
+        return;
+      const dx = ev.clientX - rect.left - halfW;
+      const dy = ev.clientY - rect.top - halfH;
+      const ratioX = clamp(dx / halfW, -1, 1);
+      const ratioY = clamp(dy / halfH, -1, 1);
+      const easedX = Math.sign(ratioX) * Math.abs(ratioX) ** 0.85;
+      const easedY = Math.sign(ratioY) * Math.abs(ratioY) ** 0.85;
+      const max = props.inertialMaxOffset;
+      targetX = easedX * max;
+      targetY = easedY * max;
+      ensureRaf();
+    }
+    function onMouseLeave() {
+      if (!props.inertial)
+        return;
+      const rebound = clamp(props.inertialRebound, 0, 1);
+      isReturning = true;
+      velocityX *= rebound;
+      velocityY *= rebound;
+      targetX = 0;
+      targetY = 0;
+      ensureRaf();
+    }
+    onBeforeUnmount(() => {
+      stopRaf();
+    });
+    function onClick(ev) {
+      if (props.disabled)
+        return;
+      if (!props.clickable)
+        return;
+      emit("click", ev);
+    }
+    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-clickable": unref(clickable),
+            "is-loading": unref(loading),
+            "is-disabled": unref(disabled),
+            "is-inertial": unref(inertial)
+          }
+        ]]),
+        style: normalizeStyle({
+          "--tx-card-radius": `${resolvedRadius.value}px`,
+          "--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}`
+        }),
+        onClick,
+        onMousemove: onMouseMove,
+        onMouseleave: onMouseLeave
+      }, [
+        _ctx.$slots.cover ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          renderSlot(_ctx.$slots, "cover", {}, void 0, true)
+        ])) : createCommentVNode("", true),
+        _ctx.$slots.header ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          renderSlot(_ctx.$slots, "header", {}, void 0, true)
+        ])) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_3, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _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"])
+        ])) : createCommentVNode("", true)
+      ], 38);
+    };
+  }
+});
+
+export { _sfc_main as default };

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

@@ -0,0 +1,23 @@
+export type TxCardVariant = 'solid' | 'dashed' | 'plain';
+export type TxCardBackground = 'blur' | 'glass' | 'mask';
+export type TxCardShadow = 'none' | 'soft' | 'medium';
+export type TxCardSize = 'small' | 'medium' | 'large';
+export interface TxCardProps {
+    variant?: TxCardVariant;
+    background?: TxCardBackground;
+    shadow?: TxCardShadow;
+    size?: TxCardSize;
+    radius?: number;
+    padding?: number;
+    glassBlur?: boolean;
+    glassBlurAmount?: number;
+    glassOverlay?: boolean;
+    glassOverlayOpacity?: number;
+    clickable?: boolean;
+    loading?: boolean;
+    loadingSpinnerSize?: number;
+    disabled?: boolean;
+    inertial?: boolean;
+    inertialMaxOffset?: number;
+    inertialRebound?: number;
+}

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

@@ -0,0 +1,224 @@
+import { CardItemProps } from './src/types.ts';
+import { default as TxCardItem } from './src/TxCardItem.vue';
+
+declare const CardItem: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        role: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        title: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        subtitle: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        description: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        iconClass: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        avatarText: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        avatarUrl: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        avatarSize: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        avatarShape: {
+            type: import('vue').PropType<import('./src/types.ts').CardItemAvatarShape>;
+            default: string;
+        };
+        clickable: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        active: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        click: (event: MouseEvent) => void;
+    }, import('vue').PublicProps, {
+        role: string;
+        title: string;
+        subtitle: string;
+        description: string;
+        iconClass: string;
+        avatarText: string;
+        avatarUrl: string;
+        avatarSize: number;
+        avatarShape: import('./src/types.ts').CardItemAvatarShape;
+        clickable: boolean;
+        active: boolean;
+        disabled: boolean;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        role: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        title: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        subtitle: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        description: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        iconClass: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        avatarText: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        avatarUrl: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        avatarSize: {
+            type: import('vue').PropType<number>;
+            default: number;
+        };
+        avatarShape: {
+            type: import('vue').PropType<import('./src/types.ts').CardItemAvatarShape>;
+            default: string;
+        };
+        clickable: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        active: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onClick?: ((event: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        role: string;
+        title: string;
+        subtitle: string;
+        description: string;
+        iconClass: string;
+        avatarText: string;
+        avatarUrl: string;
+        avatarSize: number;
+        avatarShape: import('./src/types.ts').CardItemAvatarShape;
+        clickable: boolean;
+        active: boolean;
+        disabled: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    role: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    title: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    subtitle: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    description: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    iconClass: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    avatarText: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    avatarUrl: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    avatarSize: {
+        type: import('vue').PropType<number>;
+        default: number;
+    };
+    avatarShape: {
+        type: import('vue').PropType<import('./src/types.ts').CardItemAvatarShape>;
+        default: string;
+    };
+    clickable: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    active: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    disabled: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => void;
+}, string, {
+    role: string;
+    title: string;
+    subtitle: string;
+    description: string;
+    iconClass: string;
+    avatarText: string;
+    avatarUrl: string;
+    avatarSize: number;
+    avatarShape: import('./src/types.ts').CardItemAvatarShape;
+    clickable: boolean;
+    active: boolean;
+    disabled: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        avatar?(_: {}): any;
+        title?(_: {}): any;
+        subtitle?(_: {}): any;
+        right?(_: {}): any;
+        description?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export { CardItem, TxCardItem };
+export type { CardItemProps };
+export type TxCardItemInstance = InstanceType<typeof TxCardItem>;
+export default CardItem;

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

@@ -0,0 +1,6 @@
+import { withInstall } from '../utils/withInstall.js';
+import TxCardItem from './src/TxCardItem.vue.js';
+
+const CardItem = withInstall(TxCardItem);
+
+export { CardItem, TxCardItem, CardItem as default };

package/dist/es/card-item/src/TxCardItem.vue.d.ts

@@ -0,0 +1,77 @@
+import { CardItemProps } from './types.ts';
+
+declare function __VLS_template(): {
+    avatar?(_: {}): any;
+    title?(_: {}): any;
+    subtitle?(_: {}): any;
+    right?(_: {}): any;
+    description?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CardItemProps>, {
+    role: string;
+    title: string;
+    subtitle: string;
+    description: string;
+    iconClass: string;
+    avatarText: string;
+    avatarUrl: string;
+    avatarSize: number;
+    avatarShape: string;
+    clickable: boolean;
+    active: boolean;
+    disabled: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CardItemProps>, {
+    role: string;
+    title: string;
+    subtitle: string;
+    description: string;
+    iconClass: string;
+    avatarText: string;
+    avatarUrl: string;
+    avatarSize: number;
+    avatarShape: string;
+    clickable: boolean;
+    active: boolean;
+    disabled: boolean;
+}>>> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    role: string;
+    title: string;
+    subtitle: string;
+    description: string;
+    iconClass: string;
+    avatarText: string;
+    avatarUrl: string;
+    avatarSize: number;
+    avatarShape: import('./types.ts').CardItemAvatarShape;
+    clickable: boolean;
+    active: boolean;
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/es/card-item/src/TxCardItem.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from './TxCardItem.vue2.js';
+/* empty css                */
+import _export_sfc from '../../_virtual/_plugin-vue_export-helper.js';
+
+const TxCardItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-fde23e3f"]]);
+
+export { TxCardItem as default };