@talex-touch/tuffex 0.3.3 → 0.3.4

package/dist/es/flat-radio/src/TxFlatRadio.vue2.js

@@ -0,0 +1,237 @@
+import { defineComponent, toRefs, ref, provide, computed, onMounted, nextTick, onBeforeUnmount, watch, createElementBlock, openBlock, unref, normalizeStyle, normalizeClass, createCommentVNode, renderSlot } from 'vue';
+import { FLAT_RADIO_KEY } from './types.js';
+
+const _hoisted_1 = ["role", "tabindex", "aria-disabled"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "TxFlatRadio" },
+  __name: "TxFlatRadio",
+  props: {
+    modelValue: {},
+    multiple: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    size: { default: "md" },
+    bordered: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { disabled, multiple } = toRefs(props);
+    const itemMap = /* @__PURE__ */ new Map();
+    const orderedValues = ref([]);
+    function rebuildOrder() {
+      const root = containerRef.value;
+      if (!root) return;
+      const els = Array.from(root.querySelectorAll(".tx-flat-radio-item"));
+      const sorted = [];
+      for (const el of els) {
+        for (const [val, registered] of itemMap) {
+          if (registered === el) {
+            sorted.push(val);
+            break;
+          }
+        }
+      }
+      orderedValues.value = sorted;
+    }
+    function registerItem(value, el) {
+      itemMap.set(value, el);
+      rebuildOrder();
+      updateIndicatorNoTransition();
+    }
+    function unregisterItem(value) {
+      itemMap.delete(value);
+      rebuildOrder();
+      updateIndicatorNoTransition();
+    }
+    function isSelected(value) {
+      if (props.multiple) {
+        const arr = Array.isArray(props.modelValue) ? props.modelValue : [];
+        return arr.includes(value);
+      }
+      return props.modelValue === value;
+    }
+    function select(value) {
+      if (props.disabled) return;
+      if (props.multiple) {
+        const arr = Array.isArray(props.modelValue) ? [...props.modelValue] : [];
+        const idx = arr.indexOf(value);
+        if (idx >= 0) {
+          arr.splice(idx, 1);
+        } else {
+          arr.push(value);
+        }
+        emit("update:modelValue", arr);
+        emit("change", arr);
+      } else {
+        emit("update:modelValue", value);
+        emit("change", value);
+      }
+    }
+    provide(FLAT_RADIO_KEY, {
+      modelValue: computed(() => props.modelValue),
+      multiple: computed(() => props.multiple),
+      disabled: computed(() => props.disabled),
+      size: computed(() => props.size),
+      registerItem,
+      unregisterItem,
+      select,
+      isSelected
+    });
+    const containerRef = ref(null);
+    const indicatorStyle = ref({
+      opacity: "0",
+      transform: "translateX(0)",
+      width: "0px"
+    });
+    const indicatorTransition = ref(true);
+    function updateIndicator(animate) {
+      if (props.multiple) {
+        indicatorStyle.value = { ...indicatorStyle.value, opacity: "0" };
+        return;
+      }
+      const current = props.modelValue;
+      const el = itemMap.get(current);
+      if (!el || !containerRef.value) {
+        indicatorStyle.value = { ...indicatorStyle.value, opacity: "0" };
+        return;
+      }
+      const left = el.offsetLeft;
+      const width = el.offsetWidth;
+      indicatorTransition.value = animate;
+      indicatorStyle.value = {
+        opacity: "1",
+        transform: `translateX(${left}px)`,
+        width: `${width}px`
+      };
+    }
+    function updateIndicatorNoTransition() {
+      nextTick(() => updateIndicator(false));
+    }
+    let resizeObserver = null;
+    onMounted(async () => {
+      await nextTick();
+      updateIndicator(false);
+      if (containerRef.value) {
+        resizeObserver = new ResizeObserver(() => {
+          updateIndicator(false);
+        });
+        resizeObserver.observe(containerRef.value);
+      }
+    });
+    onBeforeUnmount(() => {
+      resizeObserver?.disconnect();
+      resizeObserver = null;
+    });
+    watch(
+      () => props.modelValue,
+      async () => {
+        await nextTick();
+        updateIndicator(true);
+      },
+      { flush: "post", deep: true }
+    );
+    function getEnabledValues() {
+      return orderedValues.value.filter((v) => {
+        const el = itemMap.get(v);
+        return el && !el.hasAttribute("disabled");
+      });
+    }
+    const focusedValue = ref(null);
+    function handleKeydown(e) {
+      if (props.disabled) return;
+      const enabled = getEnabledValues();
+      if (enabled.length === 0) return;
+      const fallbackValue = enabled[0];
+      if (fallbackValue == null)
+        return;
+      const singleValue = Array.isArray(props.modelValue) ? void 0 : props.modelValue;
+      const currentVal = props.multiple ? focusedValue.value ?? fallbackValue : singleValue ?? fallbackValue;
+      const currentIdx = enabled.indexOf(currentVal);
+      let nextIdx = -1;
+      switch (e.key) {
+        case "ArrowRight":
+        case "ArrowDown":
+          e.preventDefault();
+          nextIdx = currentIdx < 0 ? 0 : (currentIdx + 1) % enabled.length;
+          break;
+        case "ArrowLeft":
+        case "ArrowUp":
+          e.preventDefault();
+          nextIdx = currentIdx < 0 ? enabled.length - 1 : (currentIdx - 1 + enabled.length) % enabled.length;
+          break;
+        case "Home":
+          e.preventDefault();
+          nextIdx = 0;
+          break;
+        case "End":
+          e.preventDefault();
+          nextIdx = enabled.length - 1;
+          break;
+        case " ":
+        case "Enter":
+          if (props.multiple) {
+            e.preventDefault();
+            if (focusedValue.value != null) {
+              select(focusedValue.value);
+            }
+          }
+          return;
+        default:
+          return;
+      }
+      if (nextIdx >= 0) {
+        const nextValue = enabled[nextIdx];
+        if (nextValue == null)
+          return;
+        if (props.multiple) {
+          focusedValue.value = nextValue;
+        } else if (nextValue !== props.modelValue) {
+          select(nextValue);
+        }
+      }
+    }
+    const sizeConfig = computed(() => {
+      const map = {
+        sm: { height: "24px", padding: "2px", fontSize: "12px", gap: "2px", radius: "6px", itemRadius: "4px" },
+        md: { height: "30px", padding: "3px", fontSize: "13px", gap: "4px", radius: "8px", itemRadius: "6px" },
+        lg: { height: "36px", padding: "4px", fontSize: "14px", gap: "4px", radius: "10px", itemRadius: "8px" }
+      };
+      return map[props.size] ?? map.md;
+    });
+    const cssVars = computed(() => ({
+      "--tx-flat-radio-height": sizeConfig.value.height,
+      "--tx-flat-radio-padding": sizeConfig.value.padding,
+      "--tx-flat-radio-font-size": sizeConfig.value.fontSize,
+      "--tx-flat-radio-gap": sizeConfig.value.gap,
+      "--tx-flat-radio-radius": sizeConfig.value.radius,
+      "--tx-flat-radio-item-radius": sizeConfig.value.itemRadius
+    }));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "containerRef",
+        ref: containerRef,
+        class: normalizeClass(["tx-flat-radio", {
+          "is-disabled": unref(disabled),
+          "is-bordered": __props.bordered,
+          "is-multiple": unref(multiple)
+        }]),
+        style: normalizeStyle(cssVars.value),
+        role: unref(multiple) ? "group" : "radiogroup",
+        tabindex: unref(disabled) ? -1 : 0,
+        "aria-disabled": unref(disabled),
+        onKeydown: handleKeydown
+      }, [
+        !unref(multiple) ? (openBlock(), createElementBlock("span", {
+          key: 0,
+          class: normalizeClass(["tx-flat-radio__indicator", { "no-transition": !indicatorTransition.value }]),
+          style: normalizeStyle(indicatorStyle.value),
+          "aria-hidden": "true"
+        }, null, 6)) : createCommentVNode("", true),
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 46, _hoisted_1);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/flat-radio/src/TxFlatRadioItem.vue.d.ts

@@ -0,0 +1,43 @@
+import { TxFlatRadioItemProps } from './types';
+
+declare function __VLS_template(): {
+    icon?(_: {}): any;
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TxFlatRadioItemProps>, {
+    label: undefined;
+    icon: undefined;
+    disabled: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<TxFlatRadioItemProps>, {
+    label: undefined;
+    icon: undefined;
+    disabled: boolean;
+}>>> & Readonly<{}>, {
+    disabled: boolean;
+    label: string;
+    icon: 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/flat-radio/src/TxFlatRadioItem.vue.js

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

package/dist/es/flat-radio/src/TxFlatRadioItem.vue2.js

@@ -0,0 +1,87 @@
+import { defineComponent, inject, getCurrentInstance, ref, computed, onMounted, onBeforeUnmount, createElementBlock, openBlock, normalizeClass, createCommentVNode, renderSlot, createTextVNode, toDisplayString } from 'vue';
+import { FLAT_RADIO_KEY } from './types.js';
+
+const _hoisted_1 = ["role", "aria-checked", "disabled"];
+const _hoisted_2 = {
+  key: 0,
+  class: "tx-flat-radio-item__icon"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "tx-flat-radio-item__label"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "TxFlatRadioItem" },
+  __name: "TxFlatRadioItem",
+  props: {
+    value: {},
+    label: { default: void 0 },
+    icon: { default: void 0 },
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const ctx = inject(FLAT_RADIO_KEY);
+    if (!ctx) {
+      if (getCurrentInstance()) {
+        console.warn("[TxFlatRadioItem] must be used inside <TxFlatRadio>");
+      }
+    }
+    const itemRef = ref(null);
+    const isSelected = computed(() => {
+      if (!ctx) return false;
+      const mv = ctx.modelValue.value;
+      if (ctx.multiple.value) {
+        return Array.isArray(mv) ? mv.includes(props.value) : false;
+      }
+      return mv === props.value;
+    });
+    const isDisabled = computed(() => props.disabled || ctx?.disabled.value);
+    const isMultiple = computed(() => ctx?.multiple.value ?? false);
+    function handleClick() {
+      if (isDisabled.value) return;
+      ctx?.select(props.value);
+    }
+    onMounted(() => {
+      if (itemRef.value && ctx) {
+        ctx.registerItem(props.value, itemRef.value);
+      }
+    });
+    onBeforeUnmount(() => {
+      ctx?.unregisterItem(props.value);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        ref_key: "itemRef",
+        ref: itemRef,
+        class: normalizeClass(["tx-flat-radio-item", {
+          "is-selected": isSelected.value,
+          "is-disabled": isDisabled.value,
+          "is-multiple-selected": isMultiple.value && isSelected.value
+        }]),
+        type: "button",
+        role: isMultiple.value ? "checkbox" : "radio",
+        "aria-checked": isSelected.value,
+        disabled: isDisabled.value || void 0,
+        tabindex: -1,
+        onClick: handleClick
+      }, [
+        _ctx.$slots.icon || __props.icon ? (openBlock(), createElementBlock("span", _hoisted_2, [
+          renderSlot(_ctx.$slots, "icon", {}, () => [
+            __props.icon ? (openBlock(), createElementBlock("i", {
+              key: 0,
+              class: normalizeClass(__props.icon)
+            }, null, 2)) : createCommentVNode("", true)
+          ], true)
+        ])) : createCommentVNode("", true),
+        _ctx.$slots.default || __props.label ? (openBlock(), createElementBlock("span", _hoisted_3, [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            createTextVNode(toDisplayString(__props.label), 1)
+          ], true)
+        ])) : createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/dist/es/flat-radio/src/types.d.ts

@@ -0,0 +1,28 @@
+import { InjectionKey, Ref } from 'vue';
+
+export type TxFlatRadioValue = string | number;
+export type TxFlatRadioSize = 'sm' | 'md' | 'lg';
+export interface TxFlatRadioProps {
+    modelValue: TxFlatRadioValue | TxFlatRadioValue[];
+    multiple?: boolean;
+    disabled?: boolean;
+    size?: TxFlatRadioSize;
+    bordered?: boolean;
+}
+export interface TxFlatRadioItemProps {
+    value: TxFlatRadioValue;
+    label?: string;
+    icon?: string;
+    disabled?: boolean;
+}
+export interface TxFlatRadioContext {
+    modelValue: Ref<TxFlatRadioValue | TxFlatRadioValue[]>;
+    multiple: Ref<boolean>;
+    disabled: Ref<boolean>;
+    size: Ref<TxFlatRadioSize>;
+    registerItem: (value: TxFlatRadioValue, el: HTMLElement) => void;
+    unregisterItem: (value: TxFlatRadioValue) => void;
+    select: (value: TxFlatRadioValue) => void;
+    isSelected: (value: TxFlatRadioValue) => boolean;
+}
+export declare const FLAT_RADIO_KEY: InjectionKey<TxFlatRadioContext>;

package/dist/es/flat-radio/src/types.js

@@ -0,0 +1,3 @@
+const FLAT_RADIO_KEY = Symbol("TxFlatRadio");
+
+export { FLAT_RADIO_KEY };

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

@@ -0,0 +1,159 @@
+import { TxFlatSelectItemProps, TxFlatSelectProps, TxFlatSelectValue } from './src/types';
+import { default as TxFlatSelect } from './src/TxFlatSelect.vue';
+import { default as TxFlatSelectItem } from './src/TxFlatSelectItem.vue';
+
+declare const FlatSelect: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        placeholder: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        modelValue: {
+            type: import('vue').PropType<TxFlatSelectValue>;
+            default: string;
+        };
+    }>> & Readonly<{
+        onChange?: ((value: TxFlatSelectValue) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: TxFlatSelectValue) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        change: (value: TxFlatSelectValue) => void;
+        "update:modelValue": (value: TxFlatSelectValue) => void;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        placeholder: string;
+        modelValue: TxFlatSelectValue;
+    }, 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;
+        };
+        placeholder: {
+            type: import('vue').PropType<string>;
+            default: string;
+        };
+        modelValue: {
+            type: import('vue').PropType<TxFlatSelectValue>;
+            default: string;
+        };
+    }>> & Readonly<{
+        onChange?: ((value: TxFlatSelectValue) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: TxFlatSelectValue) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        placeholder: string;
+        modelValue: TxFlatSelectValue;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    disabled: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    placeholder: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    modelValue: {
+        type: import('vue').PropType<TxFlatSelectValue>;
+        default: string;
+    };
+}>> & Readonly<{
+    onChange?: ((value: TxFlatSelectValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: TxFlatSelectValue) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: TxFlatSelectValue) => void;
+    "update:modelValue": (value: TxFlatSelectValue) => void;
+}, string, {
+    disabled: boolean;
+    placeholder: string;
+    modelValue: TxFlatSelectValue;
+}, {}, 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 FlatSelectItem: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        disabled: {
+            type: import('vue').PropType<boolean>;
+            default: boolean;
+        };
+        label: {
+            type: import('vue').PropType<string>;
+            default: undefined;
+        };
+        value: {
+            type: import('vue').PropType<TxFlatSelectValue>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        disabled: boolean;
+        label: string;
+    }, 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;
+        };
+        label: {
+            type: import('vue').PropType<string>;
+            default: undefined;
+        };
+        value: {
+            type: import('vue').PropType<TxFlatSelectValue>;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        disabled: boolean;
+        label: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    disabled: {
+        type: import('vue').PropType<boolean>;
+        default: boolean;
+    };
+    label: {
+        type: import('vue').PropType<string>;
+        default: undefined;
+    };
+    value: {
+        type: import('vue').PropType<TxFlatSelectValue>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    disabled: boolean;
+    label: string;
+}, {}, 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;
+export { FlatSelect, FlatSelectItem, TxFlatSelect, TxFlatSelectItem };
+export type { TxFlatSelectProps, TxFlatSelectItemProps, TxFlatSelectValue };
+export { FLAT_SELECT_KEY } from './src/types';
+export type { TxFlatSelectContext } from './src/types';
+export type TxFlatSelectInstance = InstanceType<typeof TxFlatSelect>;
+export type TxFlatSelectItemInstance = InstanceType<typeof TxFlatSelectItem>;
+export default FlatSelect;

package/dist/es/flat-select/index.js

@@ -0,0 +1,8 @@
+import { withInstall } from '../packages/tuffex/packages/utils/withInstall.js';
+import TxFlatSelect from './src/TxFlatSelect.vue.js';
+import TxFlatSelectItem from './src/TxFlatSelectItem.vue.js';
+
+const FlatSelect = withInstall(TxFlatSelect);
+const FlatSelectItem = withInstall(TxFlatSelectItem);
+
+export { FlatSelect, FlatSelectItem, TxFlatSelect, TxFlatSelectItem, FlatSelect as default };

package/dist/es/flat-select/src/TxFlatSelect.vue.d.ts

@@ -0,0 +1,56 @@
+import { TxFlatSelectValue } from './types';
+
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    modelValue?: TxFlatSelectValue;
+    placeholder?: string;
+    disabled?: boolean;
+}>, {
+    modelValue: string;
+    placeholder: string;
+    disabled: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: TxFlatSelectValue) => void;
+    "update:modelValue": (value: TxFlatSelectValue) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    modelValue?: TxFlatSelectValue;
+    placeholder?: string;
+    disabled?: boolean;
+}>, {
+    modelValue: string;
+    placeholder: string;
+    disabled: boolean;
+}>>> & Readonly<{
+    onChange?: ((value: TxFlatSelectValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: TxFlatSelectValue) => any) | undefined;
+}>, {
+    disabled: boolean;
+    placeholder: string;
+    modelValue: TxFlatSelectValue;
+}, {}, {}, {}, 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/flat-select/src/TxFlatSelect.vue.js

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