ele-admin-plus 1.2.2-beta.4 → 1.3.0-beta.2

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,79 @@
+"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, { emit }) {
+    const { emitMethods } = hook.useComponentEvents(props.selectEmits, emit);
+    return { omit: core.omit, emitMethods };
+  }
+});
+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(() => [
+      _ctx.options ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.options, (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)) : vue.createCommentVNode("", true)
+    ]),
+    _: 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,208 @@
+import { omit } from '../utils/core';
+
+declare const _default: import('vue').DefineComponent<{
+    options: import('vue').PropType<import('./types').SelectOption[]>;
+    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: Record<string, (...params: any) => 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<import('./types').SelectOption[]>;
+    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
+};
+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 } from './types';
+
+/**
+ * 属性
+ */
+export declare const selectProps: {
+    /** 选项数据 */
+    options: PropType<SelectOption[]>;
+    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,20 @@
+/**
+ * 下拉选项数据
+ */
+export interface SelectOption {
+  /** 选项值 */
+  value: any;
+  /** 显示文本 */
+  label?: string;
+  /** 是否禁用 */
+  disabled?: boolean;
+  /** 子级 */
+  children?: Array<{
+    /** 子级选项值 */
+    value: any;
+    /** 子级显示文本 */
+    label?: string;
+    /** 子级是否禁用 */
+    disabled?: boolean;
+  }>;
+}

package/lib/ele-tab-wrap/index.cjs

@@ -38,7 +38,7 @@ const _sfc_main = vue.defineComponent({
         data.type = props2.type;
       }
     );
-    vue.onBeforeMount(() => {
+    vue.onBeforeUnmount(() => {
       tabMethods.triggerTabItemClick = void 0;
       tabMethods.triggerItemContextMenu = void 0;
     });

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

@@ -1,4 +1,4 @@
-import type { Component } from 'vue';
+import type { UserComponent } from '../ele-app/types';
 
 /**
  * 文本类型
@@ -32,4 +32,4 @@ export type TextSize =
 /**
  * 图标
  */
-export type TextIcon = string | Component;
+export type TextIcon = UserComponent;

package/lib/ele-timeline/index.cjs

@@ -0,0 +1,168 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const icons = require("../icons");
+const props = require("./props");
+const _sfc_main = vue.defineComponent({
+  name: "EleTimeline",
+  components: { ElIcon: elementPlus.ElIcon, CheckCircleFilled: icons.CheckCircleFilled },
+  props: props.timelineProps,
+  emits: props.timelineEmits,
+  setup(props2, { emit }) {
+    const listRef = vue.ref(null);
+    const listWidth = vue.ref(0);
+    const listColNum = vue.computed(() => {
+      return Math.floor(listWidth.value / props2.itemWidth) || 1;
+    });
+    const lineRows = vue.computed(() => {
+      var _a;
+      const rows = [];
+      const data = props2.data || [];
+      const colNum = listColNum.value;
+      const rowNum = colNum ? Math.ceil(data.length / colNum) : 1;
+      for (let i = 0; i < rowNum; i++) {
+        const cells = [];
+        for (let j = 0; j < colNum; j++) {
+          const index2 = i * colNum + j;
+          const itemData = data[index2];
+          cells.push({
+            key: (itemData == null ? void 0 : itemData.key) ?? `${i}_${j}`,
+            data: itemData,
+            dataIndex: index2,
+            nextDataType: (_a = data[index2 + 1]) == null ? void 0 : _a.type,
+            isFirst: itemData && index2 === 0,
+            isLast: itemData && index2 === data.length - 1
+          });
+        }
+        const key = i + "_" + cells.map((d) => (d == null ? void 0 : d.key) ?? "").join();
+        rows.push({
+          key,
+          items: cells,
+          isEvenRow: (i + 1) % 2 === 0
+        });
+      }
+      return rows;
+    });
+    const handleItemClick = (item) => {
+      if (item) {
+        emit("itemClick", item);
+      }
+    };
+    const observer = new ResizeObserver(() => {
+      const listEl = listRef.value;
+      listWidth.value = (listEl == null ? void 0 : listEl.clientWidth) || 0;
+    });
+    vue.onMounted(() => {
+      const listEl = listRef.value;
+      listEl && observer.observe(listEl);
+    });
+    vue.onBeforeUnmount(() => {
+      const listEl = listRef.value;
+      listEl && observer.unobserve(listEl);
+    });
+    return {
+      listRef,
+      lineRows,
+      handleItemClick
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = {
+  ref: "listRef",
+  class: "ele-time-line-list"
+};
+const _hoisted_2 = ["onClick"];
+const _hoisted_3 = { class: "ele-time-line-item-icon" };
+const _hoisted_4 = { class: "ele-time-line-item-body" };
+const _hoisted_5 = { class: "ele-time-line-item-title" };
+const _hoisted_6 = { class: "ele-time-line-item-description" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_CheckCircleFilled = vue.resolveComponent("CheckCircleFilled");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.lineRows, (row) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        key: row.key,
+        class: vue.normalizeClass(["ele-time-line-row", { "is-even-row": row.isEvenRow }])
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row.items, (col) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: col.key,
+            class: vue.normalizeClass([
+              "ele-time-line-item",
+              { "is-first": col.isFirst },
+              { "is-last": col.isLast },
+              { "is-primary": col.data && col.data.type === "primary" },
+              { "is-placeholder": !col.data }
+            ]),
+            onClick: ($event) => _ctx.handleItemClick(col.data)
+          }, [
+            col.data ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+              vue.createElementVNode("div", _hoisted_3, [
+                vue.createElementVNode("div", {
+                  class: vue.normalizeClass([
+                    "ele-time-line-item-line is-start",
+                    { "is-primary-line": col.data.type === "primary" }
+                  ])
+                }, null, 2),
+                vue.createVNode(_component_ElIcon, vue.mergeProps({
+                  class: "ele-time-line-item-icon-status",
+                  ref_for: true
+                }, col.data.iconProps || {}), {
+                  default: vue.withCtx(() => [
+                    vue.renderSlot(_ctx.$slots, "itemIcon", {
+                      item: col.data
+                    }, () => [
+                      col.data.icon ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(col.data.icon), {
+                        key: 0,
+                        style: vue.normalizeStyle(col.data.iconStyle)
+                      }, null, 8, ["style"])) : (vue.openBlock(), vue.createBlock(_component_CheckCircleFilled, {
+                        key: 1,
+                        style: vue.normalizeStyle(col.data.iconStyle)
+                      }, null, 8, ["style"]))
+                    ])
+                  ]),
+                  _: 2
+                }, 1040),
+                vue.createElementVNode("div", {
+                  class: vue.normalizeClass([
+                    "ele-time-line-item-line is-end",
+                    { "is-primary-line": col.nextDataType === "primary" }
+                  ])
+                }, null, 2)
+              ]),
+              !col.isLast ? (vue.openBlock(), vue.createElementBlock("div", {
+                key: 0,
+                class: vue.normalizeClass([
+                  "ele-time-line-item-line-turn",
+                  { "is-primary-line": col.nextDataType === "primary" }
+                ])
+              }, null, 2)) : vue.createCommentVNode("", true),
+              vue.createElementVNode("div", _hoisted_4, [
+                vue.renderSlot(_ctx.$slots, "itemTitle", {
+                  item: col.data
+                }, () => [
+                  vue.createElementVNode("div", _hoisted_5, vue.toDisplayString(col.data.title), 1)
+                ]),
+                vue.renderSlot(_ctx.$slots, "itemDescription", {
+                  item: col.data
+                }, () => [
+                  vue.createElementVNode("div", _hoisted_6, vue.toDisplayString(col.data.description), 1)
+                ])
+              ])
+            ], 64)) : vue.createCommentVNode("", true)
+          ], 10, _hoisted_2);
+        }), 128))
+      ], 2);
+    }), 128))
+  ], 512);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;