@talex-touch/tuffex 0.3.3

package/dist/es/search-select/src/TxSearchSelect.vue2.js

@@ -0,0 +1,320 @@
+import { defineComponent, ref, computed, watch, nextTick, onMounted, onBeforeUnmount, createElementBlock, openBlock, normalizeClass, createVNode, createBlock, withKeys, withCtx, createCommentVNode, createElementVNode, Teleport, Transition, withDirectives, normalizeStyle, unref, Fragment, renderList, toDisplayString, vShow } from 'vue';
+import { useFloating, offset, flip, shift, size, autoUpdate } from '@floating-ui/vue';
+import TxCardItem from '../../card-item/src/TxCardItem.vue.js';
+import TxCard from '../../card/src/TxCard.vue.js';
+import TuffInput from '../../input/src/TxInput.vue.js';
+import _sfc_main$1 from '../../spinner/src/TxSpinner.vue.js';
+/* empty css                               */
+
+const _hoisted_1 = {
+  key: 0,
+  class: "tx-search-select__loading"
+};
+const _hoisted_2 = { class: "tx-search-select__list" };
+const _hoisted_3 = { class: "tx-search-select__item-label" };
+const _hoisted_4 = {
+  key: 0,
+  class: "tx-search-select__empty"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "TxSearchSelect" },
+  __name: "TxSearchSelect",
+  props: {
+    modelValue: { default: "" },
+    placeholder: { default: "Search" },
+    disabled: { type: Boolean, default: false },
+    clearable: { type: Boolean, default: true },
+    options: { default: () => [] },
+    loading: { type: Boolean, default: false },
+    remote: { type: Boolean, default: false },
+    searchDebounce: { default: 200 },
+    dropdownMaxHeight: { default: 280 },
+    dropdownOffset: { default: 6 },
+    panelVariant: { default: "solid" },
+    panelBackground: { default: "glass" },
+    panelShadow: { default: "soft" },
+    panelRadius: { default: 18 },
+    panelPadding: { default: 6 }
+  },
+  emits: ["update:modelValue", "change", "search", "select", "open", "close"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const open = ref(false);
+    const referenceRef = ref(null);
+    const floatingRef = ref(null);
+    const cleanupAutoUpdate = ref(null);
+    const lastOpenedAt = ref(0);
+    const inputRef = ref(null);
+    const inputText = ref("");
+    const searchTimer = ref(null);
+    const optionsMap = computed(() => {
+      const m = /* @__PURE__ */ new Map();
+      for (const o of props.options ?? []) m.set(o.value, o);
+      return m;
+    });
+    const selectedOption = computed(() => optionsMap.value.get(props.modelValue ?? ""));
+    watch(
+      selectedOption,
+      (opt) => {
+        if (!opt)
+          return;
+        inputText.value = opt.label;
+      },
+      { immediate: true }
+    );
+    const filteredOptions = computed(() => {
+      const list = props.options ?? [];
+      if (props.remote)
+        return list;
+      const q = inputText.value.trim().toLowerCase();
+      if (!q)
+        return list;
+      return list.filter((o) => o.label.toLowerCase().includes(q));
+    });
+    function clearSearchTimer() {
+      if (searchTimer.value) {
+        clearTimeout(searchTimer.value);
+        searchTimer.value = null;
+      }
+    }
+    function emitSearch(q) {
+      if (!props.remote)
+        return;
+      if (props.disabled)
+        return;
+      emit("search", q);
+    }
+    function onInput(v) {
+      inputText.value = v;
+      if (!open.value) {
+        open.value = true;
+        emit("open");
+      }
+      if (!props.remote)
+        return;
+      clearSearchTimer();
+      const delay = Math.max(0, props.searchDebounce ?? 0);
+      searchTimer.value = setTimeout(() => {
+        searchTimer.value = null;
+        emitSearch(v);
+      }, delay);
+    }
+    function onEnter() {
+      emitSearch(inputText.value);
+    }
+    function onFocus() {
+      if (props.disabled)
+        return;
+      if (!open.value) {
+        open.value = true;
+        emit("open");
+      }
+    }
+    function close() {
+      if (!open.value)
+        return;
+      open.value = false;
+      emit("close");
+    }
+    function onClear() {
+      inputText.value = "";
+      emit("update:modelValue", "");
+      emit("change", "");
+    }
+    function onPick(opt) {
+      if (opt.disabled)
+        return;
+      emit("update:modelValue", opt.value);
+      emit("change", opt.value);
+      emit("select", opt);
+      inputText.value = opt.label;
+      close();
+    }
+    function isEventInside(e, el) {
+      if (!el)
+        return false;
+      const anyE = e;
+      const path = typeof anyE.composedPath === "function" ? anyE.composedPath() : void 0;
+      if (path && path.length)
+        return path.includes(el);
+      const t = e.target ?? null;
+      return !!t && el.contains(t);
+    }
+    function handleOutside(e) {
+      if (!open.value)
+        return;
+      if (performance.now() - lastOpenedAt.value < 60)
+        return;
+      const inRef = isEventInside(e, referenceRef.value);
+      const inFloat = isEventInside(e, floatingRef.value);
+      if (!inRef && !inFloat)
+        close();
+    }
+    function handleEsc(e) {
+      if (e.key !== "Escape")
+        return;
+      if (!open.value)
+        return;
+      close();
+    }
+    const { floatingStyles, update } = useFloating(referenceRef, floatingRef, {
+      placement: "bottom-start",
+      strategy: "fixed",
+      middleware: [
+        offset(() => props.dropdownOffset),
+        flip({ padding: 8 }),
+        shift({ padding: 8 }),
+        size({
+          padding: 8,
+          apply({ rects, availableHeight, elements }) {
+            const h = Math.min(availableHeight, props.dropdownMaxHeight);
+            Object.assign(elements.floating.style, {
+              minWidth: `${rects.reference.width}px`,
+              maxWidth: `${rects.reference.width}px`,
+              height: `${h}px`,
+              maxHeight: `${h}px`,
+              overflow: "hidden"
+            });
+          }
+        })
+      ]
+    });
+    watch(
+      open,
+      async (v) => {
+        if (!v) {
+          cleanupAutoUpdate.value?.();
+          cleanupAutoUpdate.value = null;
+          clearSearchTimer();
+          return;
+        }
+        lastOpenedAt.value = performance.now();
+        await nextTick();
+        await update();
+        if (referenceRef.value && floatingRef.value) {
+          cleanupAutoUpdate.value?.();
+          cleanupAutoUpdate.value = autoUpdate(referenceRef.value, floatingRef.value, () => update());
+        }
+      },
+      { flush: "post" }
+    );
+    onMounted(() => {
+      document.addEventListener("pointerdown", handleOutside, true);
+      document.addEventListener("keydown", handleEsc);
+    });
+    onBeforeUnmount(() => {
+      document.removeEventListener("pointerdown", handleOutside, true);
+      document.removeEventListener("keydown", handleEsc);
+      cleanupAutoUpdate.value?.();
+      cleanupAutoUpdate.value = null;
+      clearSearchTimer();
+    });
+    __expose({
+      open: () => {
+        if (props.disabled)
+          return;
+        if (!open.value) {
+          open.value = true;
+          emit("open");
+        }
+      },
+      close,
+      focus: () => inputRef.value?.focus?.(),
+      blur: () => inputRef.value?.blur?.(),
+      clear: () => inputRef.value?.clear?.()
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "referenceRef",
+        ref: referenceRef,
+        class: normalizeClass(["tx-search-select", { "is-open": open.value, "is-disabled": props.disabled }])
+      }, [
+        createVNode(TuffInput, {
+          ref_key: "inputRef",
+          ref: inputRef,
+          "model-value": inputText.value,
+          disabled: props.disabled,
+          placeholder: props.placeholder,
+          clearable: props.clearable,
+          "onUpdate:modelValue": onInput,
+          onFocus,
+          onKeydown: withKeys(onEnter, ["enter"]),
+          onClear
+        }, {
+          prefix: withCtx(() => [..._cache[0] || (_cache[0] = [
+            createElementVNode("span", {
+              class: "tx-search-select__icon",
+              "aria-hidden": "true"
+            }, [
+              createElementVNode("svg", {
+                viewBox: "0 0 24 24",
+                width: "16",
+                height: "16"
+              }, [
+                createElementVNode("path", {
+                  fill: "currentColor",
+                  d: "M10 2a8 8 0 105.293 14.293l4.207 4.207 1.414-1.414-4.207-4.207A8 8 0 0010 2zm0 2a6 6 0 110 12 6 6 0 010-12z"
+                })
+              ])
+            ], -1)
+          ])]),
+          suffix: withCtx(() => [
+            props.loading ? (openBlock(), createElementBlock("span", _hoisted_1, [
+              createVNode(_sfc_main$1, { size: 12 })
+            ])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["model-value", "disabled", "placeholder", "clearable"]),
+        (openBlock(), createBlock(Teleport, { to: "body" }, [
+          createVNode(Transition, { name: "tx-search-select-dropdown" }, {
+            default: withCtx(() => [
+              withDirectives(createElementVNode("div", {
+                ref_key: "floatingRef",
+                ref: floatingRef,
+                class: "tx-search-select__dropdown",
+                style: normalizeStyle(unref(floatingStyles))
+              }, [
+                createVNode(TxCard, {
+                  class: "tx-search-select__panel",
+                  variant: props.panelVariant,
+                  background: props.panelBackground,
+                  shadow: props.panelShadow,
+                  radius: props.panelRadius,
+                  padding: props.panelPadding
+                }, {
+                  default: withCtx(() => [
+                    createElementVNode("div", _hoisted_2, [
+                      (openBlock(true), createElementBlock(Fragment, null, renderList(filteredOptions.value, (opt) => {
+                        return openBlock(), createBlock(TxCardItem, {
+                          key: String(opt.value),
+                          class: normalizeClass(["tx-search-select__item", { "is-selected": opt.value === props.modelValue, "is-disabled": opt.disabled }]),
+                          clickable: !opt.disabled,
+                          disabled: !!opt.disabled,
+                          active: opt.value === props.modelValue,
+                          onClick: ($event) => onPick(opt)
+                        }, {
+                          title: withCtx(() => [
+                            createElementVNode("span", _hoisted_3, toDisplayString(opt.label), 1)
+                          ]),
+                          _: 2
+                        }, 1032, ["class", "clickable", "disabled", "active", "onClick"]);
+                      }), 128)),
+                      !props.loading && !filteredOptions.value.length ? (openBlock(), createElementBlock("div", _hoisted_4, " No results ")) : createCommentVNode("", true)
+                    ])
+                  ]),
+                  _: 1
+                }, 8, ["variant", "background", "shadow", "radius", "padding"])
+              ], 4), [
+                [vShow, open.value && !props.disabled]
+              ])
+            ]),
+            _: 1
+          })
+        ]))
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/search-select/src/types.d.ts

@@ -0,0 +1,30 @@
+export interface TxSearchSelectOption {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+}
+export interface TxSearchSelectProps {
+    modelValue?: string | number;
+    placeholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    options?: TxSearchSelectOption[];
+    loading?: boolean;
+    remote?: boolean;
+    searchDebounce?: number;
+    dropdownMaxHeight?: number;
+    dropdownOffset?: number;
+    panelVariant?: 'solid' | 'dashed' | 'plain';
+    panelBackground?: 'blur' | 'glass' | 'mask';
+    panelShadow?: 'none' | 'soft' | 'medium';
+    panelRadius?: number;
+    panelPadding?: number;
+}
+export interface TxSearchSelectEmits {
+    (e: 'update:modelValue', v: string | number): void;
+    (e: 'change', v: string | number): void;
+    (e: 'search', q: string): void;
+    (e: 'select', opt: TxSearchSelectOption): void;
+    (e: 'open'): void;
+    (e: 'close'): void;
+}

package/dist/es/segmented-slider/index.d.ts

@@ -0,0 +1,116 @@
+import { SegmentedSliderEmits, SegmentedSliderProps, SegmentedSliderSegment } from './src/types';
+import { default as TxSegmentedSlider } from './src/TxSegmentedSlider.vue';
+
+declare const SegmentedSlider: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        modelValue: {
+            type: import('vue').PropType<string | number>;
+            default: number;
+        };
+        vertical: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        segments: {
+            type: import('vue').PropType<SegmentedSliderSegment[]>;
+            default: () => never[];
+        };
+        showLabels: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onChange?: ((value: string | number) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        change: (value: string | number) => void;
+        "update:modelValue": (value: string | number) => void;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        modelValue: number | string;
+        vertical: boolean;
+        segments: SegmentedSliderSegment[];
+        showLabels: boolean;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        modelValue: {
+            type: import('vue').PropType<string | number>;
+            default: number;
+        };
+        vertical: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        segments: {
+            type: import('vue').PropType<SegmentedSliderSegment[]>;
+            default: () => never[];
+        };
+        showLabels: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        onChange?: ((value: string | number) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        modelValue: number | string;
+        vertical: boolean;
+        segments: SegmentedSliderSegment[];
+        showLabels: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    disabled: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    modelValue: {
+        type: import('vue').PropType<string | number>;
+        default: number;
+    };
+    vertical: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    segments: {
+        type: import('vue').PropType<SegmentedSliderSegment[]>;
+        default: () => never[];
+    };
+    showLabels: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: ((value: string | number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: string | number) => void;
+    "update:modelValue": (value: string | number) => void;
+}, string, {
+    disabled: boolean;
+    modelValue: number | string;
+    vertical: boolean;
+    segments: SegmentedSliderSegment[];
+    showLabels: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
+export { SegmentedSlider, TxSegmentedSlider };
+export type { SegmentedSliderEmits, SegmentedSliderProps, SegmentedSliderSegment };
+export type TxSegmentedSliderInstance = InstanceType<typeof TxSegmentedSlider>;
+export default SegmentedSlider;

package/dist/es/segmented-slider/index.js

@@ -0,0 +1,7 @@
+import { withInstall } from '../utils/withInstall.js';
+import _sfc_main from './src/TxSegmentedSlider.vue.js';
+/* empty css                           */
+
+const SegmentedSlider = withInstall(_sfc_main);
+
+export { SegmentedSlider, _sfc_main as TxSegmentedSlider, SegmentedSlider as default };

package/dist/es/segmented-slider/src/TxSegmentedSlider.vue.d.ts

@@ -0,0 +1,45 @@
+import { SegmentedSliderProps, SegmentedSliderSegment } from './types';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SegmentedSliderProps>, {
+    modelValue: number;
+    segments: () => never[];
+    disabled: boolean;
+    showLabels: boolean;
+    vertical: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: string | number) => void;
+    "update:modelValue": (value: string | number) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SegmentedSliderProps>, {
+    modelValue: number;
+    segments: () => never[];
+    disabled: boolean;
+    showLabels: boolean;
+    vertical: boolean;
+}>>> & Readonly<{
+    onChange?: ((value: string | number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: number | string;
+    vertical: boolean;
+    segments: SegmentedSliderSegment[];
+    showLabels: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+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];
+} & {};

package/dist/es/segmented-slider/src/TxSegmentedSlider.vue.js

@@ -0,0 +1,98 @@
+import { defineComponent, ref, computed, onMounted, createElementBlock, openBlock, normalizeClass, createElementVNode, normalizeStyle, Fragment, renderList, createCommentVNode, toDisplayString } from 'vue';
+
+const _hoisted_1 = { class: "tx-segmented-slider__track" };
+const _hoisted_2 = ["aria-pressed", "onClick", "onKeydown"];
+const _hoisted_3 = {
+  key: 0,
+  class: "tx-segmented-slider__label"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "TxSegmentedSlider"
+  },
+  __name: "TxSegmentedSlider",
+  props: {
+    modelValue: { default: 0 },
+    segments: { default: () => [] },
+    disabled: { type: Boolean, default: false },
+    showLabels: { type: Boolean, default: true },
+    vertical: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const sliderRef = ref(null);
+    const currentIndex = computed(() => {
+      const index = props.segments.findIndex((seg) => seg.value === props.modelValue);
+      return Math.max(0, index);
+    });
+    const progressPercent = computed(() => {
+      if (props.segments.length <= 1)
+        return 0;
+      return currentIndex.value / (props.segments.length - 1) * 100;
+    });
+    const segmentDenom = computed(() => {
+      return Math.max(1, props.segments.length - 1);
+    });
+    function segmentLeftPercent(index) {
+      return index / segmentDenom.value * 100;
+    }
+    function handleSegmentClick(segment) {
+      if (props.disabled)
+        return;
+      emit("update:modelValue", segment.value);
+      emit("change", segment.value);
+    }
+    function handleKeydown(e, segment) {
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        handleSegmentClick(segment);
+      }
+    }
+    onMounted(() => {
+      if (props.modelValue == null && props.segments.length > 0) {
+        const first = props.segments[0];
+        if (first)
+          emit("update:modelValue", first.value);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "sliderRef",
+        ref: sliderRef,
+        class: normalizeClass(["tx-segmented-slider", {
+          "is-disabled": __props.disabled,
+          "is-vertical": __props.vertical
+        }])
+      }, [
+        createElementVNode("div", _hoisted_1, [
+          createElementVNode("div", {
+            class: "tx-segmented-slider__progress",
+            style: normalizeStyle({ width: `${progressPercent.value}%` })
+          }, null, 4),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.segments, (segment, index) => {
+            return openBlock(), createElementBlock("div", {
+              key: segment.value,
+              class: normalizeClass(["tx-segmented-slider__segment", {
+                "is-active": segment.value === __props.modelValue,
+                "is-completed": index < currentIndex.value
+              }]),
+              style: normalizeStyle({ left: `${segmentLeftPercent(index)}%` }),
+              tabindex: "0",
+              role: "button",
+              "aria-pressed": segment.value === __props.modelValue,
+              onClick: ($event) => handleSegmentClick(segment),
+              onKeydown: (e) => handleKeydown(e, segment)
+            }, [
+              _cache[0] || (_cache[0] = createElementVNode("div", { class: "tx-segmented-slider__dot" }, null, -1)),
+              __props.showLabels && segment.label ? (openBlock(), createElementBlock("div", _hoisted_3, toDisplayString(segment.label), 1)) : createCommentVNode("", true)
+            ], 46, _hoisted_2);
+          }), 128))
+        ])
+      ], 2);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/segmented-slider/src/TxSegmentedSlider.vue3.js

@@ -0,0 +1,6 @@
+import _sfc_main from './TxSegmentedSlider.vue.js';
+/* empty css                       */
+
+
+
+export { _sfc_main as default };

package/dist/es/segmented-slider/src/types.d.ts

@@ -0,0 +1,15 @@
+export interface SegmentedSliderSegment {
+    value: number | string;
+    label?: string;
+}
+export interface SegmentedSliderProps {
+    modelValue?: number | string;
+    segments?: SegmentedSliderSegment[];
+    disabled?: boolean;
+    showLabels?: boolean;
+    vertical?: boolean;
+}
+export interface SegmentedSliderEmits {
+    'update:modelValue': [value: number | string];
+    'change': [value: number | string];
+}

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

@@ -0,0 +1,6 @@
+import { default as TuffSelect } from './src/TxSelect.vue';
+import { default as TuffSelectItem } from './src/TxSelectItem.vue';
+
+export { TuffSelect, TuffSelectItem };
+export { TuffSelect as TxSelect, TuffSelectItem as TxSelectItem };
+export default TuffSelect;

package/dist/es/select/index.js

@@ -0,0 +1,11 @@
+import TuffSelect from './src/TxSelect.vue.js';
+import TuffSelectItem from './src/TxSelectItem.vue.js';
+
+TuffSelect.install = (app) => {
+  app.component(TuffSelect.name || "TuffSelect", TuffSelect);
+};
+TuffSelectItem.install = (app) => {
+  app.component(TuffSelectItem.name || "TuffSelectItem", TuffSelectItem);
+};
+
+export { TuffSelect, TuffSelectItem, TuffSelect as TxSelect, TuffSelectItem as TxSelectItem, TuffSelect as default };