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

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

@@ -0,0 +1,223 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { TreeComponentProps } from 'element-plus/es/components/tree/src/tree.type';
+import { SelectTreeData, SelectTreeDataFunction } from './types';
+
+export declare const elTreeProps: {
+    data: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    emptyText: {
+        type: StringConstructor;
+    };
+    renderAfterExpand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nodeKey: StringConstructor;
+    checkStrictly: BooleanConstructor;
+    defaultExpandAll: BooleanConstructor;
+    expandOnClickNode: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkOnClickNode: BooleanConstructor;
+    checkDescendants: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoExpandParent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultCheckedKeys: PropType<TreeComponentProps["defaultCheckedKeys"]>;
+    defaultExpandedKeys: PropType<TreeComponentProps["defaultExpandedKeys"]>;
+    currentNodeKey: PropType<string | number>;
+    renderContent: FunctionConstructor;
+    showCheckbox: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowDrag: FunctionConstructor;
+    allowDrop: FunctionConstructor;
+    props: {
+        type: PropType<TreeComponentProps["props"]>;
+        default: () => {
+            children: string;
+            label: string;
+            disabled: string;
+        };
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    highlightCurrent: BooleanConstructor;
+    load: PropType<TreeComponentProps["load"]>;
+    filterNodeMethod: PropType<TreeComponentProps["filterNodeMethod"]>;
+    accordion: BooleanConstructor;
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    icon: {
+        type: (StringConstructor | FunctionConstructor | ObjectConstructor)[];
+    };
+};
+/**
+ * 属性
+ */
+export declare const selectTreeProps: {
+    /** 数据 */
+    data: PropType<SelectTreeData | SelectTreeDataFunction>;
+    emptyText: {
+        type: StringConstructor;
+    };
+    renderAfterExpand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nodeKey: StringConstructor;
+    checkStrictly: BooleanConstructor;
+    defaultExpandAll: BooleanConstructor;
+    expandOnClickNode: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkOnClickNode: BooleanConstructor;
+    checkDescendants: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoExpandParent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultCheckedKeys: PropType<TreeComponentProps["defaultCheckedKeys"]>;
+    defaultExpandedKeys: PropType<TreeComponentProps["defaultExpandedKeys"]>;
+    currentNodeKey: PropType<string | number>;
+    renderContent: FunctionConstructor;
+    showCheckbox: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowDrag: FunctionConstructor;
+    allowDrop: FunctionConstructor;
+    props: {
+        type: PropType<TreeComponentProps["props"]>;
+        default: () => {
+            children: string;
+            label: string;
+            disabled: string;
+        };
+    };
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    highlightCurrent: BooleanConstructor;
+    load: PropType<TreeComponentProps["load"]>;
+    filterNodeMethod: PropType<TreeComponentProps["filterNodeMethod"]>;
+    accordion: BooleanConstructor;
+    indent: {
+        type: NumberConstructor;
+        default: number;
+    };
+    icon: {
+        type: (StringConstructor | FunctionConstructor | ObjectConstructor)[];
+    };
+    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) | (() => import('element-plus/es/components/popper/index').PopperEffect) | ((new (...args: any[]) => string) | (() => import('element-plus/es/components/popper/index').PopperEffect))[], 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) & {}) | (() => string | import('vue').Component) | ((new (...args: any[]) => (string | import('vue').Component) & {}) | (() => string | import('vue').Component))[], 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) & {}) | (() => string | import('vue').Component) | ((new (...args: any[]) => (string | import('vue').Component) & {}) | (() => string | import('vue').Component))[], 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;
+    showArrow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    offset: import('element-plus/es/utils/index').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    placement: import('element-plus/es/utils/index').EpPropFinalized<(new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import('@popperjs/core').Placement) | ((new (...args: any[]) => "top" | "bottom" | "left" | "right" | "auto" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => 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>;
+    tabindex: import('element-plus/es/utils/index').EpPropFinalized<(NumberConstructor | StringConstructor)[], unknown, unknown, number, boolean>;
+    appendTo: StringConstructor;
+};
+export type SelectTreeProps = ExtractPropTypes<typeof selectTreeProps>;
+/**
+ * 事件
+ */
+export declare const selectTreeEmits: {
+    'update:modelValue': (_value: any) => boolean;
+};

package/lib/ele-split-panel/index.cjs

@@ -5,12 +5,15 @@ const icons = require("../icons");
 const ReceiverView = require("../ele-config-provider/components/receiver-view");
 const util = require("../ele-pro-layout/util");
 const props = require("./props");
-const _sfc_main = vue.defineComponent({
-  name: "EleSplitPanel",
-  components: { ElIcon: elementPlus.ElIcon, ArrowLeft: icons.ArrowLeft, ArrowUp: icons.ArrowUp, ReceiverView },
+const _hoisted_1 = { class: "ele-split-panel-space" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "EleSplitPanel" },
+  __name: "index",
   props: props.splitPanelProps,
   emits: props.splitPanelEmits,
-  setup(props2, { emit }) {
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props2 = __props;
+    const emit = __emit;
     const isResponsive = util.useResponsive(props2);
     const rootRef = vue.ref(null);
     const wrapRef = vue.ref(null);
@@ -102,104 +105,86 @@ const _sfc_main = vue.defineComponent({
         }
       }
     );
-    return {
-      rootRef,
-      wrapRef,
-      sideRef,
-      isResponsive,
-      isCollapse,
-      resizedSize,
-      resizing,
+    __expose({
       toggleCollapse,
-      resetSize,
-      handleResize
+      resetSize
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(ReceiverView, {
+        ref_key: "rootRef",
+        ref: rootRef,
+        class: vue.normalizeClass([
+          "ele-split-panel",
+          { "is-reverse": _ctx.reverse },
+          { "is-vertical": _ctx.vertical },
+          { "is-collapse": isCollapse.value },
+          { "is-resizing": resizing.value },
+          { "is-responsive": vue.unref(isResponsive) },
+          { "is-flex-table": _ctx.flexTable }
+        ]),
+        style: vue.normalizeStyle({
+          "--ele-split-size": resizedSize.value || _ctx.size,
+          "--ele-split-space": _ctx.space
+        })
+      }, {
+        default: vue.withCtx(() => [
+          vue.createElementVNode("div", {
+            ref_key: "wrapRef",
+            ref: wrapRef,
+            class: "ele-split-panel-wrap",
+            style: vue.normalizeStyle(_ctx.customWrapStyle)
+          }, [
+            vue.createElementVNode("div", {
+              ref_key: "sideRef",
+              ref: sideRef,
+              class: "ele-split-panel-side",
+              style: vue.normalizeStyle(_ctx.customStyle)
+            }, [
+              vue.renderSlot(_ctx.$slots, "default")
+            ], 4),
+            vue.createElementVNode("div", _hoisted_1, [
+              _ctx.resizable ? (vue.openBlock(), vue.createElementBlock("div", {
+                key: 0,
+                class: "ele-split-resize-line",
+                onMousedown: handleResize
+              }, null, 32)) : vue.createCommentVNode("", true)
+            ])
+          ], 4),
+          vue.createElementVNode("div", {
+            class: "ele-split-panel-body",
+            style: vue.normalizeStyle(_ctx.bodyStyle)
+          }, [
+            vue.renderSlot(_ctx.$slots, "body", { collapse: isCollapse.value })
+          ], 4),
+          _ctx.allowCollapse ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            style: vue.normalizeStyle(_ctx.collapseStyle),
+            class: "ele-split-collapse-button",
+            onClick: _cache[0] || (_cache[0] = ($event) => toggleCollapse())
+          }, [
+            vue.renderSlot(_ctx.$slots, "collapse", { collapse: isCollapse.value }, () => [
+              vue.createVNode(vue.unref(elementPlus.ElIcon), { class: "ele-split-collapse-icon" }, {
+                default: vue.withCtx(() => [
+                  _ctx.vertical ? (vue.openBlock(), vue.createBlock(vue.unref(icons.ArrowUp), {
+                    key: 0,
+                    style: { "margin-top": "-1.25px" }
+                  })) : (vue.openBlock(), vue.createBlock(vue.unref(icons.ArrowLeft), {
+                    key: 1,
+                    style: { "margin-left": "-1.25px" }
+                  }))
+                ]),
+                _: 1
+              })
+            ])
+          ], 4)) : vue.createCommentVNode("", true),
+          vue.createElementVNode("div", {
+            class: "ele-split-panel-mask",
+            onClick: _cache[1] || (_cache[1] = ($event) => toggleCollapse())
+          })
+        ]),
+        _: 3
+      }, 8, ["class", "style"]);
     };
   }
 });
-const _export_sfc = (sfc, props2) => {
-  const target = sfc.__vccOpts || sfc;
-  for (const [key, val] of props2) {
-    target[key] = val;
-  }
-  return target;
-};
-const _hoisted_1 = { class: "ele-split-panel-space" };
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ArrowUp = vue.resolveComponent("ArrowUp");
-  const _component_ArrowLeft = vue.resolveComponent("ArrowLeft");
-  const _component_ElIcon = vue.resolveComponent("ElIcon");
-  const _component_ReceiverView = vue.resolveComponent("ReceiverView");
-  return vue.openBlock(), vue.createBlock(_component_ReceiverView, {
-    ref: "rootRef",
-    class: vue.normalizeClass([
-      "ele-split-panel",
-      { "is-reverse": _ctx.reverse },
-      { "is-vertical": _ctx.vertical },
-      { "is-collapse": _ctx.isCollapse },
-      { "is-resizing": _ctx.resizing },
-      { "is-responsive": _ctx.isResponsive },
-      { "is-flex-table": _ctx.flexTable }
-    ]),
-    style: vue.normalizeStyle({
-      "--ele-split-size": _ctx.resizedSize || _ctx.size,
-      "--ele-split-space": _ctx.space
-    })
-  }, {
-    default: vue.withCtx(() => [
-      vue.createElementVNode("div", {
-        ref: "wrapRef",
-        class: "ele-split-panel-wrap",
-        style: vue.normalizeStyle(_ctx.customWrapStyle)
-      }, [
-        vue.createElementVNode("div", {
-          ref: "sideRef",
-          class: "ele-split-panel-side",
-          style: vue.normalizeStyle(_ctx.customStyle)
-        }, [
-          vue.renderSlot(_ctx.$slots, "default")
-        ], 4),
-        vue.createElementVNode("div", _hoisted_1, [
-          _ctx.resizable ? (vue.openBlock(), vue.createElementBlock("div", {
-            key: 0,
-            class: "ele-split-resize-line",
-            onMousedown: _cache[0] || (_cache[0] = (...args) => _ctx.handleResize && _ctx.handleResize(...args))
-          }, null, 32)) : vue.createCommentVNode("", true)
-        ])
-      ], 4),
-      vue.createElementVNode("div", {
-        class: "ele-split-panel-body",
-        style: vue.normalizeStyle(_ctx.bodyStyle)
-      }, [
-        vue.renderSlot(_ctx.$slots, "body", { collapse: _ctx.isCollapse })
-      ], 4),
-      _ctx.allowCollapse ? (vue.openBlock(), vue.createElementBlock("div", {
-        key: 0,
-        style: vue.normalizeStyle(_ctx.collapseStyle),
-        class: "ele-split-collapse-button",
-        onClick: _cache[1] || (_cache[1] = ($event) => _ctx.toggleCollapse())
-      }, [
-        vue.renderSlot(_ctx.$slots, "collapse", { collapse: _ctx.isCollapse }, () => [
-          vue.createVNode(_component_ElIcon, { class: "ele-split-collapse-icon" }, {
-            default: vue.withCtx(() => [
-              _ctx.vertical ? (vue.openBlock(), vue.createBlock(_component_ArrowUp, {
-                key: 0,
-                style: { "margin-top": "-1.25px" }
-              })) : (vue.openBlock(), vue.createBlock(_component_ArrowLeft, {
-                key: 1,
-                style: { "margin-left": "-1.25px" }
-              }))
-            ]),
-            _: 1
-          })
-        ])
-      ], 4)) : vue.createCommentVNode("", true),
-      vue.createElementVNode("div", {
-        class: "ele-split-panel-mask",
-        onClick: _cache[2] || (_cache[2] = ($event) => _ctx.toggleCollapse())
-      })
-    ]),
-    _: 3
-  }, 8, ["class", "style"]);
-}
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-module.exports = index;
+module.exports = _sfc_main;

package/lib/ele-split-panel/index.d.ts

@@ -1,6 +1,13 @@
-import { ReceiverViewInstance } from '../ele-app/plus';
-
-declare const _default: import('vue').DefineComponent<{
+declare function __VLS_template(): {
+    default?(_: {}): any;
+    body?(_: {
+        collapse: boolean;
+    }): any;
+    collapse?(_: {
+        collapse: boolean;
+    }): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     size: StringConstructor;
     minSize: NumberConstructor;
     maxSize: NumberConstructor;
@@ -19,19 +26,11 @@ declare const _default: import('vue').DefineComponent<{
         type: BooleanConstructor;
         default: null;
     };
-}, {
-    rootRef: import('vue').Ref<ReceiverViewInstance>;
-    wrapRef: import('vue').Ref<HTMLElement | null>;
-    sideRef: import('vue').Ref<HTMLElement | null>;
-    isResponsive: import('vue').ComputedRef<boolean>;
-    isCollapse: import('vue').Ref<boolean>;
-    resizedSize: import('vue').Ref<string | null>;
-    resizing: import('vue').Ref<boolean>;
+}>, {
     toggleCollapse: (collapse?: boolean) => void;
     resetSize: () => void;
-    handleResize: (event: MouseEvent) => void;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    'update:collapse': (_collapse: boolean) => boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:collapse": (_collapse: boolean) => void;
 }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     size: StringConstructor;
     minSize: NumberConstructor;
@@ -51,9 +50,9 @@ declare const _default: import('vue').DefineComponent<{
         type: BooleanConstructor;
         default: null;
     };
-}>> & {
+}>> & Readonly<{
     "onUpdate:collapse"?: ((_collapse: boolean) => any) | undefined;
-}, {
+}>, {
     reverse: boolean;
     vertical: boolean;
     collapse: boolean;
@@ -61,5 +60,11 @@ declare const _default: import('vue').DefineComponent<{
     responsive: boolean;
     flexTable: boolean;
     allowCollapse: boolean;
-}, {}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/ele-steps/index.cjs

@@ -4,60 +4,50 @@ 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: "EleSteps",
-  components: { ElSteps: elementPlus.ElSteps, ElStep: elementPlus.ElStep },
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "EleSteps" },
+  __name: "index",
   props: props.stepsProps,
-  setup(props2) {
-    const { optionData, reloadOptions } = hook.useProOptions(
-      props2,
-      "items"
-    );
-    return {
-      omit: core.omit,
-      optionData,
-      reloadOptions
+  setup(__props, { expose: __expose }) {
+    const props2 = __props;
+    const { optionData, reloadOptions } = hook.useProOptions(props2, "items");
+    const stepsRef = vue.ref(null);
+    __expose({
+      reloadOptions,
+      stepsRef
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElSteps), vue.mergeProps(vue.unref(core.omit)(_ctx.$props, ["items", "type"]), {
+        ref_key: "stepsRef",
+        ref: stepsRef,
+        class: [
+          "ele-steps",
+          { "is-inline": _ctx.direction === "horizontal" && _ctx.type === "inline" }
+        ]
+      }), {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(optionData), (item, index) => {
+            return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElStep), vue.mergeProps({
+              key: index,
+              ref_for: true
+            }, item), vue.createSlots({ _: 2 }, [
+              vue.renderList(Object.keys(_ctx.$slots).filter((k) => "default" !== k), (name) => {
+                return {
+                  name,
+                  fn: vue.withCtx(() => [
+                    vue.renderSlot(_ctx.$slots, name, {
+                      index,
+                      item
+                    })
+                  ])
+                };
+              })
+            ]), 1040);
+          }), 128))
+        ]),
+        _: 3
+      }, 16, ["class"]);
     };
   }
 });
-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_ElStep = vue.resolveComponent("ElStep");
-  const _component_ElSteps = vue.resolveComponent("ElSteps");
-  return vue.openBlock(), vue.createBlock(_component_ElSteps, vue.mergeProps(_ctx.omit(_ctx.$props, ["items", "type"]), {
-    class: [
-      "ele-steps",
-      { "is-inline": _ctx.direction === "horizontal" && _ctx.type === "inline" }
-    ]
-  }), {
-    default: vue.withCtx(() => [
-      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.optionData, (item, index2) => {
-        return vue.openBlock(), vue.createBlock(_component_ElStep, vue.mergeProps({
-          key: index2,
-          ref_for: true
-        }, item), vue.createSlots({ _: 2 }, [
-          vue.renderList(Object.keys(_ctx.$slots).filter((k) => "default" !== k), (name) => {
-            return {
-              name,
-              fn: vue.withCtx(() => [
-                vue.renderSlot(_ctx.$slots, name, {
-                  index: index2,
-                  item
-                })
-              ])
-            };
-          })
-        ]), 1040);
-      }), 128))
-    ]),
-    _: 3
-  }, 16, ["class"]);
-}
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-module.exports = index;
+module.exports = _sfc_main;

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

@@ -1,7 +1,11 @@
-import { omit } from '../utils/core';
+import { ElStepInstance } from '../ele-app/el';
 import { StepItem } from './types';
 
-declare const _default: import('vue').DefineComponent<{
+declare function __VLS_template(): Partial<Record<string, (_: {
+    index: number;
+    item: StepItem;
+}) => any>>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     items: import('vue').PropType<StepItem[] | import('./types').StepItemsFunction>;
     type: import('vue').PropType<import('./types').StepType>;
     space: import('element-plus/es/utils/index').EpPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, "", boolean>;
@@ -21,11 +25,10 @@ declare const _default: import('vue').DefineComponent<{
     };
     finishStatus: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "wait" | "error" | "finish" | "success" | "process", unknown, "finish", boolean>;
     processStatus: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "wait" | "error" | "finish" | "success" | "process", unknown, "process", boolean>;
-}, {
-    omit: typeof omit;
-    optionData: import('vue').Ref<StepItem[]>;
+}>, {
     reloadOptions: () => void;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    stepsRef: import('vue').Ref<ElStepInstance, ElStepInstance>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     items: import('vue').PropType<StepItem[] | import('./types').StepItemsFunction>;
     type: import('vue').PropType<import('./types').StepType>;
     space: import('element-plus/es/utils/index').EpPropFinalized<readonly [NumberConstructor, StringConstructor], unknown, unknown, "", boolean>;
@@ -45,11 +48,17 @@ declare const _default: import('vue').DefineComponent<{
     };
     finishStatus: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "wait" | "error" | "finish" | "success" | "process", unknown, "finish", boolean>;
     processStatus: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "wait" | "error" | "finish" | "success" | "process", unknown, "process", boolean>;
-}>>, {
+}>> & Readonly<{}>, {
     direction: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>;
     space: import('element-plus/es/utils/index').EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>;
     active: number;
     finishStatus: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "error" | "success" | "wait" | "finish" | "process", unknown>;
     processStatus: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "error" | "success" | "wait" | "finish" | "process", unknown>;
-}, {}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};