@talex-touch/tuffex 0.3.3

package/dist/lib/agents/src/TxAgentsList.vue2.js

@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxListItemSkeleton = require('../../skeleton/src/TxListItemSkeleton.vue.js');
+const TxAgentItem = require('./TxAgentItem.vue.js');
+
+const _hoisted_1 = { class: "tx-agents-list" };
+const _hoisted_2 = {
+  key: 0,
+  class: "tx-agents-list__loading"
+};
+const _hoisted_3 = { class: "tx-agents-list__group-header" };
+const _hoisted_4 = { class: "tx-agents-list__group-title" };
+const _hoisted_5 = { class: "tx-agents-list__group-badge" };
+const _hoisted_6 = { class: "tx-agents-list__items" };
+const _hoisted_7 = {
+  key: 2,
+  class: "tx-agents-list__empty"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{
+    name: "TxAgentsList"
+  },
+  __name: "TxAgentsList",
+  props: {
+    loading: { type: Boolean, default: false },
+    agents: {},
+    selectedId: { default: null }
+  },
+  emits: ["select"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const enabledAgents = vue.computed(() => props.agents.filter((a) => !a.disabled));
+    const disabledAgents = vue.computed(() => props.agents.filter((a) => !!a.disabled));
+    const groups = vue.computed(() => {
+      const list = [];
+      if (enabledAgents.value.length) {
+        list.push({
+          id: "enabled",
+          title: "Enabled",
+          iconClass: "i-carbon-checkmark-filled",
+          items: enabledAgents.value,
+          badgeText: enabledAgents.value.length
+        });
+      }
+      if (disabledAgents.value.length) {
+        list.push({
+          id: "disabled",
+          title: "Disabled",
+          iconClass: "i-carbon-close-filled",
+          items: disabledAgents.value,
+          badgeText: disabledAgents.value.length
+        });
+      }
+      return list;
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        __props.loading ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+          vue.createVNode(TxListItemSkeleton.default),
+          vue.createVNode(TxListItemSkeleton.default),
+          vue.createVNode(TxListItemSkeleton.default),
+          vue.createVNode(TxListItemSkeleton.default)
+        ])) : __props.agents.length ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(groups.value, (group) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: group.id,
+            class: "tx-agents-list__group"
+          }, [
+            vue.createElementVNode("div", _hoisted_3, [
+              group.iconClass ? (vue.openBlock(), vue.createElementBlock("i", {
+                key: 0,
+                class: vue.normalizeClass(group.iconClass),
+                "aria-hidden": "true"
+              }, null, 2)) : vue.createCommentVNode("", true),
+              vue.createElementVNode("span", _hoisted_4, vue.toDisplayString(group.title), 1),
+              vue.createElementVNode("span", _hoisted_5, vue.toDisplayString(group.badgeText), 1)
+            ]),
+            vue.createElementVNode("div", _hoisted_6, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(group.items, (agent) => {
+                return vue.openBlock(), vue.createBlock(TxAgentItem.default, vue.mergeProps({
+                  key: agent.id
+                }, { ref_for: true }, agent, {
+                  selected: agent.id === __props.selectedId,
+                  onClick: ($event) => emit("select", agent.id)
+                }), null, 16, ["selected", "onClick"]);
+              }), 128))
+            ])
+          ]);
+        }), 128)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_7, [..._cache[0] || (_cache[0] = [
+          vue.createElementVNode("i", {
+            class: "i-carbon-bot",
+            "aria-hidden": "true"
+          }, null, -1),
+          vue.createElementVNode("div", { class: "tx-agents-list__empty-text" }, " No agents ", -1)
+        ])]))
+      ]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/alert/src/TxAlert.vue.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxAlert_vue_vue_type_script_setup_true_lang = require('./TxAlert.vue2.js');
+;/* empty css              */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxAlert = /* @__PURE__ */ _pluginVue_exportHelper.default(TxAlert_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-debd99f8"]]);
+
+exports.default = TxAlert;

package/dist/lib/alert/src/TxAlert.vue2.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const index = require('../../icon/index.js');
+
+const _hoisted_1 = {
+  key: 0,
+  class: "tx-alert__icon"
+};
+const _hoisted_2 = { class: "tx-alert__content" };
+const _hoisted_3 = {
+  key: 0,
+  class: "tx-alert__title"
+};
+const _hoisted_4 = { class: "tx-alert__message" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "TxAlert",
+  props: {
+    type: { default: "info" },
+    title: {},
+    message: {},
+    closable: { type: Boolean, default: true },
+    showIcon: { type: Boolean, default: true }
+  },
+  emits: ["close"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const iconComponent = vue.computed(() => {
+      const iconMap = {
+        success: "check-circle",
+        warning: "alert-triangle",
+        error: "x-circle",
+        info: "info"
+      };
+      return iconMap[props.type];
+    });
+    function handleClose() {
+      emit("close");
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["tx-alert", [
+          `tx-alert--${__props.type}`,
+          { "tx-alert--closable": __props.closable }
+        ]]),
+        role: "alert"
+      }, [
+        __props.showIcon ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(iconComponent.value)))
+        ])) : vue.createCommentVNode("", true),
+        vue.createElementVNode("div", _hoisted_2, [
+          __props.title ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, vue.toDisplayString(__props.title), 1)) : vue.createCommentVNode("", true),
+          vue.createElementVNode("div", _hoisted_4, [
+            vue.renderSlot(_ctx.$slots, "default", {}, () => [
+              vue.createTextVNode(vue.toDisplayString(__props.message), 1)
+            ], true)
+          ])
+        ]),
+        __props.closable ? (vue.openBlock(), vue.createElementBlock("button", {
+          key: 1,
+          class: "tx-alert__close",
+          "aria-label": "Close",
+          onClick: handleClose
+        }, [
+          vue.createVNode(vue.unref(index.TxIcon), { name: "x" })
+        ])) : vue.createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/auto-sizer/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxAutoSizer_vue_vue_type_script_setup_true_lang = require('./src/TxAutoSizer.vue.js');
+
+const AutoSizer = withInstall.withInstall(TxAutoSizer_vue_vue_type_script_setup_true_lang.default);
+
+exports.TxAutoSizer = TxAutoSizer_vue_vue_type_script_setup_true_lang.default;
+exports.AutoSizer = AutoSizer;
+exports.default = AutoSizer;

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

@@ -0,0 +1,234 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const autoResize = require('../../utils/animation/auto-resize.js');
+const flip = require('../../utils/animation/flip.js');
+
+const _sfc_main = /* @__PURE__ */ vue.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 = vue.useAttrs();
+    const outer = vue.ref(null);
+    const inner = vue.ref(null);
+    let opSeq = 0;
+    const { refresh, measure, size, setEnabled } = autoResize.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 } = flip.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$1(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 vue.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 = vue.computed(() => {
+      if (typeof props.inline === "boolean")
+        return props.inline;
+      return props.width && !props.height;
+    });
+    const baseStyle = vue.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 = vue.computed(() => {
+      return [props.outerClass, attrs.class];
+    });
+    const mergedStyle = vue.computed(() => {
+      return [baseStyle.value, attrs.style];
+    });
+    const passthroughAttrs = vue.computed(() => {
+      const { class: _c, style: _s, ...rest } = attrs;
+      return rest;
+    });
+    __expose({
+      refresh,
+      flip: flip$1,
+      action,
+      size,
+      focus: () => outer.value?.focus?.(),
+      outerEl: outer
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(__props.as), vue.mergeProps({
+        ref_key: "outer",
+        ref: outer,
+        class: mergedClass.value,
+        style: mergedStyle.value
+      }, passthroughAttrs.value), {
+        default: vue.withCtx(() => [
+          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(__props.innerAs), {
+            ref_key: "inner",
+            ref: inner,
+            class: vue.normalizeClass(__props.innerClass),
+            style: { "display": "flow-root" }
+          }, {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 8, ["class"]))
+        ]),
+        _: 3
+      }, 16, ["class", "style"]);
+    };
+  }
+});
+
+exports.default = _sfc_main;

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

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxAutoSizer_vue_vue_type_script_setup_true_lang = require('./TxAutoSizer.vue.js');
+
+
+
+exports.default = TxAutoSizer_vue_vue_type_script_setup_true_lang.default;

package/dist/lib/avatar/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const withInstall = require('../utils/withInstall.js');
+const TxAvatar$1 = require('./src/TxAvatar.vue.js');
+const TxAvatarGroup$1 = require('./src/TxAvatarGroup.vue.js');
+
+const TxAvatar = withInstall.withInstall(TxAvatar$1.default);
+const TxAvatarGroup = withInstall.withInstall(TxAvatarGroup$1.default);
+
+exports.TxAvatar = TxAvatar;
+exports.TxAvatarGroup = TxAvatarGroup;
+exports.default = TxAvatar;

package/dist/lib/avatar/src/TxAvatar.vue.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxAvatar_vue_vue_type_script_setup_true_lang = require('./TxAvatar.vue2.js');
+;/* empty css               */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxAvatarComponent = /* @__PURE__ */ _pluginVue_exportHelper.default(TxAvatar_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-2027ad14"]]);
+
+exports.default = TxAvatarComponent;

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

@@ -0,0 +1,105 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const index = require('../../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__ */ vue.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 = vue.ref(false);
+    const customStyle = vue.computed(() => {
+      if (props.backgroundColor) {
+        return {
+          "--tx-avatar-bg": props.backgroundColor,
+          "--tx-avatar-text": props.textColor || "#ffffff"
+        };
+      }
+      return {};
+    });
+    const fallbackText = vue.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 vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["tx-avatar", [
+          `tx-avatar--${__props.size}`,
+          `tx-avatar--${__props.shape}`,
+          { "tx-avatar--clickable": __props.clickable }
+        ]]),
+        style: vue.normalizeStyle(customStyle.value),
+        onClick: handleClick
+      }, [
+        __props.src && !imageError.value ? (vue.openBlock(), vue.createElementBlock("img", {
+          key: 0,
+          src: __props.src,
+          alt: __props.alt,
+          class: "tx-avatar__image",
+          onError: handleImageError
+        }, null, 40, _hoisted_1)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+          _ctx.$slots.default ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }, void 0, true) : __props.icon ? (vue.openBlock(), vue.createBlock(vue.unref(index.TxIcon), {
+            key: 1,
+            name: __props.icon,
+            class: "tx-avatar__icon"
+          }, null, 8, ["name"])) : fallbackText.value ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_3, vue.toDisplayString(fallbackText.value), 1)) : (vue.openBlock(), vue.createBlock(vue.unref(index.TxIcon), {
+            key: 3,
+            name: "user",
+            class: "tx-avatar__default-icon"
+          }))
+        ])),
+        __props.status ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 2,
+          class: vue.normalizeClass(["tx-avatar__status", `tx-avatar__status--${__props.status}`])
+        }, null, 2)) : vue.createCommentVNode("", true)
+      ], 6);
+    };
+  }
+});
+
+exports.default = _sfc_main;

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

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxAvatarGroup_vue_vue_type_script_lang = require('./TxAvatarGroup.vue2.js');
+;/* empty css                    */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxAvatarGroupComponent = /* @__PURE__ */ _pluginVue_exportHelper.default(TxAvatarGroup_vue_vue_type_script_lang.default, [["__scopeId", "data-v-afc38b28"]]);
+
+exports.default = TxAvatarGroupComponent;

package/dist/lib/avatar/src/TxAvatarGroup.vue2.js

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const vue = require('vue');
+const TxAvatar = require('./TxAvatar.vue.js');
+
+const _sfc_main = vue.defineComponent({
+  name: "TxAvatarGroup",
+  props: {
+    max: { type: Number, required: false },
+    size: { type: String, required: false },
+    overlap: { type: [Number, String], default: 8 }
+  },
+  setup(props, { slots }) {
+    const overlapPx = vue.computed(() => {
+      return typeof props.overlap === "number" ? `${props.overlap}px` : props.overlap;
+    });
+    return () => {
+      const nodes = (slots.default?.() ?? []).filter((n) => vue.isVNode(n));
+      const maxVisible = typeof props.max === "number" ? Math.max(0, props.max) : nodes.length;
+      const extraCount = typeof props.max === "number" ? Math.max(0, nodes.length - maxVisible) : 0;
+      const visible = nodes.slice(0, maxVisible);
+      const children = visible.map((vnode, index) => {
+        const rawProps = vnode.props ?? {};
+        const className = rawProps.class;
+        const style = rawProps.style;
+        const mergedStyle = index === 0 ? [style, { zIndex: 1 }] : [style, { marginLeft: `calc(${overlapPx.value} * -1)`, zIndex: index + 1 }];
+        const injectedProps = {
+          class: [className, "tx-avatar-group__item"],
+          style: mergedStyle
+        };
+        if (props.size && rawProps.size == null) {
+          injectedProps.size = props.size;
+        }
+        return vue.cloneVNode(vnode, injectedProps);
+      });
+      if (extraCount > 0) {
+        const index = children.length;
+        children.push(
+          vue.h(
+            TxAvatar.default,
+            {
+              size: props.size,
+              class: ["tx-avatar-group__item", "tx-avatar-group__more"],
+              style: index === 0 ? [{ zIndex: 1 }] : [{ marginLeft: `calc(${overlapPx.value} * -1)`, zIndex: index + 1 }]
+            },
+            {
+              default: () => `+${extraCount}`
+            }
+          )
+        );
+      }
+      return vue.h(
+        "div",
+        {
+          class: "tx-avatar-group",
+          style: {
+            "--tx-avatar-group-overlap": overlapPx.value
+          }
+        },
+        children
+      );
+    };
+  }
+});
+
+exports.default = _sfc_main;

package/dist/lib/badge/src/TxBadge.vue.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const TxBadge_vue_vue_type_script_setup_true_lang = require('./TxBadge.vue2.js');
+;/* empty css              */
+const _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const TxBadge = /* @__PURE__ */ _pluginVue_exportHelper.default(TxBadge_vue_vue_type_script_setup_true_lang.default, [["__scopeId", "data-v-8f173120"]]);
+
+exports.default = TxBadge;