ep-craft 0.1.34 → 0.1.35

package/dist/components/slider/index.d.ts

@@ -1,4 +1,20 @@
 import type { Plugin } from 'vue';
-import { ElSlider } from 'element-plus';
-export declare const EpSlider: typeof ElSlider & Plugin;
+import _EpSlider from './EpSlider.vue';
+/**
+ * slider 自持 barrel（vendor-batch-3 产出）。
+ *
+ * 表单集成：本体与 `composables/use-slide.ts` 通过 `@element-plus/components/form`
+ * 导入本地表单 hooks，读取的 `formContextKey` / `formItemContextKey` 是本地
+ * Symbol，故 disabled / size / label 关联与 change 校验在 `EpForm` /
+ * `EpFormItem` 下生效。
+ *
+ * `sliderContextKey` 是本地 Symbol：父组件 provide 与按钮 inject 共用本模块导出的键。
+ *
+ * 不导出 `ElSlider` 别名。
+ */
+export declare const EpSlider: typeof _EpSlider & Plugin;
 export default EpSlider;
+export { sliderContextKey } from './constants';
+export { sliderEmits, sliderProps } from './slider';
+export type { SliderContext } from './constants';
+export type { SliderEmits, SliderInitData, SliderInstance, SliderProps, SliderPropsPublic, } from './slider';

package/dist/components/slider/index.js

@@ -1,6 +1,12 @@
-import { ElSlider as r } from "element-plus";
-import { withInstall as e } from "../../utils/with-install.js";
-const i = Object.assign({}, r, { name: "EpSlider" }), o = e(i, "ep-slider");
+import { withInstall as r } from "../../utils/with-install.js";
+import i from "./EpSlider.vue.js";
+import { sliderEmits as p, sliderProps as l } from "./slider.js";
+const t = r(
+  i,
+  "ep-slider"
+);
 export {
-  o as EpSlider
+  t as EpSlider,
+  p as sliderEmits,
+  l as sliderProps
 };

package/dist/components/slider/marker.d.ts

@@ -0,0 +1,64 @@
+import type { CSSProperties, ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+export declare const sliderMarkerProps: {
+    readonly mark: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (() => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (((new (...args: any[]) => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (() => string | {
+        style: CSSProperties;
+        label: any;
+    })) | null)[], unknown, unknown, undefined, boolean>;
+};
+export type SliderMarkerProps = ExtractPropTypes<typeof sliderMarkerProps>;
+export type SliderMarkerPropsPublic = ExtractPublicPropTypes<typeof sliderMarkerProps>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    readonly mark: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (() => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (((new (...args: any[]) => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (() => string | {
+        style: CSSProperties;
+        label: any;
+    })) | null)[], unknown, unknown, undefined, boolean>;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    readonly mark: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (() => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (((new (...args: any[]) => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (() => string | {
+        style: CSSProperties;
+        label: any;
+    })) | null)[], unknown, unknown, undefined, boolean>;
+}>> & Readonly<{}>, {
+    readonly mark: import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (() => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (((new (...args: any[]) => string | {
+        style: CSSProperties;
+        label: any;
+    }) | (() => string | {
+        style: CSSProperties;
+        label: any;
+    })) | null)[], unknown, unknown>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/slider/marker.js

@@ -0,0 +1,40 @@
+import { defineComponent as a, computed as t, h as p } from "vue";
+import { isString as e } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as s, definePropType as l } from "../../utils/vue/props/runtime.js";
+import { useNamespace as n } from "../../hooks/use-namespace/index.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+const d = s({
+  mark: {
+    type: l([String, Object]),
+    default: void 0
+  }
+}), j = a({
+  name: "EpSliderMarker",
+  props: d,
+  setup(r) {
+    const m = n("slider"), o = t(() => e(r.mark) ? r.mark : r.mark.label), i = t(
+      () => e(r.mark) ? void 0 : r.mark.style
+    );
+    return () => p(
+      "div",
+      {
+        class: m.e("marks-text"),
+        style: i.value
+      },
+      o.value
+    );
+  }
+});
+export {
+  j as default,
+  d as sliderMarkerProps
+};

package/dist/components/slider/slider.d.ts

@@ -0,0 +1,80 @@
+import type { Arrayable } from '@element-plus/utils';
+import type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+import type { SliderMarkerProps } from './marker';
+import type Slider from './EpSlider.vue';
+type SliderMarks = Record<number, string | SliderMarkerProps['mark']>;
+export interface SliderInitData {
+    firstValue: number;
+    secondValue: number;
+    oldValue?: Arrayable<number>;
+    dragging: boolean;
+    sliderSize: number;
+}
+export declare const sliderProps: {
+    readonly ariaLabel: StringConstructor;
+    readonly modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => number | number[]) | (() => Arrayable<number>) | (((new (...args: any[]) => number | number[]) | (() => Arrayable<number>)) | null)[], unknown, unknown, 0, boolean>;
+    readonly id: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    readonly min: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly max: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 100, boolean>;
+    readonly step: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => number | "mark") | (() => number | "mark") | (((new (...args: any[]) => number | "mark") | (() => number | "mark")) | null)[], unknown, unknown, 1, boolean>;
+    readonly showInput: BooleanConstructor;
+    readonly showInputControls: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly inputSize: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly showStops: BooleanConstructor;
+    readonly showTooltip: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly formatTooltip: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (val: number) => number | string) | (() => (val: number) => number | string) | {
+        (): (val: number) => number | string;
+        new (): any;
+        readonly prototype: any;
+    } | (((new (...args: any[]) => (val: number) => number | string) | (() => (val: number) => number | string) | {
+        (): (val: number) => number | string;
+        new (): any;
+        readonly prototype: any;
+    }) | null)[], unknown, unknown, undefined, boolean>;
+    readonly disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly range: BooleanConstructor;
+    readonly vertical: BooleanConstructor;
+    readonly height: StringConstructor;
+    readonly rangeStartLabel: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    readonly rangeEndLabel: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    readonly formatValueText: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (val: number) => string) | (() => (val: number) => string) | {
+        (): (val: number) => string;
+        new (): any;
+        readonly prototype: any;
+    } | (((new (...args: any[]) => (val: number) => string) | (() => (val: number) => string) | {
+        (): (val: number) => string;
+        new (): any;
+        readonly prototype: any;
+    }) | null)[], unknown, unknown, undefined, boolean>;
+    readonly tooltipClass: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, import("element-plus").Placement, unknown, "top", boolean>;
+    readonly marks: {
+        readonly type: import("vue").PropType<SliderMarks>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly persistent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+};
+export type SliderProps = ExtractPropTypes<typeof sliderProps>;
+export type SliderPropsPublic = ExtractPublicPropTypes<typeof sliderProps>;
+export declare const sliderEmits: {
+    "update:modelValue": (value: Arrayable<number>) => value is number | number[];
+    input: (value: Arrayable<number>) => value is number | number[];
+    change: (value: Arrayable<number>) => value is number | number[];
+};
+export type SliderEmits = typeof sliderEmits;
+export type SliderInstance = InstanceType<typeof Slider> & unknown;
+export {};

package/dist/components/slider/slider.js

@@ -0,0 +1,170 @@
+import { placements as a } from "@popperjs/core";
+import { isNumber as r } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isArray as p } from "@vue/shared";
+import { CHANGE_EVENT as l, INPUT_EVENT as n, UPDATE_MODEL_EVENT as m } from "../../constants/event.js";
+import "@element-plus/icons-vue";
+import { buildProps as u, definePropType as t } from "../../utils/vue/props/runtime.js";
+import "vue";
+import { useSizeProp as i } from "../../hooks/use-size/index.js";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import { useAriaProps as d } from "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+const A = u({
+  /**
+   * @description binding value
+   */
+  modelValue: {
+    type: t([Number, Array]),
+    default: 0
+  },
+  id: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description minimum value
+   */
+  min: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description maximum value
+   */
+  max: {
+    type: Number,
+    default: 100
+  },
+  /**
+   * @description step size, can be a number or `'mark'` to restrict values to marks. When set to `'mark'`, the `marks` attribute must be set
+   */
+  step: {
+    type: t([Number, String]),
+    default: 1
+  },
+  /**
+   * @description whether to display an input box, works when `range` is false and `step` is not `'mark'`
+   */
+  showInput: Boolean,
+  /**
+   * @description whether to display control buttons when `show-input` is true
+   */
+  showInputControls: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description size of the slider wrapper, will not work in vertical mode
+   */
+  size: i,
+  /**
+   * @description size of the input box, when set `size`, the default is the value of `size`
+   */
+  inputSize: i,
+  /**
+   * @description whether to display breakpoints
+   */
+  showStops: Boolean,
+  /**
+   * @description whether to display tooltip value
+   */
+  showTooltip: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description format to display tooltip value
+   */
+  formatTooltip: {
+    type: t(Function),
+    default: void 0
+  },
+  /**
+   * @description whether Slider is disabled
+   */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+   * @description whether to select a range
+   */
+  range: Boolean,
+  /**
+   * @description vertical mode
+   */
+  vertical: Boolean,
+  /**
+   * @description slider height, required in vertical mode
+   */
+  height: String,
+  /**
+   * @description when `range` is true, screen reader label for the start of the range
+   */
+  rangeStartLabel: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description when `range` is true, screen reader label for the end of the range
+   */
+  rangeEndLabel: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description format to display the `aria-valuenow` attribute for screen readers
+   */
+  formatValueText: {
+    type: t(Function),
+    default: void 0
+  },
+  /**
+   * @description custom class name for the tooltip
+   */
+  tooltipClass: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description position of Tooltip
+   */
+  placement: {
+    type: String,
+    values: a,
+    default: "top"
+  },
+  /**
+   * @description marks, type of key must be `number` and must in closed interval `[min, max]`, each mark can custom style
+   */
+  marks: {
+    type: t(Object)
+  },
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description when slider tooltip inactive and `persistent` is `false` , popconfirm will be destroyed. `persistent` always be `false` when `show-tooltip ` is `false`
+   */
+  persistent: {
+    type: Boolean,
+    default: !0
+  },
+  ...d(["ariaLabel"])
+}), o = (e) => r(e) || p(e) && e.every(r), w = {
+  [m]: o,
+  [n]: o,
+  [l]: o
+};
+export {
+  w as sliderEmits,
+  A as sliderProps
+};

package/dist/components/step/EpStep.vue.d.ts

@@ -0,0 +1,38 @@
+import type { StepProps } from './step';
+import type { ComputedRef, Ref, VNode } from 'vue';
+import type { StepsProps } from '../steps/steps';
+export interface StepItemState {
+    uid: number;
+    getVnode: () => VNode;
+    currentStatus: ComputedRef<string>;
+    internalStatus: Ref<string>;
+    setIndex: (val: number) => void;
+    calcProgress: (status: string) => void;
+}
+export interface IStepsInject {
+    props: Required<StepsProps>;
+    steps: Ref<StepItemState[]>;
+    addStep: (item: StepItemState) => void;
+    removeStep: (item: StepItemState) => void;
+}
+declare var __VLS_1: {}, __VLS_27: {}, __VLS_29: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+} & {
+    title?: (props: typeof __VLS_27) => any;
+} & {
+    description?: (props: typeof __VLS_29) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<StepProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StepProps> & Readonly<{}>, {
+    description: string;
+    icon: import("@element-plus/utils").IconPropType;
+    title: string;
+    status: "" | "wait" | "process" | "finish" | "error" | "success";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/step/EpStep.vue.js

@@ -0,0 +1,157 @@
+import { defineComponent as Y, ref as E, inject as q, getCurrentInstance as F, onMounted as G, watch as H, computed as n, onBeforeUnmount as Q, openBlock as r, createElementBlock as m, normalizeClass as l, normalizeStyle as P, createElementVNode as f, unref as t, createCommentVNode as W, renderSlot as N, createBlock as S, withCtx as w, resolveDynamicComponent as R, createVNode as z, toDisplayString as x, createTextVNode as K } from "vue";
+import { useNamespace as X } from "../../hooks/use-namespace/index.js";
+import { isNumber as Z } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import { Check as _, Close as ee } from "@element-plus/icons-vue";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import { ElIcon as I } from "../icon/index.js";
+import { STEPS_INJECTION_KEY as te } from "../steps/tokens.js";
+const Ce = /* @__PURE__ */ Y({
+  name: "EpStep",
+  __name: "EpStep",
+  props: {
+    title: { default: "" },
+    icon: { default: "" },
+    description: { default: "" },
+    status: { default: "" }
+  },
+  setup(c) {
+    const M = c, s = X("step"), i = E(-1), V = E({}), p = E(""), a = q(te), y = F();
+    let h = 0, C = 0;
+    G(() => {
+      H(
+        [
+          () => a.props.active,
+          () => a.props.processStatus,
+          () => a.props.finishStatus
+        ],
+        ([e], [u]) => {
+          C = u || 0, h = e - C, U(e);
+        },
+        { immediate: !0 }
+      );
+    });
+    const v = n(() => M.status || p.value), j = n(() => {
+      const e = a.steps.value[i.value - 1];
+      return e ? e.internalStatus.value : "wait";
+    }), k = n(() => a.props.alignCenter), b = n(() => a.props.direction === "vertical"), o = n(() => a.props.simple), $ = n(() => a.steps.value.length), B = n(() => {
+      var e;
+      return ((e = a.steps.value[$.value - 1]) == null ? void 0 : e.uid) === y.uid;
+    }), d = n(() => o.value ? "" : a.props.space), A = n(() => [
+      s.b(),
+      s.is(o.value ? "simple" : a.props.direction),
+      s.is("flex", B.value && !d.value && !k.value),
+      s.is("center", k.value && !b.value && !o.value)
+    ]), J = n(() => {
+      const e = {
+        flexBasis: Z(d.value) ? `${d.value}px` : d.value ? d.value : `${100 / ($.value - (k.value ? 0 : 1))}%`
+      };
+      return b.value || B.value && (e.maxWidth = `${100 / $.value}%`), e;
+    }), L = (e) => {
+      i.value = e;
+    }, O = (e) => {
+      const u = e === "wait", g = {
+        transitionDelay: `${Math.abs(h) === 1 ? 0 : h > 0 ? (i.value + 1 - C) * 150 : -(i.value + 1 - a.props.active) * 150}ms`
+      }, D = e === a.props.processStatus || u ? 0 : 100;
+      g.borderWidth = D && !o.value ? "1px" : 0, g[a.props.direction === "vertical" ? "height" : "width"] = `${D}%`, V.value = g;
+    }, U = (e) => {
+      e > i.value ? p.value = a.props.finishStatus : e === i.value && j.value !== "error" ? p.value = a.props.processStatus : p.value = "wait";
+      const u = a.steps.value[i.value - 1];
+      u && u.calcProgress(p.value);
+    }, T = {
+      uid: y.uid,
+      getVnode: () => y.vnode,
+      currentStatus: v,
+      internalStatus: p,
+      setIndex: L,
+      calcProgress: O
+    };
+    return a.addStep(T), Q(() => {
+      a.removeStep(T);
+    }), (e, u) => (r(), m("div", {
+      style: P(J.value),
+      class: l(A.value)
+    }, [
+      f("div", {
+        class: l([t(s).e("head"), t(s).is(v.value)])
+      }, [
+        o.value ? W("", !0) : (r(), m("div", {
+          key: 0,
+          class: l(t(s).e("line"))
+        }, [
+          f("i", {
+            class: l(t(s).e("line-inner")),
+            style: P(V.value)
+          }, null, 6)
+        ], 2)),
+        f("div", {
+          class: l([t(s).e("icon"), t(s).is(c.icon || e.$slots.icon ? "icon" : "text")])
+        }, [
+          N(e.$slots, "icon", {}, () => [
+            c.icon ? (r(), S(t(I), {
+              key: 0,
+              class: l(t(s).e("icon-inner"))
+            }, {
+              default: w(() => [
+                (r(), S(R(c.icon)))
+              ]),
+              _: 1
+            }, 8, ["class"])) : v.value === "success" ? (r(), S(t(I), {
+              key: 1,
+              class: l([t(s).e("icon-inner"), t(s).is("status")])
+            }, {
+              default: w(() => [
+                z(t(_))
+              ]),
+              _: 1
+            }, 8, ["class"])) : v.value === "error" ? (r(), S(t(I), {
+              key: 2,
+              class: l([t(s).e("icon-inner"), t(s).is("status")])
+            }, {
+              default: w(() => [
+                z(t(ee))
+              ]),
+              _: 1
+            }, 8, ["class"])) : o.value ? W("", !0) : (r(), m("div", {
+              key: 3,
+              class: l(t(s).e("icon-inner"))
+            }, x(i.value + 1), 3))
+          ])
+        ], 2)
+      ], 2),
+      f("div", {
+        class: l(t(s).e("main"))
+      }, [
+        f("div", {
+          class: l([t(s).e("title"), t(s).is(v.value)])
+        }, [
+          N(e.$slots, "title", {}, () => [
+            K(x(c.title), 1)
+          ])
+        ], 2),
+        o.value ? (r(), m("div", {
+          key: 0,
+          class: l(t(s).e("arrow"))
+        }, null, 2)) : (r(), m("div", {
+          key: 1,
+          class: l([t(s).e("description"), t(s).is(v.value)])
+        }, [
+          N(e.$slots, "description", {}, () => [
+            K(x(c.description), 1)
+          ])
+        ], 2))
+      ], 2)
+    ], 6));
+  }
+});
+export {
+  Ce as default
+};

package/dist/components/step/EpStep2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpStep.vue.js";
+export {
+  f as default
+};

package/dist/components/step/index.d.ts

@@ -1,4 +1,14 @@
 import type { Plugin } from 'vue';
-import { ElStep } from 'element-plus';
-export declare const EpStep: typeof ElStep & Plugin;
+import _EpStep from './EpStep.vue';
+/**
+ * step 自持 barrel（vendor-batch-1 产出）。
+ *
+ * 仅负责把本地本体注册为 `ep-step`。父级识别不经过本 barrel：`EpSteps` 按
+ * 组件名 `'EpStep'`（与本体 `defineOptions` 同字面量）收集子项，`StepItemState` /
+ * `IStepsInject` 随 `EpStep.vue` 导出，由 Steps 以 `import type` 复用。
+ * 不导出 `ElStep` 别名。
+ */
+export declare const EpStep: typeof _EpStep & Plugin;
 export default EpStep;
+export { stepProps } from './step';
+export type { StepInstance, StepProps, StepPropsPublic } from './step';

package/dist/components/step/index.js

@@ -1,6 +1,11 @@
-import { ElStep as t } from "element-plus";
 import { withInstall as p } from "../../utils/with-install.js";
-const e = Object.assign({}, t, { name: "EpStep" }), m = p(e, "ep-step");
+import t from "./EpStep.vue.js";
+import { stepProps as f } from "./step.js";
+const e = p(
+  t,
+  "ep-step"
+);
 export {
-  m as EpStep
+  e as EpStep,
+  f as stepProps
 };

package/dist/components/step/step.d.ts

@@ -0,0 +1,42 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type { IconPropType } from '@element-plus/utils';
+import type Step from './EpStep.vue';
+export interface StepProps {
+    /**
+     * @description step title
+     */
+    title?: string;
+    /**
+     * @description step custom icon. Icons can be passed via named slot as well
+     */
+    icon?: IconPropType;
+    /**
+     * @description step description
+     * @default ''
+     */
+    description?: string;
+    /**
+     * @description current status. It will be automatically set by Steps if not configured.
+     * @default ''
+     */
+    status?: '' | 'wait' | 'process' | 'finish' | 'error' | 'success';
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `StepProps` instead.
+ */
+export declare const stepProps: {
+    readonly title: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly description: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly status: import("@element-plus/utils").EpPropFinalized<StringConstructor, "" | "wait" | "error" | "finish" | "success" | "process", unknown, "", boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `StepProps` instead.
+ */
+export type StepPropsPublic = ExtractPublicPropTypes<typeof stepProps>;
+export type StepInstance = InstanceType<typeof Step> & unknown;