ep-craft 0.1.26 → 0.1.28

package/dist/components/select-v2/src/defaults.d.ts

@@ -0,0 +1,258 @@
+import type SelectV2 from './select.vue';
+import type { Option, OptionType } from './select.types';
+import type { Props } from './useProps';
+import type { EmitFn } from '@element-plus/utils/vue/typescript';
+import type { CSSProperties, ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+import type { Options, Placement, PopperEffect } from '@element-plus/components/popper';
+/**
+ * @description Tag tooltip configuration interface
+ */
+export interface TagTooltipProps {
+    appendTo?: string | HTMLElement;
+    placement?: Placement;
+    fallbackPlacements?: Placement[];
+    effect?: PopperEffect;
+    popperClass?: string;
+    popperStyle?: string | CSSProperties;
+    transition?: string;
+    teleported?: boolean;
+    popperOptions?: Partial<Options>;
+    showAfter?: number;
+    hideAfter?: number;
+    autoClose?: number;
+    offset?: number;
+}
+export declare const selectV2Props: {
+    readonly ariaLabel: StringConstructor;
+    readonly emptyValues: ArrayConstructor;
+    readonly valueOnClear: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly floatLabel: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly allowCreate: BooleanConstructor;
+    readonly autocomplete: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "none" | "both" | "inline" | "list") | (() => "none" | "both" | "inline" | "list") | (((new (...args: any[]) => "none" | "both" | "inline" | "list") | (() => "none" | "both" | "inline" | "list")) | null)[], unknown, unknown, "none", boolean>;
+    readonly automaticDropdown: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+    readonly clearIcon: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+    readonly effect: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => PopperEffect) | (((new (...args: any[]) => string) | (() => PopperEffect)) | null)[], unknown, unknown, "light", boolean>;
+    readonly collapseTags: BooleanConstructor;
+    readonly collapseTagsTooltip: BooleanConstructor;
+    readonly tagTooltip: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TagTooltipProps) | (() => TagTooltipProps) | (((new (...args: any[]) => TagTooltipProps) | (() => TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly maxCollapseTags: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+    readonly defaultFirstOption: BooleanConstructor;
+    readonly disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly estimatedOptionHeight: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, undefined, boolean>;
+    readonly filterable: BooleanConstructor;
+    readonly filterMethod: {
+        readonly type: import("vue").PropType<(query: string) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly height: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 274, boolean>;
+    readonly itemHeight: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 34, boolean>;
+    readonly id: StringConstructor;
+    readonly loading: BooleanConstructor;
+    readonly loadingText: StringConstructor;
+    readonly modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | {
+        (): any;
+        new (): any;
+        readonly prototype: any;
+    } | (((new (...args: any[]) => any) | (() => any) | {
+        (): any;
+        new (): any;
+        readonly prototype: any;
+    }) | null)[], unknown, unknown, undefined, boolean>;
+    readonly multiple: BooleanConstructor;
+    readonly multipleLimit: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly name: StringConstructor;
+    readonly noDataText: StringConstructor;
+    readonly noMatchText: StringConstructor;
+    readonly remoteMethod: {
+        readonly type: import("vue").PropType<(query: string) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly reserveKeyword: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly options: {
+        readonly type: import("vue").PropType<OptionType[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly placeholder: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly teleported: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly persistent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly popperClass: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly popperStyle: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly popperOptions: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => Partial<Options>, boolean>;
+    readonly remote: BooleanConstructor;
+    readonly debounce: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Props) | (() => Props) | (((new (...args: any[]) => Props) | (() => Props)) | null)[], unknown, unknown, () => Required<Props>, boolean>;
+    readonly valueKey: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "value", boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly remoteShowSuffix: BooleanConstructor;
+    readonly showArrow: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement)) | null)[], Placement, unknown, "bottom-start", boolean>;
+    readonly fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | (((new (...args: any[]) => Placement[]) | (() => Placement[])) | null)[], unknown, unknown, readonly ["bottom-start", "top-start", "right", "left"], boolean>;
+    readonly tagType: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown, "info", boolean>;
+    readonly tagEffect: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown, "light", boolean>;
+    readonly tabindex: import("@element-plus/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
+    readonly appendTo: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fitInputWidth: import("@element-plus/utils").EpPropFinalized<readonly [BooleanConstructor, NumberConstructor], unknown, number | boolean, true, boolean>;
+    readonly suffixIcon: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+};
+export declare const optionV2Props: {
+    readonly data: ArrayConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly hovering: BooleanConstructor;
+    readonly item: {
+        readonly type: import("vue").PropType<Option>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly index: NumberConstructor;
+    readonly style: ObjectConstructor;
+    readonly selected: BooleanConstructor;
+    readonly created: BooleanConstructor;
+};
+export declare const selectV2Emits: {
+    "update:modelValue": (val: SelectV2Props["modelValue"]) => boolean;
+    change: (val: SelectV2Props["modelValue"]) => boolean;
+    'end-reached': (direction: import("@element-plus/components/scrollbar").ScrollbarDirection) => boolean;
+    'remove-tag': (val: unknown) => boolean;
+    'visible-change': (visible: boolean) => boolean;
+    focus: (evt: FocusEvent) => boolean;
+    blur: (evt: FocusEvent) => boolean;
+    clear: () => boolean;
+};
+export declare const optionV2Emits: {
+    hover: (index?: number) => index is number;
+    select: (val: Option, index?: number) => boolean;
+};
+export type SelectV2Props = ExtractPropTypes<typeof selectV2Props>;
+export type SelectV2PropsPublic = ExtractPublicPropTypes<typeof selectV2Props>;
+export type OptionV2Props = ExtractPropTypes<typeof optionV2Props>;
+export type OptionV2PropsPublic = ExtractPublicPropTypes<typeof optionV2Props>;
+export type SelectV2EmitFn = EmitFn<typeof selectV2Emits>;
+export type OptionV2EmitFn = EmitFn<typeof optionV2Emits>;
+export type SelectV2Instance = InstanceType<typeof SelectV2> & unknown;

package/dist/components/select-v2/src/defaults.js

@@ -0,0 +1,359 @@
+import { placements as i } from "@popperjs/core";
+import "vue";
+import { isBoolean as n, isNumber as l } from "../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import { CHANGE_EVENT as u, UPDATE_MODEL_EVENT as m } from "../../../constants/event.js";
+import { iconPropType as r } from "../../../utils/vue/icon.js";
+import { buildProps as p, definePropType as t } from "../../../utils/vue/props/runtime.js";
+import { useSizeProp as d } from "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import { useAriaProps as s } from "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import { useEmptyValuesProps as f } from "../../../hooks/use-empty-values/index.js";
+import { floatLabelProp as c } from "../../../hooks/use-float-label/index.js";
+import "../../scrollbar/index.js";
+import "../../tooltip/index.js";
+import { ArrowDown as y, CircleClose as b } from "@element-plus/icons-vue";
+import "../../tag/index.js";
+import { defaultProps as g } from "./useProps.js";
+import { useTooltipContentProps as o } from "../../tooltip/src/content.js";
+import { tagProps as a } from "../../tag/tag.js";
+import { scrollbarEmits as B } from "../../scrollbar/src/scrollbar.js";
+const G = p({
+  /**
+   * @description whether creating new items is allowed. To use this, `filterable` must be true
+   */
+  allowCreate: Boolean,
+  /**
+   * @description autocomplete of select input
+   */
+  autocomplete: {
+    type: t(String),
+    default: "none"
+  },
+  /**
+   * @description for non-filterable Select, this prop decides if the option menu pops up when the input is focused
+   */
+  automaticDropdown: Boolean,
+  /**
+   * @description whether select can be cleared
+   */
+  clearable: Boolean,
+  /**
+   * @description custom clear icon
+   */
+  clearIcon: {
+    type: r,
+    default: b
+  },
+  /**
+   * @description tooltip theme, built-in theme: `dark` / `light`
+   */
+  effect: {
+    type: t(String),
+    default: "light"
+  },
+  /**
+   * @description whether to collapse tags to a text when multiple selecting
+   */
+  collapseTags: Boolean,
+  /**
+   * @description whether show all selected tags when mouse hover text of collapse-tags. To use this, `collapse-tags` must be true
+   */
+  collapseTagsTooltip: Boolean,
+  /**
+   * @description configuration object for the collapse-tags tooltip. To use this, `collapse-tags` and `collapse-tags-tooltip` must be true
+   */
+  tagTooltip: {
+    type: t(Object),
+    default: () => ({})
+  },
+  /**
+   * @description The max tags number to be shown. To use this, `collapse-tags` must be true
+   */
+  maxCollapseTags: {
+    type: Number,
+    default: 1
+  },
+  /**
+   * @description
+   */
+  defaultFirstOption: Boolean,
+  /**
+   * @description is disabled
+   */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+   * @description Estimated item height for variable option sizes. Defaults to fixed `itemHeight` when omitted.
+   */
+  estimatedOptionHeight: {
+    type: Number,
+    default: void 0
+  },
+  /**
+   * @description whether Select is filterable
+   */
+  filterable: Boolean,
+  /**
+   * @description custom filter method, the first parameter is the current input value. To use this, `filterable` must be true
+   */
+  filterMethod: {
+    type: t(Function)
+  },
+  /**
+   * @description The height of the dropdown panel, 34px for each item
+   */
+  height: {
+    type: Number,
+    default: 274
+    // same as select dropdown menu
+  },
+  /**
+   * @description The height of the dropdown item
+   */
+  itemHeight: {
+    type: Number,
+    default: 34
+  },
+  /**
+   * @description native input id
+   */
+  id: String,
+  /**
+   * @description whether Select is loading data from server
+   */
+  loading: Boolean,
+  /**
+   * @description displayed text while loading data from server, default is 'Loading'
+   */
+  loadingText: String,
+  /**
+   * @description biding value
+   */
+  modelValue: {
+    type: t([Array, String, Number, Boolean, Object]),
+    default: void 0
+  },
+  /**
+   * @description is multiple
+   */
+  multiple: Boolean,
+  /**
+   * @description maximum number of options user can select when multiple is true. No limit when set to 0
+   */
+  multipleLimit: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description the name attribute of select input
+   */
+  name: String,
+  /**
+   * @description displayed text when there is no options, you can also use slot empty, the default is 'No Data'
+   */
+  noDataText: String,
+  /**
+   * @description displayed text when no data matches the filtering query, you can also use slot `empty`, default is 'No matching data'
+   */
+  noMatchText: String,
+  /**
+   * @description function that gets called when the input value changes. Its parameter is the current input value. To use this, `filterable` must be true
+   */
+  remoteMethod: {
+    type: t(Function)
+  },
+  /**
+   * @description whether reserve the keyword after select filtered option.
+   */
+  reserveKeyword: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description data of the options, the key of `value` and `label` can be customize by `props`
+   */
+  options: {
+    type: t(Array),
+    required: !0
+  },
+  /**
+   * @description placeholder, the default is 'Please select'
+   */
+  placeholder: {
+    type: String
+  },
+  /**
+   * @description whether select dropdown is teleported, if `true` it will be teleported to where `append-to` sets
+   */
+  teleported: o.teleported,
+  /**
+   * @description when select dropdown is inactive and `persistent` is `false`, select dropdown will be destroyed
+   */
+  persistent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description custom class name for Select's dropdown
+   */
+  popperClass: o.popperClass,
+  /**
+   * @description custom style for Select's dropdown
+   */
+  popperStyle: o.popperStyle,
+  /**
+   * @description [popper.js](https://popper.js.org/docs/v2/) parameters
+   */
+  popperOptions: {
+    type: t(Object),
+    default: () => ({})
+  },
+  /**
+   * @description whether search data from server
+   */
+  remote: Boolean,
+  /**
+   * @description debounce delay during remote search, in milliseconds
+   */
+  debounce: {
+    type: Number,
+    default: 300
+  },
+  /**
+   * @description size of component
+   */
+  size: d,
+  /**
+   * @description configuration options, see the following table
+   */
+  props: {
+    type: t(Object),
+    default: () => g
+  },
+  /**
+   * @description unique identity key name for value, required when value is an object
+   */
+  valueKey: {
+    type: String,
+    default: "value"
+  },
+  /**
+   * @description Controls whether the scrollbar is always displayed
+   */
+  scrollbarAlwaysOn: Boolean,
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description offset of the dropdown
+   */
+  offset: {
+    type: Number,
+    default: 12
+  },
+  /**
+   * @description in remote search method show suffix icon
+   */
+  remoteShowSuffix: Boolean,
+  /**
+   * @description Determines whether the arrow is displayed
+   */
+  showArrow: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description position of dropdown
+   */
+  placement: {
+    type: t(String),
+    values: i,
+    default: "bottom-start"
+  },
+  /**
+   * @description list of possible positions for dropdown
+   */
+  fallbackPlacements: {
+    type: t(Array),
+    default: ["bottom-start", "top-start", "right", "left"]
+  },
+  /**
+   * @description tag type
+   */
+  tagType: { ...a.type, default: "info" },
+  /**
+   * @description tag effect
+   */
+  tagEffect: { ...a.effect, default: "light" },
+  /**
+   * @description tabindex for input
+   */
+  tabindex: {
+    type: [String, Number],
+    default: 0
+  },
+  /**
+   * @description which element the select dropdown appends to
+   */
+  appendTo: o.appendTo,
+  /**
+   * @description if it is `true`, the width of the dropdown panel is the same as the input box.
+   * if it is `false`, the width is automatically calculated based on the value of `label`,
+   * or it can be set to a number to make it a fixed width
+   */
+  fitInputWidth: {
+    type: [Boolean, Number],
+    default: !0,
+    validator(e) {
+      return n(e) || l(e);
+    }
+  },
+  suffixIcon: {
+    type: r,
+    default: y
+  },
+  ...c,
+  ...f,
+  ...s(["ariaLabel"])
+}), U = p({
+  data: Array,
+  disabled: Boolean,
+  hovering: Boolean,
+  item: {
+    type: t(Object),
+    required: !0
+  },
+  index: Number,
+  style: Object,
+  selected: Boolean,
+  created: Boolean
+}), W = {
+  [m]: (e) => !0,
+  [u]: (e) => !0,
+  "end-reached": B["end-reached"],
+  "remove-tag": (e) => !0,
+  "visible-change": (e) => !0,
+  focus: (e) => e instanceof FocusEvent,
+  blur: (e) => e instanceof FocusEvent,
+  clear: () => !0
+}, J = {
+  hover: (e) => l(e),
+  select: (e, v) => !0
+};
+export {
+  J as optionV2Emits,
+  U as optionV2Props,
+  W as selectV2Emits,
+  G as selectV2Props
+};

package/dist/components/select-v2/src/group-item.vue.d.ts

@@ -0,0 +1,40 @@
+import type { CSSProperties, PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    item: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+    };
+    height: NumberConstructor;
+}>, {
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    item: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+    };
+    height: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/select-v2/src/group-item.vue.js

@@ -0,0 +1,13 @@
+import t from "./group-item2.vue.js";
+import { openBlock as o, createElementBlock as r, normalizeStyle as i, normalizeClass as l, toDisplayString as s } from "vue";
+import n from "../../../_virtual/_plugin-vue_export-helper.js";
+function p(e, a, m, c, f, u) {
+  return o(), r("div", {
+    class: l(e.ns.be("group", "title")),
+    style: i({ ...e.style, lineHeight: `${e.height}px` })
+  }, s(e.item.label), 7);
+}
+const h = /* @__PURE__ */ n(t, [["render", p]]);
+export {
+  h as default
+};