@talex-touch/tuffex 0.3.3

package/dist/es/chat/src/TxTypingIndicator.vue2.js

@@ -0,0 +1,148 @@
+import { defineComponent, useId, computed, createElementBlock, openBlock, createCommentVNode, normalizeStyle, createElementVNode, createStaticVNode, toDisplayString } from 'vue';
+
+const _hoisted_1 = {
+  class: "tx-typing-indicator",
+  role: "status",
+  "aria-live": "polite"
+};
+const _hoisted_2 = { class: "tx-typing-indicator__ai" };
+const _hoisted_3 = {
+  key: 6,
+  class: "tx-typing-indicator__text"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TxTypingIndicator"
+  },
+  __name: "TxTypingIndicator",
+  props: {
+    variant: { default: "dots" },
+    text: { default: "Typing…" },
+    showText: { type: Boolean, default: true },
+    size: { default: 6 },
+    gap: { default: 5 },
+    loaderSize: { default: 44 },
+    pureSize: { default: 14 },
+    ringSize: { default: 18 },
+    ringThickness: { default: 2 },
+    circleDashSize: { default: 18 },
+    circleDashThickness: { default: 2 },
+    circleDashDashDeg: { default: 12 },
+    circleDashGapDeg: { default: 12 },
+    barsSize: { default: 12 }
+  },
+  setup(__props) {
+    const props = __props;
+    const uid = useId();
+    const maskId = `tx-typing-indicator-mask-${uid}`;
+    const normalizedVariant = computed(() => props.variant ?? "dots");
+    const dotStyle = computed(() => ({
+      width: `${props.size}px`,
+      height: `${props.size}px`
+    }));
+    const dotsStyle = computed(() => ({
+      gap: `${props.gap}px`
+    }));
+    const aiWrapStyle = computed(() => ({
+      "--tx-typing-ai-size": `${props.loaderSize ?? 44}px`,
+      "--tx-typing-ai-scale": String((props.loaderSize ?? 44) / 100)
+    }));
+    const aiBoxMaskStyle = computed(() => ({
+      mask: `url(#${maskId})`,
+      WebkitMask: `url(#${maskId})`
+    }));
+    const pureStyle = computed(() => ({
+      "--tx-typing-pure-size": `${props.pureSize ?? 14}px`
+    }));
+    const ringStyle = computed(() => ({
+      "--tx-typing-ring-size": `${props.ringSize ?? 18}px`,
+      "--tx-typing-ring-thickness": `${props.ringThickness ?? 2}px`
+    }));
+    const barsStyle = computed(() => ({
+      "--tx-typing-bars-size": `${props.barsSize ?? 12}px`
+    }));
+    const circleDashStyle = computed(() => ({
+      "--tx-typing-circle-dash-size": `${props.circleDashSize ?? 18}px`,
+      "--tx-typing-circle-dash-thickness": `${props.circleDashThickness ?? 2}px`,
+      "--tx-typing-circle-dash-deg": `${props.circleDashDashDeg ?? 12}deg`,
+      "--tx-typing-circle-gap-deg": `${props.circleDashGapDeg ?? 12}deg`
+    }));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        normalizedVariant.value === "ai" ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: "tx-typing-indicator__ai-wrap",
+          style: normalizeStyle(aiWrapStyle.value),
+          "aria-hidden": "true"
+        }, [
+          createElementVNode("div", _hoisted_2, [
+            createElementVNode("svg", {
+              class: "tx-typing-indicator__ai-svg",
+              width: "100",
+              height: "100",
+              viewBox: "0 0 100 100"
+            }, [
+              createElementVNode("defs", null, [
+                createElementVNode("mask", {
+                  id: maskId,
+                  class: "tx-typing-indicator__ai-mask"
+                }, [..._cache[0] || (_cache[0] = [
+                  createStaticVNode('<polygon points="0,0 100,0 100,100 0,100" fill="black" data-v-4366ee81></polygon><polygon points="25,25 75,25 50,75" fill="white" data-v-4366ee81></polygon><polygon points="50,25 75,75 25,75" fill="white" data-v-4366ee81></polygon><polygon points="35,35 65,35 50,65" fill="white" data-v-4366ee81></polygon><polygon points="35,35 65,35 50,65" fill="white" data-v-4366ee81></polygon><polygon points="35,35 65,35 50,65" fill="white" data-v-4366ee81></polygon><polygon points="35,35 65,35 50,65" fill="white" data-v-4366ee81></polygon>', 7)
+                ])])
+              ])
+            ]),
+            createElementVNode("div", {
+              class: "tx-typing-indicator__ai-box",
+              style: normalizeStyle(aiBoxMaskStyle.value)
+            }, null, 4)
+          ])
+        ], 4)) : normalizedVariant.value === "pure" ? (openBlock(), createElementBlock("div", {
+          key: 1,
+          class: "tx-typing-indicator__pure",
+          style: normalizeStyle(pureStyle.value),
+          "aria-hidden": "true"
+        }, null, 4)) : normalizedVariant.value === "ring" ? (openBlock(), createElementBlock("div", {
+          key: 2,
+          class: "tx-typing-indicator__ring",
+          style: normalizeStyle(ringStyle.value),
+          "aria-hidden": "true"
+        }, null, 4)) : normalizedVariant.value === "circle-dash" ? (openBlock(), createElementBlock("div", {
+          key: 3,
+          class: "tx-typing-indicator__circle-dash",
+          style: normalizeStyle(circleDashStyle.value),
+          "aria-hidden": "true"
+        }, null, 4)) : normalizedVariant.value === "bars" ? (openBlock(), createElementBlock("div", {
+          key: 4,
+          class: "tx-typing-indicator__bars",
+          style: normalizeStyle(barsStyle.value),
+          "aria-hidden": "true"
+        }, [..._cache[1] || (_cache[1] = [
+          createElementVNode("span", { class: "tx-typing-indicator__bar" }, null, -1),
+          createElementVNode("span", { class: "tx-typing-indicator__bar" }, null, -1),
+          createElementVNode("span", { class: "tx-typing-indicator__bar" }, null, -1)
+        ])], 4)) : (openBlock(), createElementBlock("div", {
+          key: 5,
+          class: "tx-typing-indicator__dots",
+          style: normalizeStyle(dotsStyle.value),
+          "aria-hidden": "true"
+        }, [
+          createElementVNode("span", {
+            class: "tx-typing-indicator__dot",
+            style: normalizeStyle(dotStyle.value)
+          }, null, 4),
+          createElementVNode("span", {
+            class: "tx-typing-indicator__dot",
+            style: normalizeStyle(dotStyle.value)
+          }, null, 4),
+          createElementVNode("span", {
+            class: "tx-typing-indicator__dot",
+            style: normalizeStyle(dotStyle.value)
+          }, null, 4)
+        ], 4)),
+        __props.showText ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(__props.text), 1)) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

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

@@ -0,0 +1,65 @@
+export type ChatMessageRole = 'user' | 'assistant' | 'system';
+export interface ChatMessageAttachmentImage {
+    type: 'image';
+    url: string;
+    name?: string;
+}
+export type ChatMessageAttachment = ChatMessageAttachmentImage;
+export interface ChatMessageModel {
+    id: string;
+    role: ChatMessageRole;
+    content: string;
+    createdAt?: number;
+    avatarUrl?: string;
+    attachments?: ChatMessageAttachment[];
+}
+export interface ChatMessageProps {
+    message: ChatMessageModel;
+    markdown?: boolean;
+}
+export interface ChatMessageEmits {
+    (e: 'imageClick', payload: {
+        url: string;
+        name?: string;
+        messageId: string;
+    }): void;
+}
+export interface ChatListProps {
+    messages: ChatMessageModel[];
+    markdown?: boolean;
+    stagger?: boolean;
+}
+export interface ChatComposerProps {
+    modelValue?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    submitting?: boolean;
+    minRows?: number;
+    maxRows?: number;
+    sendOnEnter?: boolean;
+    sendOnMetaEnter?: boolean;
+}
+export interface ChatComposerEmits {
+    (e: 'update:modelValue', value: string): void;
+    (e: 'send', payload: {
+        text: string;
+    }): void;
+    (e: 'focus', event: FocusEvent): void;
+    (e: 'blur', event: FocusEvent): void;
+}
+export interface TypingIndicatorProps {
+    variant?: 'dots' | 'ai' | 'pure' | 'ring' | 'circle-dash' | 'bars';
+    text?: string;
+    showText?: boolean;
+    size?: number;
+    gap?: number;
+    loaderSize?: number;
+    pureSize?: number;
+    ringSize?: number;
+    ringThickness?: number;
+    circleDashSize?: number;
+    circleDashThickness?: number;
+    circleDashDashDeg?: number;
+    circleDashGapDeg?: number;
+    barsSize?: number;
+}

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

@@ -0,0 +1,5 @@
+import { default as TuffCheckbox } from './src/TxCheckbox.vue';
+
+export { TuffCheckbox };
+export { TuffCheckbox as TxCheckbox };
+export default TuffCheckbox;

package/dist/es/checkbox/index.js

@@ -0,0 +1,7 @@
+import TxCheckbox from './src/TxCheckbox.vue.js';
+
+TxCheckbox.install = (app) => {
+  app.component(TxCheckbox.name || "TuffCheckbox", TxCheckbox);
+};
+
+export { TxCheckbox as TuffCheckbox, TxCheckbox, TxCheckbox as default };

package/dist/es/checkbox/src/TxCheckbox.vue.d.ts

@@ -0,0 +1,58 @@
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    modelValue?: boolean;
+    disabled?: boolean;
+    label?: string;
+    labelPlacement?: "start" | "end";
+    ariaLabel?: string;
+}>, {
+    modelValue: boolean;
+    disabled: boolean;
+    labelPlacement: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: boolean) => void;
+    "update:modelValue": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    modelValue?: boolean;
+    disabled?: boolean;
+    label?: string;
+    labelPlacement?: "start" | "end";
+    ariaLabel?: string;
+}>, {
+    modelValue: boolean;
+    disabled: boolean;
+    labelPlacement: string;
+}>>> & Readonly<{
+    onChange?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: boolean;
+    labelPlacement: "start" | "end";
+}, {}, {}, {}, 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/checkbox/src/TxCheckbox.vue.js

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

package/dist/es/checkbox/src/TxCheckbox.vue2.js

@@ -0,0 +1,98 @@
+import { defineComponent, computed, useSlots, createElementBlock, openBlock, withKeys, normalizeClass, withModifiers, createCommentVNode, createElementVNode, renderSlot, createTextVNode, toDisplayString } from 'vue';
+
+const _hoisted_1 = ["aria-checked", "aria-disabled", "aria-label", "tabindex", "onKeydown"];
+const _hoisted_2 = {
+  key: 0,
+  class: "tx-checkbox__label"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "tx-checkbox__label"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TxCheckbox"
+  },
+  __name: "TxCheckbox",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    label: {},
+    labelPlacement: { default: "end" },
+    ariaLabel: {}
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const isChecked = computed({
+      get: () => props.modelValue,
+      set: (val) => {
+        emit("update:modelValue", val);
+        emit("change", val);
+      }
+    });
+    const hasLabel = computed(() => Boolean(props.label) || Boolean(useSlots().default));
+    const effectiveAriaLabel = computed(() => {
+      if (hasLabel.value)
+        return void 0;
+      return props.ariaLabel;
+    });
+    function toggle() {
+      if (props.disabled)
+        return;
+      isChecked.value = !isChecked.value;
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        role: "checkbox",
+        "aria-checked": isChecked.value,
+        "aria-disabled": __props.disabled,
+        "aria-label": effectiveAriaLabel.value,
+        tabindex: __props.disabled ? -1 : 0,
+        class: normalizeClass(["tx-checkbox", [
+          {
+            "is-checked": isChecked.value,
+            "is-disabled": __props.disabled
+          }
+        ]]),
+        onClick: toggle,
+        onKeydown: [
+          withKeys(withModifiers(toggle, ["prevent"]), ["enter"]),
+          withKeys(withModifiers(toggle, ["prevent"]), ["space"])
+        ]
+      }, [
+        (__props.label || _ctx.$slots.default) && __props.labelPlacement === "start" ? (openBlock(), createElementBlock("span", _hoisted_2, [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            createTextVNode(toDisplayString(__props.label), 1)
+          ], true)
+        ])) : createCommentVNode("", true),
+        _cache[0] || (_cache[0] = createElementVNode("span", {
+          class: "tx-checkbox__box",
+          "aria-hidden": "true"
+        }, [
+          createElementVNode("svg", {
+            viewBox: "0 0 400 400",
+            xmlns: "http://www.w3.org/2000/svg"
+          }, [
+            createElementVNode("polyline", {
+              fill: "none",
+              "stroke-width": "24",
+              points: "88,214 173,284 304,138",
+              "stroke-linecap": "round",
+              "stroke-linejoin": "round",
+              class: "tx-checkbox__tick"
+            })
+          ])
+        ], -1)),
+        (__props.label || _ctx.$slots.default) && __props.labelPlacement === "end" ? (openBlock(), createElementBlock("span", _hoisted_3, [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            createTextVNode(toDisplayString(__props.label), 1)
+          ], true)
+        ])) : createCommentVNode("", true)
+      ], 42, _hoisted_1);
+    };
+  }
+});
+
+export { _sfc_main as default };

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

@@ -0,0 +1 @@
+export * from './src';

package/dist/es/collapse/src/TxCollapse.vue.d.ts

@@ -0,0 +1,44 @@
+interface Props {
+    accordion?: boolean;
+    modelValue?: string | string[];
+}
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    accordion: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: string | string[]) => void;
+    "update:modelValue": (value: string | string[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    accordion: boolean;
+}>>> & Readonly<{
+    onChange?: ((value: string | string[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+}>, {
+    accordion: 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/collapse/src/TxCollapse.vue.js

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

package/dist/es/collapse/src/TxCollapse.vue2.js

@@ -0,0 +1,71 @@
+import { defineComponent, ref, watch, provide, createElementBlock, openBlock, renderSlot } from 'vue';
+
+const _hoisted_1 = { class: "tx-collapse" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TxCollapse",
+  props: {
+    accordion: { type: Boolean, default: false },
+    modelValue: {}
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const activeNames = ref([]);
+    if (props.modelValue) {
+      activeNames.value = Array.isArray(props.modelValue) ? props.modelValue : [props.modelValue];
+    }
+    watch(() => props.modelValue, (newValue) => {
+      if (newValue !== void 0) {
+        activeNames.value = Array.isArray(newValue) ? newValue : [newValue];
+      }
+    }, { immediate: true });
+    function setActiveNames(names) {
+      activeNames.value = names;
+      const first = names[0];
+      const emitValue = props.accordion ? first !== void 0 ? first : [] : names;
+      emit("update:modelValue", emitValue);
+      emit("change", emitValue);
+    }
+    function addItem(name) {
+      if (!activeNames.value.includes(name)) {
+        activeNames.value.push(name);
+      }
+    }
+    function removeItem(name) {
+      const index = activeNames.value.indexOf(name);
+      if (index > -1) {
+        activeNames.value.splice(index, 1);
+      }
+    }
+    function handleItemClick(name) {
+      if (props.accordion) {
+        if (activeNames.value.includes(name)) {
+          setActiveNames([]);
+        } else {
+          setActiveNames([name]);
+        }
+      } else {
+        if (activeNames.value.includes(name)) {
+          removeItem(name);
+          setActiveNames([...activeNames.value]);
+        } else {
+          addItem(name);
+          setActiveNames([...activeNames.value]);
+        }
+      }
+    }
+    provide("collapse", {
+      activeNames,
+      accordion: props.accordion,
+      handleItemClick
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/collapse/src/TxCollapseItem.vue.d.ts

@@ -0,0 +1,41 @@
+interface Props {
+    title?: string;
+    name?: string;
+    disabled?: boolean;
+    arrowIcon?: string;
+}
+declare function __VLS_template(): {
+    title?(_: {}): any;
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    arrowIcon: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    arrowIcon: string;
+}>>> & Readonly<{}>, {
+    arrowIcon: string;
+}, {}, {}, {}, 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/collapse/src/TxCollapseItem.vue.js

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

package/dist/es/collapse/src/TxCollapseItem.vue2.js

@@ -0,0 +1,58 @@
+import { defineComponent, inject, computed, createElementBlock, openBlock, createElementVNode, createVNode, normalizeClass, renderSlot, unref, createTextVNode, toDisplayString, Transition, withCtx, withDirectives, vShow } from 'vue';
+import { TxIcon } from '../../icon/index.js';
+
+const _hoisted_1 = { class: "tx-collapse-item" };
+const _hoisted_2 = { class: "tx-collapse-item__content" };
+const _hoisted_3 = { class: "tx-collapse-item__content-inner" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TxCollapseItem",
+  props: {
+    title: {},
+    name: {},
+    disabled: { type: Boolean },
+    arrowIcon: { default: "chevron-down" }
+  },
+  setup(__props) {
+    const props = __props;
+    const collapse = inject("collapse");
+    const itemName = computed(() => props.name || props.title || "");
+    const isActive = computed(() => {
+      return collapse?.activeNames.value.includes(itemName.value) || false;
+    });
+    function handleHeaderClick() {
+      if (props.disabled || !collapse)
+        return;
+      collapse.handleItemClick(itemName.value);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", {
+          class: normalizeClass(["tx-collapse-item__header", { "tx-collapse-item__header--active": isActive.value }]),
+          onClick: handleHeaderClick
+        }, [
+          createVNode(unref(TxIcon), {
+            name: __props.arrowIcon,
+            class: normalizeClass(["tx-collapse-item__arrow", { "tx-collapse-item__arrow--active": isActive.value }])
+          }, null, 8, ["name", "class"]),
+          renderSlot(_ctx.$slots, "title", {}, () => [
+            createTextVNode(toDisplayString(__props.title), 1)
+          ], true)
+        ], 2),
+        createVNode(Transition, { name: "tx-collapse" }, {
+          default: withCtx(() => [
+            withDirectives(createElementVNode("div", _hoisted_2, [
+              createElementVNode("div", _hoisted_3, [
+                renderSlot(_ctx.$slots, "default", {}, void 0, true)
+              ])
+            ], 512), [
+              [vShow, isActive.value]
+            ])
+          ]),
+          _: 3
+        })
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/collapse/src/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TxCollapse } from './TxCollapse.vue';
+export { default as TxCollapseItem } from './TxCollapseItem.vue';
+export type { CollapseContext, CollapseEmits, CollapseItemProps, CollapseProps } from './types';

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

@@ -0,0 +1,21 @@
+export interface CollapseContext {
+    activeNames: {
+        value: string[];
+    };
+    accordion: boolean;
+    handleItemClick: (name: string) => void;
+}
+export interface CollapseProps {
+    accordion?: boolean;
+    modelValue?: string | string[];
+}
+export interface CollapseEmits {
+    'update:modelValue': [value: string | string[]];
+    'change': [value: string | string[]];
+}
+export interface CollapseItemProps {
+    title?: string;
+    name?: string;
+    disabled?: boolean;
+    arrowIcon?: string;
+}

package/dist/es/command-palette/__tests__/command-palette.test.d.ts

@@ -0,0 +1 @@
+export {};