ele-admin-plus 1.2.2-beta.5 → 1.3.0-beta.3

package/lib/ele-radio-group/props.d.ts

@@ -0,0 +1,28 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { RadioType, RadioOption, RadioOptionFunction } from './types';
+
+export { radioGroupEmits } from 'element-plus';
+/**
+ * 属性
+ */
+export declare const radioGroupProps: {
+    /** 风格类型 */
+    type: PropType<RadioType>;
+    /** 选项数据 */
+    options: PropType<RadioOption[] | RadioOptionFunction>;
+    ariaLabel: StringConstructor;
+    id: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    size: {
+        readonly type: import('@vue/runtime-core').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+    modelValue: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+    fill: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    textColor: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    name: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+};
+export type RadioGroupProps = ExtractPropTypes<typeof radioGroupProps>;

package/lib/ele-radio-group/style/index.cjs

@@ -0,0 +1,4 @@
+"use strict";
+require("element-plus/es/components/radio-group/style/index");
+require("element-plus/es/components/radio/style/index");
+require("element-plus/es/components/radio-button/style/index");

package/lib/ele-radio-group/style/index.d.ts

@@ -0,0 +1 @@
+

package/lib/ele-radio-group/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 风格类型
+ */
+export type RadioType = 'default' | 'button';
+
+/**
+ * 选项数据
+ */
+export interface RadioOption {
+  /** 选项值 */
+  value: any;
+  /** 显示文本 */
+  label?: string;
+  /** 是否禁用 */
+  disabled?: boolean;
+  /** 是否显示边框 */
+  border?: boolean;
+  /** name */
+  name?: string;
+}
+
+/**
+ * 选项数据请求函数
+ */
+export type RadioOptionFunction = () => Promise<RadioOption[]>;

package/lib/ele-segmented/types.d.ts

@@ -1,5 +1,4 @@
-import type { Component } from 'vue';
-import type { StyleValue } from '../ele-app/types';
+import type { StyleValue, UserComponent } from '../ele-app/types';
 import type { ElIconProps } from '../ele-app/el';
 
 /**
@@ -16,7 +15,7 @@ export interface SegmentedItem extends Record<keyof any, any> {
   /** 值 */
   value: string | number;
   /** 图标 */
-  icon?: string | Component;
+  icon?: UserComponent;
   /** 是否禁用 */
   disabled?: boolean;
   /** 自定义样式 */

package/lib/ele-select/index.cjs

@@ -0,0 +1,85 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const core = require("../utils/core");
+const hook = require("../utils/hook");
+const props = require("./props");
+const _sfc_main = vue.defineComponent({
+  name: "EleSelect",
+  components: { ElSelect: elementPlus.ElSelect, ElOptionGroup: elementPlus.ElOptionGroup, ElOption: elementPlus.ElOption },
+  props: props.selectProps,
+  emits: props.selectEmits,
+  setup(props$1, { emit }) {
+    const { emitMethods } = hook.useComponentEvents(props.selectEmits, emit);
+    const { optionData, reloadOptions } = hook.useProOptions(props$1);
+    return {
+      omit: core.omit,
+      emitMethods,
+      optionData,
+      reloadOptions
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElOption = vue.resolveComponent("ElOption");
+  const _component_ElOptionGroup = vue.resolveComponent("ElOptionGroup");
+  const _component_ElSelect = vue.resolveComponent("ElSelect");
+  return vue.openBlock(), vue.createBlock(_component_ElSelect, vue.mergeProps(_ctx.omit(_ctx.$props, ["options"]), {
+    "onUpdate:modelValue": _ctx.emitMethods["update:modelValue"],
+    onChange: _ctx.emitMethods["change"],
+    onRemoveTag: _ctx.emitMethods["remove-tag"],
+    onClear: _ctx.emitMethods["clear"],
+    onVisibleChange: _ctx.emitMethods["visible-change"],
+    onFocus: _ctx.emitMethods["focus"],
+    onBlur: _ctx.emitMethods["blur"]
+  }), vue.createSlots({
+    default: vue.withCtx(() => [
+      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.optionData, (option) => {
+        return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+          key: option.value
+        }, [
+          option.children ? (vue.openBlock(), vue.createBlock(_component_ElOptionGroup, {
+            key: 0,
+            label: option.label
+          }, {
+            default: vue.withCtx(() => [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(option.children, (childOption) => {
+                return vue.openBlock(), vue.createBlock(_component_ElOption, {
+                  key: childOption.value,
+                  label: childOption.label,
+                  value: childOption.value,
+                  disabled: childOption.disabled
+                }, null, 8, ["label", "value", "disabled"]);
+              }), 128))
+            ]),
+            _: 2
+          }, 1032, ["label"])) : (vue.openBlock(), vue.createBlock(_component_ElOption, {
+            key: 1,
+            label: option.label,
+            value: option.value,
+            disabled: option.disabled
+          }, null, 8, ["label", "value", "disabled"]))
+        ], 64);
+      }), 128))
+    ]),
+    _: 2
+  }, [
+    vue.renderList(Object.keys(_ctx.$slots).filter((k) => "default" !== k), (name) => {
+      return {
+        name,
+        fn: vue.withCtx((slotProps) => [
+          vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+        ])
+      };
+    })
+  ]), 1040, ["onUpdate:modelValue", "onChange", "onRemoveTag", "onClear", "onVisibleChange", "onFocus", "onBlur"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;

package/lib/ele-select/index.d.ts

@@ -0,0 +1,219 @@
+import { omit } from '../utils/core';
+import { SelectOption } from './types';
+
+declare const _default: import('vue').DefineComponent<{
+    options: import('vue').PropType<SelectOption[] | import('./types').SelectOptionFunction>;
+    ariaLabel: StringConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown, undefined, boolean>;
+    name: StringConstructor;
+    id: StringConstructor;
+    modelValue: import('element-plus/es/utils/index').EpPropFinalized<(ArrayConstructor | ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown, undefined, boolean>;
+    autocomplete: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    automaticDropdown: BooleanConstructor;
+    size: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    effect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, string, boolean>;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    allowCreate: BooleanConstructor;
+    loading: BooleanConstructor;
+    popperClass: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    popperOptions: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => Partial<import('element-plus').Options>) | (() => Partial<import('element-plus').Options>) | ((new (...args: any[]) => Partial<import('element-plus').Options>) | (() => Partial<import('element-plus').Options>))[], unknown, unknown, () => Partial<import('element-plus').Options>, boolean>;
+    remote: BooleanConstructor;
+    loadingText: StringConstructor;
+    noMatchText: StringConstructor;
+    noDataText: StringConstructor;
+    remoteMethod: FunctionConstructor;
+    filterMethod: FunctionConstructor;
+    multiple: BooleanConstructor;
+    multipleLimit: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    placeholder: {
+        readonly type: import('vue').PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultFirstOption: BooleanConstructor;
+    reserveKeyword: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    valueKey: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    collapseTags: BooleanConstructor;
+    collapseTagsTooltip: BooleanConstructor;
+    maxCollapseTags: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    persistent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    clearIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    fitInputWidth: BooleanConstructor;
+    suffixIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagType: {
+        default: string;
+        type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "success" | "warning" | "info" | "primary" | "danger", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagEffect: {
+        default: string;
+        type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    remoteShowSuffix: BooleanConstructor;
+    placement: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').Placement & {}) | (() => import('element-plus').Placement) | ((new (...args: any[]) => import('element-plus').Placement & {}) | (() => import('element-plus').Placement))[], import('element-plus').Placement, unknown, string, boolean>;
+    fallbackPlacements: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').Placement[]) | (() => import('element-plus').Placement[]) | ((new (...args: any[]) => import('element-plus').Placement[]) | (() => import('element-plus').Placement[]))[], unknown, unknown, string[], boolean>;
+}, {
+    omit: typeof omit;
+    emitMethods: {
+        blur: (_e: FocusEvent) => void;
+        change: (_value: any) => void;
+        focus: (_e: FocusEvent) => void;
+        clear: () => void;
+        "update:modelValue": (_value: any) => void;
+        "visible-change": (_visible: boolean) => void;
+        "remove-tag": (_value: any) => void;
+    };
+    optionData: import('vue').Ref<SelectOption[]>;
+    reloadOptions: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:modelValue': (_value: any) => boolean;
+    change: (_value: any) => boolean;
+    'remove-tag': (_value: any) => boolean;
+    clear: () => boolean;
+    'visible-change': (_visible: boolean) => boolean;
+    focus: (_e: FocusEvent) => boolean;
+    blur: (_e: FocusEvent) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    options: import('vue').PropType<SelectOption[] | import('./types').SelectOptionFunction>;
+    ariaLabel: StringConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown, undefined, boolean>;
+    name: StringConstructor;
+    id: StringConstructor;
+    modelValue: import('element-plus/es/utils/index').EpPropFinalized<(ArrayConstructor | ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown, undefined, boolean>;
+    autocomplete: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    automaticDropdown: BooleanConstructor;
+    size: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    effect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, string, boolean>;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    allowCreate: BooleanConstructor;
+    loading: BooleanConstructor;
+    popperClass: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    popperOptions: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => Partial<import('element-plus').Options>) | (() => Partial<import('element-plus').Options>) | ((new (...args: any[]) => Partial<import('element-plus').Options>) | (() => Partial<import('element-plus').Options>))[], unknown, unknown, () => Partial<import('element-plus').Options>, boolean>;
+    remote: BooleanConstructor;
+    loadingText: StringConstructor;
+    noMatchText: StringConstructor;
+    noDataText: StringConstructor;
+    remoteMethod: FunctionConstructor;
+    filterMethod: FunctionConstructor;
+    multiple: BooleanConstructor;
+    multipleLimit: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    placeholder: {
+        readonly type: import('vue').PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultFirstOption: BooleanConstructor;
+    reserveKeyword: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    valueKey: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    collapseTags: BooleanConstructor;
+    collapseTagsTooltip: BooleanConstructor;
+    maxCollapseTags: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    persistent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    clearIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    fitInputWidth: BooleanConstructor;
+    suffixIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagType: {
+        default: string;
+        type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "success" | "warning" | "info" | "primary" | "danger", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagEffect: {
+        default: string;
+        type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    remoteShowSuffix: BooleanConstructor;
+    placement: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').Placement & {}) | (() => import('element-plus').Placement) | ((new (...args: any[]) => import('element-plus').Placement & {}) | (() => import('element-plus').Placement))[], import('element-plus').Placement, unknown, string, boolean>;
+    fallbackPlacements: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').Placement[]) | (() => import('element-plus').Placement[]) | ((new (...args: any[]) => import('element-plus').Placement[]) | (() => import('element-plus').Placement[]))[], unknown, unknown, string[], boolean>;
+}>> & {
+    "onUpdate:modelValue"?: ((_value: any) => any) | undefined;
+    onChange?: ((_value: any) => any) | undefined;
+    onFocus?: ((_e: FocusEvent) => any) | undefined;
+    onBlur?: ((_e: FocusEvent) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onVisible-change"?: ((_visible: boolean) => any) | undefined;
+    "onRemove-tag"?: ((_value: any) => any) | undefined;
+}, {
+    placement: import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus').Placement & {}) | (() => import('element-plus').Placement) | ((new (...args: any[]) => import('element-plus').Placement & {}) | (() => import('element-plus').Placement))[], import('element-plus').Placement, unknown>;
+    valueOnClear: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown>;
+    modelValue: import('element-plus/es/utils/index').EpPropMergeType<(ArrayConstructor | StringConstructor | ObjectConstructor | NumberConstructor | BooleanConstructor)[], unknown, unknown>;
+    autocomplete: string;
+    automaticDropdown: boolean;
+    effect: string;
+    disabled: boolean;
+    clearable: boolean;
+    filterable: boolean;
+    allowCreate: boolean;
+    loading: boolean;
+    popperClass: string;
+    popperOptions: Partial<import('element-plus').Options>;
+    remote: boolean;
+    multiple: boolean;
+    multipleLimit: number;
+    defaultFirstOption: boolean;
+    reserveKeyword: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    valueKey: string;
+    collapseTags: boolean;
+    collapseTagsTooltip: boolean;
+    maxCollapseTags: number;
+    teleported: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    persistent: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    fitInputWidth: boolean;
+    tagType: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "success" | "warning" | "info" | "primary" | "danger", unknown>;
+    tagEffect: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>;
+    validateEvent: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    remoteShowSuffix: boolean;
+    fallbackPlacements: import('element-plus').Placement[];
+}, {}>;
+export default _default;

package/lib/ele-select/props.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const select = require("element-plus/es/components/select/src/select");
+const selectProps = {
+  ...select.SelectProps,
+  /** 选项数据 */
+  options: [Array, Function]
+};
+const selectEmits = {
+  "update:modelValue": (_value) => true,
+  change: (_value) => true,
+  "remove-tag": (_value) => true,
+  clear: () => true,
+  "visible-change": (_visible) => true,
+  focus: (_e) => true,
+  blur: (_e) => true
+};
+exports.selectEmits = selectEmits;
+exports.selectProps = selectProps;

package/lib/ele-select/props.d.ts

@@ -0,0 +1,98 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { SelectOption, SelectOptionFunction } from './types';
+
+/**
+ * 属性
+ */
+export declare const selectProps: {
+    /** 选项数据 */
+    options: PropType<SelectOption[] | SelectOptionFunction>;
+    ariaLabel: StringConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown, undefined, boolean>;
+    name: StringConstructor;
+    id: StringConstructor;
+    modelValue: import('element-plus/es/utils/index').EpPropFinalized<(ArrayConstructor | ObjectConstructor | NumberConstructor | StringConstructor | BooleanConstructor)[], unknown, unknown, undefined, boolean>;
+    autocomplete: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    automaticDropdown: BooleanConstructor;
+    size: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    effect: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, string, boolean>;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    allowCreate: BooleanConstructor;
+    loading: BooleanConstructor;
+    popperClass: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    popperOptions: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => Partial<import('@popperjs/core').Options>) | (() => Partial<import('@popperjs/core').Options>) | ((new (...args: any[]) => Partial<import('@popperjs/core').Options>) | (() => Partial<import('@popperjs/core').Options>))[], unknown, unknown, () => Partial<import('@popperjs/core').Options>, boolean>;
+    remote: BooleanConstructor;
+    loadingText: StringConstructor;
+    noMatchText: StringConstructor;
+    noDataText: StringConstructor;
+    remoteMethod: FunctionConstructor;
+    filterMethod: FunctionConstructor;
+    multiple: BooleanConstructor;
+    multipleLimit: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    placeholder: {
+        readonly type: import('vue').PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    defaultFirstOption: BooleanConstructor;
+    reserveKeyword: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    valueKey: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    collapseTags: BooleanConstructor;
+    collapseTagsTooltip: BooleanConstructor;
+    maxCollapseTags: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    persistent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    clearIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    fitInputWidth: BooleanConstructor;
+    suffixIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) | ((new (...args: any[]) => (string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>) & {}) | (() => string | import('vue').Component<any, any, any, import('vue').ComputedOptions, import('vue').MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagType: {
+        default: string;
+        type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "success" | "warning" | "info" | "primary" | "danger", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagEffect: {
+        default: string;
+        type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "dark" | "light" | "plain", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    remoteShowSuffix: BooleanConstructor;
+    placement: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('@popperjs/core').Placement & {}) | (() => import('@popperjs/core').Placement) | ((new (...args: any[]) => import('@popperjs/core').Placement & {}) | (() => import('@popperjs/core').Placement))[], import('@popperjs/core').Placement, unknown, string, boolean>;
+    fallbackPlacements: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('@popperjs/core').Placement[]) | (() => import('@popperjs/core').Placement[]) | ((new (...args: any[]) => import('@popperjs/core').Placement[]) | (() => import('@popperjs/core').Placement[]))[], unknown, unknown, string[], boolean>;
+};
+export type SelectProps = ExtractPropTypes<typeof selectProps>;
+/**
+ * 事件
+ */
+export declare const selectEmits: {
+    'update:modelValue': (_value: any) => boolean;
+    change: (_value: any) => boolean;
+    'remove-tag': (_value: any) => boolean;
+    clear: () => boolean;
+    'visible-change': (_visible: boolean) => boolean;
+    focus: (_e: FocusEvent) => boolean;
+    blur: (_e: FocusEvent) => boolean;
+};

package/lib/ele-select/style/index.cjs

@@ -0,0 +1,4 @@
+"use strict";
+require("element-plus/es/components/select/style/index");
+require("element-plus/es/components/option-group/style/index");
+require("element-plus/es/components/option/style/index");

package/lib/ele-select/style/index.d.ts

@@ -0,0 +1 @@
+

package/lib/ele-select/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 选项数据
+ */
+export interface SelectOption {
+  /** 选项值 */
+  value: any;
+  /** 显示文本 */
+  label?: string;
+  /** 是否禁用 */
+  disabled?: boolean;
+  /** 子级 */
+  children?: Array<{
+    /** 子级选项值 */
+    value: any;
+    /** 子级显示文本 */
+    label?: string;
+    /** 子级是否禁用 */
+    disabled?: boolean;
+  }>;
+}
+
+/**
+ * 选项数据请求函数
+ */
+export type SelectOptionFunction = () => Promise<SelectOption[]>;

package/lib/ele-select-tree/index.cjs

@@ -0,0 +1,56 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const core = require("../utils/core");
+const hook = require("../utils/hook");
+const selectTreeProps = elementPlus.ElTreeSelect.props;
+const selectTreeEmits = {
+  "update:modelValue": (_value) => true
+};
+const _sfc_main = vue.defineComponent({
+  name: "EleSelectTree",
+  components: { ElTreeSelect: elementPlus.ElTreeSelect },
+  props: {
+    ...core.omit(selectTreeProps, ["data", "onUpdate:modelValue"]),
+    data: [Array, Function]
+  },
+  emits: selectTreeEmits,
+  setup(props, { emit }) {
+    const { emitMethods } = hook.useComponentEvents(selectTreeEmits, emit);
+    const { optionData, reloadOptions } = hook.useProOptions(
+      props,
+      "data"
+    );
+    return {
+      omit: core.omit,
+      emitMethods,
+      optionData,
+      reloadOptions
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElTreeSelect = vue.resolveComponent("ElTreeSelect");
+  return vue.openBlock(), vue.createBlock(_component_ElTreeSelect, vue.mergeProps(_ctx.omit(_ctx.$props, ["data"]), {
+    data: _ctx.optionData,
+    "onUpdate:modelValue": _ctx.emitMethods["update:modelValue"]
+  }), vue.createSlots({ _: 2 }, [
+    vue.renderList(Object.keys(_ctx.$slots), (name) => {
+      return {
+        name,
+        fn: vue.withCtx((slotProps) => [
+          vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+        ])
+      };
+    })
+  ]), 1040, ["data", "onUpdate:modelValue"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;

package/lib/ele-select-tree/index.d.ts

@@ -0,0 +1,21 @@
+import { PropType } from 'vue';
+import { omit } from '../utils/core';
+import { SelectTreeData, SelectTreeDataFunction } from './types';
+
+declare const _default: import('vue').DefineComponent<{
+    data: PropType<SelectTreeData | SelectTreeDataFunction>;
+}, {
+    omit: typeof omit;
+    emitMethods: {
+        "update:modelValue": (_value: any) => void;
+    };
+    optionData: import('vue').Ref<Record<string, any>[]>;
+    reloadOptions: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:modelValue': (_value: any) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    data: PropType<SelectTreeData | SelectTreeDataFunction>;
+}>> & {
+    "onUpdate:modelValue"?: ((_value: any) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/lib/ele-select-tree/style/index.cjs

@@ -0,0 +1,2 @@
+"use strict";
+require("element-plus/es/components/tree-select/style/index");

package/lib/ele-select-tree/style/index.d.ts

@@ -0,0 +1 @@
+