@talex-touch/tuffex 0.3.3

package/dist/es/auto-sizer/src/TxAutoSizer.vue.js

@@ -0,0 +1,230 @@
+import { defineComponent, useAttrs, ref, computed, createBlock, openBlock, resolveDynamicComponent, mergeProps, withCtx, normalizeClass, renderSlot, nextTick } from 'vue';
+import { useAutoResize } from '../../utils/animation/auto-resize.js';
+import { useFlip } from '../../utils/animation/flip.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TxAutoSizer",
+    inheritAttrs: false
+  },
+  __name: "TxAutoSizer",
+  props: {
+    as: { default: "div" },
+    innerAs: { default: "div" },
+    width: { type: Boolean, default: true },
+    height: { type: Boolean, default: true },
+    inline: { type: Boolean, default: void 0 },
+    durationMs: { default: 200 },
+    easing: { default: "ease" },
+    outerClass: { default: "overflow-hidden" },
+    innerClass: { default: void 0 },
+    rounding: { default: "ceil" },
+    immediate: { type: Boolean, default: true },
+    rafBatch: { type: Boolean, default: true },
+    observeTarget: { default: "inner" }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const attrs = useAttrs();
+    const outer = ref(null);
+    const inner = ref(null);
+    let opSeq = 0;
+    const { refresh, measure, size, setEnabled } = useAutoResize(outer, inner, {
+      width: props.width,
+      height: props.height,
+      applyStyle: true,
+      applyMode: "auto",
+      styleTarget: "outer",
+      observeTarget: props.observeTarget,
+      rounding: props.rounding,
+      immediate: props.immediate,
+      rafBatch: props.rafBatch,
+      durationMs: props.durationMs,
+      easing: props.easing,
+      clearStyleOnFinish: true
+    });
+    const { flip: rawFlip } = useFlip(outer, {
+      mode: "size",
+      duration: props.durationMs,
+      easing: props.easing,
+      includeScale: false,
+      size: {
+        width: props.width,
+        height: props.height
+      }
+    });
+    function snapshot(el, watch) {
+      const keys = new Set(watch ?? ["rect", "box", "scroll", "class", "style", "attrs"]);
+      const rect = keys.has("rect") ? { width: el.getBoundingClientRect().width, height: el.getBoundingClientRect().height } : { width: 0, height: 0 };
+      const box = keys.has("box") ? {
+        clientWidth: el.clientWidth,
+        clientHeight: el.clientHeight,
+        offsetWidth: el.offsetWidth,
+        offsetHeight: el.offsetHeight
+      } : { clientWidth: 0, clientHeight: 0, offsetWidth: 0, offsetHeight: 0 };
+      const scroll = keys.has("scroll") ? {
+        scrollWidth: el.scrollWidth,
+        scrollHeight: el.scrollHeight
+      } : { scrollWidth: 0, scrollHeight: 0 };
+      const className = keys.has("class") ? el.className : "";
+      const style = keys.has("style") ? el.getAttribute("style") : null;
+      const attrs2 = {};
+      if (keys.has("attrs")) {
+        for (const name of el.getAttributeNames()) {
+          if (name === "style" || name === "class")
+            continue;
+          attrs2[name] = el.getAttribute(name);
+        }
+      }
+      return { rect, box, scroll, className, style, attrs: attrs2 };
+    }
+    function defaultDetect(before, after) {
+      const changedKeys = [];
+      if (before.rect.width !== after.rect.width || before.rect.height !== after.rect.height)
+        changedKeys.push("rect");
+      if (before.box.clientWidth !== after.box.clientWidth || before.box.clientHeight !== after.box.clientHeight || before.box.offsetWidth !== after.box.offsetWidth || before.box.offsetHeight !== after.box.offsetHeight) {
+        changedKeys.push("box");
+      }
+      if (before.scroll.scrollWidth !== after.scroll.scrollWidth || before.scroll.scrollHeight !== after.scroll.scrollHeight)
+        changedKeys.push("scroll");
+      if (before.className !== after.className)
+        changedKeys.push("class");
+      if (before.style !== after.style)
+        changedKeys.push("style");
+      const aKeys = Object.keys(before.attrs);
+      const bKeys = Object.keys(after.attrs);
+      if (aKeys.length !== bKeys.length) {
+        changedKeys.push("attrs");
+      } else {
+        for (const k of aKeys) {
+          if (before.attrs[k] !== after.attrs[k]) {
+            changedKeys.push("attrs");
+            break;
+          }
+        }
+      }
+      return { changedKeys, before, after };
+    }
+    function resolveOptions(optionsOrDetect) {
+      if (typeof optionsOrDetect === "function") {
+        return { watch: void 0, detect: optionsOrDetect, target: void 0 };
+      }
+      return {
+        watch: optionsOrDetect?.watch,
+        detect: optionsOrDetect?.detect,
+        target: optionsOrDetect?.target
+      };
+    }
+    function pickTarget(target) {
+      if (target === "outer")
+        return outer.value ?? inner.value;
+      return inner.value ?? outer.value;
+    }
+    async function flip(action2) {
+      const seq = ++opSeq;
+      setEnabled(false);
+      try {
+        await rawFlip(action2);
+      } finally {
+        if (seq !== opSeq)
+          return;
+        setEnabled(true);
+        await measure(true);
+      }
+    }
+    async function action(fn, optionsOrDetect) {
+      const seq = ++opSeq;
+      const { watch, detect, target } = resolveOptions(optionsOrDetect);
+      const el = pickTarget(target);
+      if (!el)
+        return { changedKeys: [] };
+      const before = snapshot(el, watch);
+      let after = null;
+      setEnabled(false);
+      try {
+        await rawFlip(async () => {
+          await fn(el);
+          await nextTick();
+          after = snapshot(el, watch);
+        });
+      } finally {
+        if (seq !== opSeq)
+          return { changedKeys: [] };
+        setEnabled(true);
+        await measure(true);
+      }
+      const resolvedAfter = after ?? snapshot(el, watch);
+      const raw = (detect ?? defaultDetect)(before, resolvedAfter);
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        return {
+          before,
+          after: resolvedAfter,
+          ...raw
+        };
+      }
+      return {
+        changedKeys: [],
+        before,
+        after: resolvedAfter,
+        result: raw
+      };
+    }
+    const inline = computed(() => {
+      if (typeof props.inline === "boolean")
+        return props.inline;
+      return props.width && !props.height;
+    });
+    const baseStyle = computed(() => {
+      return {
+        boxSizing: "border-box",
+        display: inline.value ? "inline-block" : void 0,
+        width: inline.value ? "fit-content" : void 0,
+        maxWidth: inline.value ? "100%" : void 0,
+        flex: inline.value ? "0 0 auto" : void 0
+      };
+    });
+    const mergedClass = computed(() => {
+      return [props.outerClass, attrs.class];
+    });
+    const mergedStyle = computed(() => {
+      return [baseStyle.value, attrs.style];
+    });
+    const passthroughAttrs = computed(() => {
+      const { class: _c, style: _s, ...rest } = attrs;
+      return rest;
+    });
+    __expose({
+      refresh,
+      flip,
+      action,
+      size,
+      focus: () => outer.value?.focus?.(),
+      outerEl: outer
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(__props.as), mergeProps({
+        ref_key: "outer",
+        ref: outer,
+        class: mergedClass.value,
+        style: mergedStyle.value
+      }, passthroughAttrs.value), {
+        default: withCtx(() => [
+          (openBlock(), createBlock(resolveDynamicComponent(__props.innerAs), {
+            ref_key: "inner",
+            ref: inner,
+            class: normalizeClass(__props.innerClass),
+            style: { "display": "flow-root" }
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 8, ["class"]))
+        ]),
+        _: 3
+      }, 16, ["class", "style"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/auto-sizer/src/TxAutoSizer.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from './TxAutoSizer.vue.js';
+
+
+
+export { _sfc_main as default };

package/dist/es/auto-sizer/src/types.d.ts

@@ -0,0 +1,50 @@
+import { AutoResizeRounding } from '../../../../utils/animation/auto-resize';
+
+export type AutoSizerWatchKey = 'rect' | 'box' | 'scroll' | 'class' | 'style' | 'attrs';
+export type AutoSizerActionTarget = 'inner' | 'outer';
+export type AutoSizerObserveTarget = 'inner' | 'outer' | 'both';
+export interface AutoSizerSnapshot {
+    rect: {
+        width: number;
+        height: number;
+    };
+    box: {
+        clientWidth: number;
+        clientHeight: number;
+        offsetWidth: number;
+        offsetHeight: number;
+    };
+    scroll: {
+        scrollWidth: number;
+        scrollHeight: number;
+    };
+    className: string;
+    style: string | null;
+    attrs: Record<string, string | null>;
+}
+export type AutoSizerDetect = (before: AutoSizerSnapshot, after: AutoSizerSnapshot) => any;
+export interface AutoSizerActionResult {
+    changedKeys: string[];
+    before: AutoSizerSnapshot;
+    after: AutoSizerSnapshot;
+}
+export interface AutoSizerActionOptions {
+    watch?: AutoSizerWatchKey[];
+    detect?: AutoSizerDetect;
+    target?: AutoSizerActionTarget;
+}
+export interface AutoSizerProps {
+    as?: string;
+    innerAs?: string;
+    width?: boolean;
+    height?: boolean;
+    inline?: boolean;
+    durationMs?: number;
+    easing?: string;
+    outerClass?: string;
+    innerClass?: string;
+    rounding?: AutoResizeRounding;
+    immediate?: boolean;
+    rafBatch?: boolean;
+    observeTarget?: AutoSizerObserveTarget;
+}

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

@@ -0,0 +1,187 @@
+import { AvatarEmits, AvatarGroupProps, AvatarProps, AvatarSize, AvatarStatus } from './src/types';
+import { default as TxAvatarComponent } from './src/TxAvatar.vue';
+import { default as TxAvatarGroupComponent } from './src/TxAvatarGroup.vue';
+
+declare const TxAvatar: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        name: {
+            type: import('vue').PropType<string>;
+        };
+        clickable: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        src: {
+            type: import('vue').PropType<string>;
+        };
+        alt: {
+            type: import('vue').PropType<string>;
+        };
+        icon: {
+            type: import('vue').PropType<string>;
+        };
+        size: {
+            type: import('vue').PropType<AvatarSize>;
+            default: string;
+        };
+        status: {
+            type: import('vue').PropType<AvatarStatus>;
+        };
+        shape: {
+            type: import('vue').PropType<import('./src/types').AvatarShape>;
+            default: string;
+        };
+        backgroundColor: {
+            type: import('vue').PropType<string>;
+        };
+        textColor: {
+            type: import('vue').PropType<string>;
+        };
+    }>> & Readonly<{
+        onClick?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        click: () => void;
+    }, import('vue').PublicProps, {
+        clickable: boolean;
+        size: AvatarSize;
+        shape: import('./src/types').AvatarShape;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        name: {
+            type: import('vue').PropType<string>;
+        };
+        clickable: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        src: {
+            type: import('vue').PropType<string>;
+        };
+        alt: {
+            type: import('vue').PropType<string>;
+        };
+        icon: {
+            type: import('vue').PropType<string>;
+        };
+        size: {
+            type: import('vue').PropType<AvatarSize>;
+            default: string;
+        };
+        status: {
+            type: import('vue').PropType<AvatarStatus>;
+        };
+        shape: {
+            type: import('vue').PropType<import('./src/types').AvatarShape>;
+            default: string;
+        };
+        backgroundColor: {
+            type: import('vue').PropType<string>;
+        };
+        textColor: {
+            type: import('vue').PropType<string>;
+        };
+    }>> & Readonly<{
+        onClick?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        clickable: boolean;
+        size: AvatarSize;
+        shape: import('./src/types').AvatarShape;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    name: {
+        type: import('vue').PropType<string>;
+    };
+    clickable: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    src: {
+        type: import('vue').PropType<string>;
+    };
+    alt: {
+        type: import('vue').PropType<string>;
+    };
+    icon: {
+        type: import('vue').PropType<string>;
+    };
+    size: {
+        type: import('vue').PropType<AvatarSize>;
+        default: string;
+    };
+    status: {
+        type: import('vue').PropType<AvatarStatus>;
+    };
+    shape: {
+        type: import('vue').PropType<import('./src/types').AvatarShape>;
+        default: string;
+    };
+    backgroundColor: {
+        type: import('vue').PropType<string>;
+    };
+    textColor: {
+        type: import('vue').PropType<string>;
+    };
+}>> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => void;
+}, string, {
+    clickable: boolean;
+    size: AvatarSize;
+    shape: import('./src/types').AvatarShape;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+declare const TxAvatarGroup: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        max?: number | undefined;
+        size?: AvatarSize | undefined;
+        overlap?: number | string | undefined;
+    }> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        overlap: string | number;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        max?: number | undefined;
+        size?: AvatarSize | undefined;
+        overlap?: number | string | undefined;
+    }> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, {
+        overlap: string | number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    max?: number | undefined;
+    size?: AvatarSize | undefined;
+    overlap?: number | string | undefined;
+}> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    overlap: string | number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
+export { TxAvatar, TxAvatarGroup };
+export type { AvatarEmits, AvatarGroupProps, AvatarProps, AvatarSize, AvatarStatus };
+export type TxAvatarInstance = InstanceType<typeof TxAvatarComponent>;
+export type TxAvatarGroupInstance = InstanceType<typeof TxAvatarGroupComponent>;
+export default TxAvatar;

package/dist/es/avatar/index.js

@@ -0,0 +1,8 @@
+import { withInstall } from '../utils/withInstall.js';
+import TxAvatarComponent from './src/TxAvatar.vue.js';
+import TxAvatarGroupComponent from './src/TxAvatarGroup.vue.js';
+
+const TxAvatar = withInstall(TxAvatarComponent);
+const TxAvatarGroup = withInstall(TxAvatarGroupComponent);
+
+export { TxAvatar, TxAvatarGroup, TxAvatar as default };

package/dist/es/avatar/src/TxAvatar.vue.d.ts

@@ -0,0 +1,48 @@
+import { AvatarProps } from './types';
+
+interface Props extends AvatarProps {
+}
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    size: string;
+    shape: string;
+    clickable: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    size: string;
+    shape: string;
+    clickable: boolean;
+}>>> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {
+    clickable: boolean;
+    size: import('./types').AvatarSize;
+    shape: import('./types').AvatarShape;
+}, {}, {}, {}, 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/avatar/src/TxAvatar.vue.js

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

package/dist/es/avatar/src/TxAvatar.vue2.js

@@ -0,0 +1,101 @@
+import { defineComponent, ref, computed, createElementBlock, openBlock, normalizeStyle, normalizeClass, createCommentVNode, renderSlot, createBlock, unref, toDisplayString } from 'vue';
+import { TxIcon } from '../../icon/index.js';
+
+const _hoisted_1 = ["src", "alt"];
+const _hoisted_2 = {
+  key: 1,
+  class: "tx-avatar__fallback"
+};
+const _hoisted_3 = {
+  key: 2,
+  class: "tx-avatar__text"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TxAvatar"
+  },
+  __name: "TxAvatar",
+  props: {
+    src: {},
+    alt: {},
+    name: {},
+    icon: {},
+    size: { default: "medium" },
+    status: {},
+    shape: { default: "circle" },
+    clickable: { type: Boolean, default: false },
+    backgroundColor: {},
+    textColor: {}
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const imageError = ref(false);
+    const customStyle = computed(() => {
+      if (props.backgroundColor) {
+        return {
+          "--tx-avatar-bg": props.backgroundColor,
+          "--tx-avatar-text": props.textColor || "#ffffff"
+        };
+      }
+      return {};
+    });
+    const fallbackText = computed(() => {
+      const name = props.name?.trim();
+      if (!name)
+        return "";
+      const words = name.split(" ").filter((word) => word.length > 0);
+      if (!words.length)
+        return "";
+      const first = words[0]?.charAt(0).toUpperCase() ?? "";
+      if (words.length === 1)
+        return first;
+      const last = words[words.length - 1]?.charAt(0).toUpperCase() ?? "";
+      return `${first}${last}`;
+    });
+    function handleImageError() {
+      imageError.value = true;
+    }
+    function handleClick() {
+      if (props.clickable) {
+        emit("click");
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["tx-avatar", [
+          `tx-avatar--${__props.size}`,
+          `tx-avatar--${__props.shape}`,
+          { "tx-avatar--clickable": __props.clickable }
+        ]]),
+        style: normalizeStyle(customStyle.value),
+        onClick: handleClick
+      }, [
+        __props.src && !imageError.value ? (openBlock(), createElementBlock("img", {
+          key: 0,
+          src: __props.src,
+          alt: __props.alt,
+          class: "tx-avatar__image",
+          onError: handleImageError
+        }, null, 40, _hoisted_1)) : (openBlock(), createElementBlock("div", _hoisted_2, [
+          _ctx.$slots.default ? renderSlot(_ctx.$slots, "default", { key: 0 }, void 0, true) : __props.icon ? (openBlock(), createBlock(unref(TxIcon), {
+            key: 1,
+            name: __props.icon,
+            class: "tx-avatar__icon"
+          }, null, 8, ["name"])) : fallbackText.value ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(fallbackText.value), 1)) : (openBlock(), createBlock(unref(TxIcon), {
+            key: 3,
+            name: "user",
+            class: "tx-avatar__default-icon"
+          }))
+        ])),
+        __props.status ? (openBlock(), createElementBlock("div", {
+          key: 2,
+          class: normalizeClass(["tx-avatar__status", `tx-avatar__status--${__props.status}`])
+        }, null, 2)) : createCommentVNode("", true)
+      ], 6);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/avatar/src/TxAvatarGroup.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import('vue').DefineComponent<{
+    max?: number | undefined;
+    size?: import('./types').AvatarSize | undefined;
+    overlap?: number | string | undefined;
+}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    max?: number | undefined;
+    size?: import('./types').AvatarSize | undefined;
+    overlap?: number | string | undefined;
+}> & Readonly<{}>, {
+    overlap: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/es/avatar/src/TxAvatarGroup.vue.js

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