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

package/es/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/es/ele-cascader/index.js

@@ -0,0 +1,99 @@
+import { defineComponent, reactive, watch, resolveComponent, openBlock, createBlock, mergeProps, createSlots, renderList, withCtx, renderSlot, normalizeProps, guardReactiveProps } from "vue";
+import { ElCascader } from "element-plus";
+import { omit } from "../utils/core";
+import { useComponentEvents, useProOptions } from "../utils/hook";
+import { cascaderProps, cascaderEmits } from "./props";
+const _sfc_main = defineComponent({
+  name: "EleCascader",
+  components: { ElCascader },
+  props: cascaderProps,
+  emits: cascaderEmits,
+  setup(props, { emit }) {
+    var _a;
+    const { emitMethods } = useComponentEvents(cascaderEmits, emit);
+    const { optionData, reloadOptions } = useProOptions(props);
+    const cascaderProps2 = reactive({
+      ...props.props || {},
+      multiple: !!(props.multiple || ((_a = props.props) == null ? void 0 : _a.multiple))
+    });
+    watch(
+      [() => props.multiple, () => props.props],
+      () => {
+        const cProps = props.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.multiple) {
+          if (!cascaderProps2.multiple) {
+            cascaderProps2.multiple = true;
+          }
+        } else if (!!cascaderProps2.multiple !== !!cProps.multiple) {
+          cascaderProps2.multiple = cProps.multiple;
+        }
+      },
+      {
+        immediate: true,
+        deep: true
+      }
+    );
+    return {
+      omit,
+      emitMethods,
+      optionData,
+      reloadOptions,
+      cascaderProps: cascaderProps2
+    };
+  }
+});
+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_ElCascader = resolveComponent("ElCascader");
+  return openBlock(), createBlock(_component_ElCascader, 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"]
+  }), createSlots({ _: 2 }, [
+    renderList(Object.keys(_ctx.$slots), (name) => {
+      return {
+        name,
+        fn: withCtx((slotProps) => [
+          renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
+        ])
+      };
+    })
+  ]), 1040, ["props", "options", "onUpdate:modelValue", "onChange", "onFocus", "onBlur", "onClear", "onVisibleChange", "onExpandChange", "onRemoveTag"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  index as default
+};

package/es/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/es/ele-cascader/props.js

@@ -0,0 +1,13 @@
+import { cascaderProps as cascaderProps$1 } from "element-plus";
+import { cascaderEmits } from "element-plus";
+const cascaderProps = {
+  ...cascaderProps$1,
+  /** 选项数据 */
+  options: [Array, Function],
+  /** 是否多选 */
+  multiple: Boolean
+};
+export {
+  cascaderEmits,
+  cascaderProps
+};

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

@@ -0,0 +1 @@
+

package/es/ele-cascader/style/index.js

@@ -0,0 +1 @@
+import "element-plus/es/components/cascader/style/index";

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

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

package/es/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/es/ele-check-card/index.js

@@ -1,5 +1,6 @@
 import { defineComponent, resolveComponent, openBlock, createElementBlock, createBlock, normalizeProps, mergeProps, withCtx, Fragment, renderList, createVNode, normalizeStyle, normalizeClass, renderSlot, createTextVNode, toDisplayString } from "vue";
 import { ElRow, ElCol } from "element-plus";
+import { useProOptions } from "../utils/hook";
 import { useFormValidate, isEmptyValue, valueIsChanged } from "../ele-basic-select/util";
 import CardItem from "./components/card-item";
 import { checkCardProps, checkCardEmits } from "./props";
@@ -10,6 +11,10 @@ const _sfc_main = defineComponent({
   emits: checkCardEmits,
   setup(props, { emit }) {
     const { validateChange } = useFormValidate();
+    const { optionData, reloadOptions } = useProOptions(
+      props,
+      "items"
+    );
     const isChecked = (item) => {
       if (props.modelValue == null || item.value == null) {
         return false;
@@ -59,7 +64,12 @@ const _sfc_main = defineComponent({
       }
       updateModelValue(props.modelValue.filter((v) => v !== item.value));
     };
-    return { isChecked, handleItemClick };
+    return {
+      optionData,
+      reloadOptions,
+      isChecked,
+      handleItemClick
+    };
   }
 });
 const _export_sfc = (sfc, props) => {
@@ -77,7 +87,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   return openBlock(), createElementBlock("div", _hoisted_1, [
     _ctx.row ? (openBlock(), createBlock(_component_ElRow, normalizeProps(mergeProps({ key: 0 }, _ctx.row === true ? {} : _ctx.row)), {
       default: withCtx(() => [
-        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.items, (item, index2) => {
+        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.optionData, (item, index2) => {
           return openBlock(), createBlock(_component_ElCol, mergeProps({
             key: index2 + "-" + item.value,
             ref_for: true
@@ -107,7 +117,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         }), 128))
       ]),
       _: 3
-    }, 16)) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(_ctx.items, (item, index2) => {
+    }, 16)) : (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(_ctx.optionData, (item, index2) => {
       return openBlock(), createBlock(_component_CardItem, {
         key: item.key ?? index2 + "-" + item.value,
         item,

package/es/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/es/ele-check-card/props.js

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

package/es/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[]>;

package/es/ele-checkbox-group/index.d.ts

@@ -0,0 +1,60 @@
+import { omit } from '../utils/core';
+import { CheckboxOption } from './types';
+
+declare const _default: import('vue').DefineComponent<{
+    type: import('vue').PropType<import('./types').CheckboxType>;
+    options: import('vue').PropType<CheckboxOption[] | import('./types').CheckboxOptionFunction>;
+    ariaLabel: StringConstructor;
+    modelValue: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+    disabled: BooleanConstructor;
+    min: NumberConstructor;
+    max: NumberConstructor;
+    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;
+    };
+    fill: StringConstructor;
+    textColor: StringConstructor;
+    tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}, {
+    omit: typeof omit;
+    emitMethods: {
+        change: (val: import('element-plus').CheckboxValueType[]) => void;
+        "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+    };
+    optionData: import('vue').Ref<CheckboxOption[]>;
+    reloadOptions: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => boolean;
+    change: (val: import('element-plus').CheckboxValueType[]) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    type: import('vue').PropType<import('./types').CheckboxType>;
+    options: import('vue').PropType<CheckboxOption[] | import('./types').CheckboxOptionFunction>;
+    ariaLabel: StringConstructor;
+    modelValue: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+    disabled: BooleanConstructor;
+    min: NumberConstructor;
+    max: NumberConstructor;
+    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;
+    };
+    fill: StringConstructor;
+    textColor: StringConstructor;
+    tag: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+    validateEvent: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}>> & {
+    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+    onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+}, {
+    modelValue: import('element-plus').CheckboxGroupValueType;
+    disabled: boolean;
+    tag: string;
+    validateEvent: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}>;
+export default _default;