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

package/lib/ele-autocomplete/props.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const elementPlus = require("element-plus");
+const autocompleteProps = {
+  ...elementPlus.autocompleteProps,
+  /** 建议数据 */
+  fetchSuggestions: [Array, Function]
+};
+Object.defineProperty(exports, "autocompleteEmits", {
+  enumerable: true,
+  get: () => elementPlus.autocompleteEmits
+});
+exports.autocompleteProps = autocompleteProps;

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

@@ -0,0 +1,27 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { AutocompleteDataItem, AutocompleteDataFunction } from './types';
+
+export { autocompleteEmits } from 'element-plus';
+/**
+ * 属性
+ */
+export declare const autocompleteProps: {
+    /** 建议数据 */
+    fetchSuggestions: PropType<AutocompleteDataItem[] | AutocompleteDataFunction>;
+    ariaLabel: StringConstructor;
+    valueKey: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "value", boolean>;
+    modelValue: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    debounce: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+    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))[], "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end", unknown, "bottom-start", boolean>;
+    popperClass: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    triggerOnFocus: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    selectWhenUnmatched: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    hideLoading: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    highlightFirstItem: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    fitInputWidth: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    clearable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    disabled: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    name: StringConstructor;
+};
+export type AutocompleteProps = ExtractPropTypes<typeof autocompleteProps>;

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,18 @@
+import type { AutocompleteFetchSuggestionsCallback } from 'element-plus';
+export type ElFetchSuggestionsCallback = AutocompleteFetchSuggestionsCallback;
+
+/**
+ * 建议数据项
+ */
+export interface AutocompleteDataItem extends Record<string, any> {
+  /** 值 */
+  value?: string;
+}
+
+/**
+ * 建议数据请求函数
+ */
+export type AutocompleteDataFunction = (
+  keyword: string,
+  cb: ElFetchSuggestionsCallback
+) => Promise<AutocompleteDataItem[]> | void;

package/lib/ele-breadcrumb/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,
   ElBreadcrumbProps,
@@ -22,7 +21,7 @@ export interface BreadcrumbItem extends ElBreadcrumbItemProps {
   /** 标题 */
   title?: string;
   /** 图标 */
-  icon?: string | Component;
+  icon?: UserComponent;
   /** 图标属性 */
   iconProps?: ElIconProps;
   /** 图标样式 */

package/lib/ele-cascader/index.cjs

@@ -0,0 +1,98 @@
+"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: "EleCascader",
+  components: { ElCascader: elementPlus.ElCascader },
+  props: props.cascaderProps,
+  emits: props.cascaderEmits,
+  setup(props$1, { emit }) {
+    var _a;
+    const { emitMethods } = hook.useComponentEvents(props.cascaderEmits, emit);
+    const { optionData, reloadOptions } = hook.useProOptions(props$1);
+    const cascaderProps2 = vue.reactive({
+      ...props$1.props || {},
+      multiple: !!(props$1.multiple || ((_a = props$1.props) == null ? void 0 : _a.multiple))
+    });
+    vue.watch(
+      [() => props$1.multiple, () => props$1.props],
+      () => {
+        const cProps = props$1.props || {};
+        [
+          "expandTrigger",
+          "checkStrictly",
+          "emitPath",
+          "lazy",
+          "lazyLoad",
+          "value",
+          "label",
+          "children",
+          "disabled",
+          "leaf",
+          "hoverThreshold"
+        ].forEach((k) => {
+          if (cascaderProps2[k] == null && cProps[k] == null) {
+            return;
+          }
+          if (cascaderProps2[k] !== cProps[k]) {
+            cascaderProps2[k] = cProps[k];
+          }
+        });
+        if (props$1.multiple) {
+          if (!cascaderProps2.multiple) {
+            cascaderProps2.multiple = true;
+          }
+        } else if (!!cascaderProps2.multiple !== !!cProps.multiple) {
+          cascaderProps2.multiple = cProps.multiple;
+        }
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    return {
+      omit: core.omit,
+      emitMethods,
+      optionData,
+      reloadOptions,
+      cascaderProps: cascaderProps2
+    };
+  }
+});
+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_ElCascader = vue.resolveComponent("ElCascader");
+  return vue.openBlock(), vue.createBlock(_component_ElCascader, vue.mergeProps(_ctx.omit(_ctx.$props, ["props", "options", "multiple"]), {
+    props: _ctx.cascaderProps,
+    options: _ctx.optionData,
+    "onUpdate:modelValue": _ctx.emitMethods["update:modelValue"],
+    onChange: _ctx.emitMethods["change"],
+    onFocus: _ctx.emitMethods["focus"],
+    onBlur: _ctx.emitMethods["blur"],
+    onClear: _ctx.emitMethods["clear"],
+    onVisibleChange: _ctx.emitMethods["visibleChange"],
+    onExpandChange: _ctx.emitMethods["expandChange"],
+    onRemoveTag: _ctx.emitMethods["removeTag"]
+  }), 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, ["props", "options", "onUpdate:modelValue", "onChange", "onFocus", "onBlur", "onClear", "onVisibleChange", "onExpandChange", "onRemoveTag"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;

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

@@ -0,0 +1,207 @@
+import { CascaderProps } from 'element-plus';
+import { omit } from '../utils/core';
+import { CascaderOption } from './types';
+
+declare const _default: import('vue').DefineComponent<{
+    options: import('vue').PropType<CascaderOption[] | import('./types').CascaderOptionFunction>;
+    multiple: BooleanConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown, undefined, boolean>;
+    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;
+    };
+    placeholder: StringConstructor;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    filterMethod: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | (() => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | {
+        (): (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | (() => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | {
+        (): (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, (node: import('element-plus').CascaderNode, keyword: string) => boolean, boolean>;
+    separator: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    showAllLevels: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    collapseTags: BooleanConstructor;
+    maxCollapseTags: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    collapseTagsTooltip: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    debounce: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    beforeFilter: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (value: string) => boolean | Promise<any>) | (() => (value: string) => boolean | Promise<any>) | {
+        (): (value: string) => boolean | Promise<any>;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => (value: string) => boolean | Promise<any>) | (() => (value: string) => boolean | Promise<any>) | {
+        (): (value: string) => boolean | Promise<any>;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, () => true, boolean>;
+    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>;
+    popperClass: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    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>;
+    persistent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    modelValue: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus/es/components/cascader-panel/src/node').CascaderValue & {}) | (() => import('element-plus/es/components/cascader-panel/src/node').CascaderValue) | ((new (...args: any[]) => import('element-plus/es/components/cascader-panel/src/node').CascaderValue & {}) | (() => import('element-plus/es/components/cascader-panel/src/node').CascaderValue))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    props: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/cascader-panel/index').CascaderProps) | (() => import('element-plus/es/components/cascader-panel/index').CascaderProps) | ((new (...args: any[]) => import('element-plus/es/components/cascader-panel/index').CascaderProps) | (() => import('element-plus/es/components/cascader-panel/index').CascaderProps))[], unknown, unknown, () => import('element-plus/es/components/cascader-panel/index').CascaderProps, boolean>;
+}, {
+    omit: typeof omit;
+    emitMethods: {
+        blur: (evt: FocusEvent) => void;
+        change: (_: import('element-plus').CascaderValue) => void;
+        focus: (evt: FocusEvent) => void;
+        clear: () => void;
+        "update:modelValue": (_: import('element-plus').CascaderValue) => void;
+        visibleChange: (val: boolean) => void;
+        expandChange: (val: import('element-plus').CascaderValue) => void;
+        removeTag: (val: import('element-plus/es/components/cascader-panel/src/node').CascaderNodeValue | import('element-plus/es/components/cascader-panel/src/node').CascaderNodePathValue) => void;
+    };
+    optionData: import('vue').Ref<CascaderOption[]>;
+    reloadOptions: () => void;
+    cascaderProps: {
+        expandTrigger?: import('element-plus').ExpandTrigger | undefined;
+        multiple?: boolean | undefined;
+        checkStrictly?: boolean | undefined;
+        emitPath?: boolean | undefined;
+        lazy?: boolean | undefined;
+        lazyLoad?: import('element-plus/es/components/cascader-panel/src/node').LazyLoad | undefined;
+        value?: string | undefined;
+        label?: string | undefined;
+        children?: string | undefined;
+        disabled?: (string | import('element-plus/es/components/cascader-panel/src/node').isDisabled) | undefined;
+        leaf?: (string | import('element-plus/es/components/cascader-panel/src/node').isLeaf) | undefined;
+        hoverThreshold?: number | undefined;
+    };
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (_: import('element-plus').CascaderValue) => boolean;
+    change: (_: import('element-plus').CascaderValue) => boolean;
+    focus: (evt: FocusEvent) => boolean;
+    blur: (evt: FocusEvent) => boolean;
+    clear: () => boolean;
+    visibleChange: (val: boolean) => boolean;
+    expandChange: (val: import('element-plus').CascaderValue) => boolean;
+    removeTag: (val: import('element-plus').CascaderNode["valueByOption"]) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    options: import('vue').PropType<CascaderOption[] | import('./types').CascaderOptionFunction>;
+    multiple: BooleanConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown, undefined, boolean>;
+    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;
+    };
+    placeholder: StringConstructor;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    filterMethod: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | (() => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | {
+        (): (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | (() => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | {
+        (): (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, (node: import('element-plus').CascaderNode, keyword: string) => boolean, boolean>;
+    separator: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    showAllLevels: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    collapseTags: BooleanConstructor;
+    maxCollapseTags: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    collapseTagsTooltip: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    debounce: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    beforeFilter: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (value: string) => boolean | Promise<any>) | (() => (value: string) => boolean | Promise<any>) | {
+        (): (value: string) => boolean | Promise<any>;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => (value: string) => boolean | Promise<any>) | (() => (value: string) => boolean | Promise<any>) | {
+        (): (value: string) => boolean | Promise<any>;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, () => true, boolean>;
+    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>;
+    popperClass: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    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>;
+    persistent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    modelValue: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus/es/components/cascader-panel/src/node').CascaderValue & {}) | (() => import('element-plus/es/components/cascader-panel/src/node').CascaderValue) | ((new (...args: any[]) => import('element-plus/es/components/cascader-panel/src/node').CascaderValue & {}) | (() => import('element-plus/es/components/cascader-panel/src/node').CascaderValue))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    props: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus/es/components/cascader-panel/index').CascaderProps) | (() => import('element-plus/es/components/cascader-panel/index').CascaderProps) | ((new (...args: any[]) => import('element-plus/es/components/cascader-panel/index').CascaderProps) | (() => import('element-plus/es/components/cascader-panel/index').CascaderProps))[], unknown, unknown, () => import('element-plus/es/components/cascader-panel/index').CascaderProps, boolean>;
+}>> & {
+    "onUpdate:modelValue"?: ((_: import('element-plus').CascaderValue) => any) | undefined;
+    onChange?: ((_: import('element-plus').CascaderValue) => any) | undefined;
+    onFocus?: ((evt: FocusEvent) => any) | undefined;
+    onBlur?: ((evt: FocusEvent) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onVisibleChange?: ((val: boolean) => any) | undefined;
+    onExpandChange?: ((val: import('element-plus').CascaderValue) => any) | undefined;
+    onRemoveTag?: ((val: import('element-plus/es/components/cascader-panel/src/node').CascaderNodeValue | import('element-plus/es/components/cascader-panel/src/node').CascaderNodePathValue) => any) | undefined;
+}, {
+    multiple: boolean;
+    valueOnClear: import('element-plus/es/utils/index').EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown>;
+    disabled: boolean;
+    clearable: boolean;
+    filterable: boolean;
+    filterMethod: (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+    separator: string;
+    showAllLevels: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    collapseTags: boolean;
+    maxCollapseTags: number;
+    collapseTagsTooltip: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    debounce: number;
+    beforeFilter: (value: string) => boolean | Promise<any>;
+    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>;
+    fallbackPlacements: import('element-plus').Placement[];
+    popperClass: string;
+    teleported: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    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>;
+    persistent: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    props: CascaderProps;
+}, {}>;
+export default _default;

package/lib/ele-cascader/props.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const elementPlus = require("element-plus");
+const cascaderProps = {
+  ...elementPlus.cascaderProps,
+  /** 选项数据 */
+  options: [Array, Function],
+  /** 是否多选 */
+  multiple: Boolean
+};
+Object.defineProperty(exports, "cascaderEmits", {
+  enumerable: true,
+  get: () => elementPlus.cascaderEmits
+});
+exports.cascaderProps = cascaderProps;

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

@@ -0,0 +1,77 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { CascaderOption, CascaderOptionFunction } from './types';
+
+export { cascaderEmits } from 'element-plus';
+/**
+ * 属性
+ */
+export declare const cascaderProps: {
+    /** 选项数据 */
+    options: PropType<CascaderOption[] | CascaderOptionFunction>;
+    /** 是否多选 */
+    multiple: BooleanConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: import('element-plus/es/utils/index').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown, undefined, boolean>;
+    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;
+    };
+    placeholder: StringConstructor;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    filterMethod: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | (() => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | {
+        (): (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | (() => (node: import('element-plus').CascaderNode, keyword: string) => boolean) | {
+        (): (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, (node: import('element-plus').CascaderNode, keyword: string) => boolean, boolean>;
+    separator: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    showAllLevels: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    collapseTags: BooleanConstructor;
+    maxCollapseTags: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    collapseTagsTooltip: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    debounce: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    beforeFilter: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => (value: string) => boolean | Promise<any>) | (() => (value: string) => boolean | Promise<any>) | {
+        (): (value: string) => boolean | Promise<any>;
+        new (): any;
+        readonly prototype: any;
+    } | ((new (...args: any[]) => (value: string) => boolean | Promise<any>) | (() => (value: string) => boolean | Promise<any>) | {
+        (): (value: string) => boolean | Promise<any>;
+        new (): any;
+        readonly prototype: any;
+    })[], unknown, unknown, () => true, boolean>;
+    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>;
+    popperClass: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    teleported: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    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>;
+    persistent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    modelValue: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<(new (...args: any[]) => import('element-plus/es/components/cascader-panel/src/node').CascaderValue & {}) | (() => import('element-plus/es/components/cascader-panel/src/node').CascaderValue) | ((new (...args: any[]) => import('element-plus/es/components/cascader-panel/src/node').CascaderValue & {}) | (() => import('element-plus/es/components/cascader-panel/src/node').CascaderValue))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    props: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CascaderProps) | (() => import('element-plus').CascaderProps) | ((new (...args: any[]) => import('element-plus').CascaderProps) | (() => import('element-plus').CascaderProps))[], unknown, unknown, () => import('element-plus').CascaderProps, boolean>;
+};
+export type CascaderProps = ExtractPropTypes<typeof cascaderProps>;

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,9 @@
+/**
+ * 选项数据
+ */
+export type CascaderOption = Record<string, any>;
+
+/**
+ * 选项数据请求函数
+ */
+export type CascaderOptionFunction = () => Promise<CascaderOption[]>;

package/lib/ele-check-card/index.cjs

@@ -1,6 +1,7 @@
 "use strict";
 const vue = require("vue");
 const elementPlus = require("element-plus");
+const hook = require("../utils/hook");
 const util = require("../ele-basic-select/util");
 const CardItem = require("./components/card-item");
 const props = require("./props");
@@ -11,6 +12,10 @@ const _sfc_main = vue.defineComponent({
   emits: props.checkCardEmits,
   setup(props2, { emit }) {
     const { validateChange } = util.useFormValidate();
+    const { optionData, reloadOptions } = hook.useProOptions(
+      props2,
+      "items"
+    );
     const isChecked = (item) => {
       if (props2.modelValue == null || item.value == null) {
         return false;
@@ -60,7 +65,12 @@ const _sfc_main = vue.defineComponent({
       }
       updateModelValue(props2.modelValue.filter((v) => v !== item.value));
     };
-    return { isChecked, handleItemClick };
+    return {
+      optionData,
+      reloadOptions,
+      isChecked,
+      handleItemClick
+    };
   }
 });
 const _export_sfc = (sfc, props2) => {
@@ -78,7 +88,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
     _ctx.row ? (vue.openBlock(), vue.createBlock(_component_ElRow, vue.normalizeProps(vue.mergeProps({ key: 0 }, _ctx.row === true ? {} : _ctx.row)), {
       default: vue.withCtx(() => [
-        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.items, (item, index2) => {
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.optionData, (item, index2) => {
           return vue.openBlock(), vue.createBlock(_component_ElCol, vue.mergeProps({
             key: index2 + "-" + item.value,
             ref_for: true
@@ -108,7 +118,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         }), 128))
       ]),
       _: 3
-    }, 16)) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(_ctx.items, (item, index2) => {
+    }, 16)) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(_ctx.optionData, (item, index2) => {
       return vue.openBlock(), vue.createBlock(_component_CardItem, {
         key: item.key ?? index2 + "-" + item.value,
         item,

package/lib/ele-check-card/index.d.ts

@@ -5,7 +5,7 @@ declare const _default: import('vue').DefineComponent<{
         type: import('vue').PropType<CheckedValue>;
         default: () => null;
     };
-    items: import('vue').PropType<CheckCardItem[]>;
+    items: import('vue').PropType<CheckCardItem[] | import('./types').CheckCardItemsFunction>;
     multiple: BooleanConstructor;
     disabled: BooleanConstructor;
     bordered: {
@@ -22,6 +22,8 @@ declare const _default: import('vue').DefineComponent<{
     row: import('vue').PropType<boolean | import('../ele-app/el').ElRowProps>;
     allowUncheck: BooleanConstructor;
 }, {
+    optionData: import('vue').Ref<CheckCardItem[]>;
+    reloadOptions: () => void;
     isChecked: (item: CheckCardItem) => boolean;
     handleItemClick: (item: CheckCardItem) => void;
 }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
@@ -32,7 +34,7 @@ declare const _default: import('vue').DefineComponent<{
         type: import('vue').PropType<CheckedValue>;
         default: () => null;
     };
-    items: import('vue').PropType<CheckCardItem[]>;
+    items: import('vue').PropType<CheckCardItem[] | import('./types').CheckCardItemsFunction>;
     multiple: BooleanConstructor;
     disabled: BooleanConstructor;
     bordered: {

package/lib/ele-check-card/props.cjs

@@ -9,7 +9,7 @@ const checkCardProps = {
     }
   },
   /** 数据 */
-  items: Array,
+  items: [Array, Function],
   /** 是否多选 */
   multiple: Boolean,
   /** 是否禁用 */

package/lib/ele-check-card/props.d.ts

@@ -1,7 +1,7 @@
 import { ExtractPropTypes, PropType } from 'vue';
 import { StyleValue } from '../ele-app/types';
 import { ElRowProps } from '../ele-app/el';
-import { CheckCardItem, CheckedValue } from './types';
+import { CheckedValue, CheckCardItem, CheckCardItemsFunction } from './types';
 
 /**
  * 属性
@@ -13,7 +13,7 @@ export declare const checkCardProps: {
         default: () => null;
     };
     /** 数据 */
-    items: PropType<CheckCardItem[]>;
+    items: PropType<CheckCardItem[] | CheckCardItemsFunction>;
     /** 是否多选 */
     multiple: BooleanConstructor;
     /** 是否禁用 */

package/lib/ele-check-card/types.d.ts

@@ -37,3 +37,8 @@ export interface CheckCardItem extends Record<keyof any, any> {
   /** 栅格属性 */
   col?: ElColProps;
 }
+
+/**
+ * 卡片数据请求函数
+ */
+export type CheckCardItemsFunction = () => Promise<CheckCardItem[]>;