ep-craft 0.1.36 → 0.1.38

package/dist/components/drawer/EpDrawer.vue.js

@@ -0,0 +1,234 @@
+import { defineComponent as U, useSlots as j, computed as k, ref as v, openBlock as r, createBlock as G, Teleport as J, createVNode as s, Transition as K, unref as e, withCtx as p, withDirectives as Q, createElementVNode as h, mergeProps as W, withModifiers as X, normalizeClass as a, createElementBlock as i, renderSlot as f, toDisplayString as Y, createCommentVNode as n, normalizeStyle as Z, vShow as _, mergeDefaults as ee } from "vue";
+import { Close as oe } from "@element-plus/icons-vue";
+import { EpOverlay as te } from "../overlay/overlay.js";
+import { EpFocusTrap as ae } from "../focus-trap/index.js";
+import "../dialog/index.js";
+import { EpIcon as le } from "../icon/index.js";
+import { useNamespace as re } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { useLocale as se } from "../../hooks/use-locale/index.js";
+import "../../hooks/use-size/index.js";
+import { useDeprecated as ie } from "../../hooks/use-deprecated/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 { drawerEmits as ne } from "./drawer.js";
+import { useResizable as de } from "./useResizable.js";
+import { useDialog as ce } from "../dialog/use-dialog.js";
+import { dialogPropsDefaults as me } from "../dialog/dialog.js";
+const pe = ["aria-label", "aria-labelledby", "aria-describedby"], fe = ["id", "aria-level"], ue = ["aria-label"], ye = ["id"], Ve = /* @__PURE__ */ U({
+  name: "EpDrawer",
+  inheritAttrs: !1,
+  __name: "EpDrawer",
+  props: /* @__PURE__ */ ee({
+    direction: {},
+    resizable: { type: Boolean },
+    size: {},
+    withHeader: { type: Boolean },
+    modalFade: { type: Boolean },
+    headerAriaLevel: {},
+    appendToBody: { type: Boolean },
+    appendTo: {},
+    beforeClose: { type: Function },
+    destroyOnClose: { type: Boolean },
+    closeOnClickModal: { type: Boolean },
+    closeOnPressEscape: { type: Boolean },
+    lockScroll: { type: Boolean },
+    modal: { type: Boolean },
+    modalPenetrable: { type: Boolean },
+    openDelay: {},
+    closeDelay: {},
+    top: {},
+    modelValue: { type: Boolean },
+    modalClass: {},
+    width: {},
+    zIndex: {},
+    trapFocus: { type: Boolean },
+    transition: {},
+    center: { type: Boolean },
+    alignCenter: { type: Boolean },
+    closeIcon: {},
+    draggable: { type: Boolean },
+    overflow: { type: Boolean },
+    fullscreen: { type: Boolean },
+    headerClass: {},
+    bodyClass: {},
+    footerClass: {},
+    showClose: { type: Boolean },
+    title: {},
+    ariaLevel: {}
+  }, {
+    ...me,
+    direction: "rtl",
+    size: "30%",
+    withHeader: !0,
+    modalFade: !0,
+    headerAriaLevel: "2"
+  }),
+  emits: ne,
+  setup(o, { expose: z, emit: R }) {
+    const d = o, A = R, F = j();
+    ie(
+      {
+        scope: "el-drawer",
+        from: "the title slot",
+        replacement: "the header slot",
+        version: "3.0.0",
+        ref: "https://element-plus.org/en-US/component/drawer.html#slots"
+      },
+      k(() => !!F.title)
+    );
+    const u = v(), C = v(), B = v(), t = re("drawer"), { t: E } = se(), {
+      afterEnter: L,
+      afterLeave: D,
+      beforeLeave: T,
+      visible: y,
+      rendered: S,
+      titleId: b,
+      bodyId: w,
+      zIndex: g,
+      onModalClick: I,
+      onOpenAutoFocus: P,
+      onCloseAutoFocus: $,
+      onFocusoutPrevented: O,
+      onCloseRequested: H,
+      handleClose: c
+    } = ce(d, u), { isHorizontal: N, size: V, isResizing: q } = de(d, B, A), x = k(() => d.modalPenetrable && !d.modal);
+    return z({
+      handleClose: c
+    }), (l, m) => (r(), G(J, {
+      to: o.appendTo,
+      disabled: o.appendTo !== "body" ? !1 : !o.appendToBody
+    }, [
+      s(K, {
+        name: e(t).b("fade"),
+        onAfterEnter: e(L),
+        onAfterLeave: e(D),
+        onBeforeLeave: e(T)
+      }, {
+        default: p(() => [
+          Q(s(e(te), {
+            mask: o.modal,
+            "overlay-class": [
+              e(t).is("drawer"),
+              o.modalClass ?? "",
+              `${e(t).namespace.value}-modal-drawer`,
+              e(t).is("penetrable", x.value)
+            ],
+            "z-index": e(g),
+            onClick: e(I)
+          }, {
+            default: p(() => [
+              s(e(ae), {
+                loop: "",
+                trapped: e(y),
+                "focus-trap-el": u.value,
+                "focus-start-el": C.value,
+                onFocusAfterTrapped: e(P),
+                onFocusAfterReleased: e($),
+                onFocusoutPrevented: e(O),
+                onReleaseRequested: e(H)
+              }, {
+                default: p(() => [
+                  h("div", W({
+                    ref_key: "drawerRef",
+                    ref: u,
+                    "aria-modal": "true",
+                    "aria-label": o.title || void 0,
+                    "aria-labelledby": o.title ? void 0 : e(b),
+                    "aria-describedby": e(w)
+                  }, l.$attrs, {
+                    class: [
+                      e(t).b(),
+                      o.direction,
+                      e(y) && "open",
+                      e(t).is("dragging", e(q))
+                    ],
+                    style: { [e(N) ? "width" : "height"]: e(V) },
+                    role: "dialog",
+                    onClick: m[1] || (m[1] = X(() => {
+                    }, ["stop"]))
+                  }), [
+                    h("span", {
+                      ref_key: "focusStartRef",
+                      ref: C,
+                      class: a(e(t).e("sr-focus")),
+                      tabindex: "-1"
+                    }, null, 2),
+                    o.withHeader ? (r(), i("header", {
+                      key: 0,
+                      class: a([e(t).e("header"), o.headerClass])
+                    }, [
+                      l.$slots.title ? f(l.$slots, "title", {}, void 0, void 0, 1) : f(l.$slots, "header", {
+                        close: e(c),
+                        titleId: e(b),
+                        titleClass: e(t).e("title")
+                      }, () => [
+                        h("span", {
+                          id: e(b),
+                          role: "heading",
+                          "aria-level": o.headerAriaLevel,
+                          class: a(e(t).e("title"))
+                        }, Y(o.title), 11, fe)
+                      ], void 0, 0),
+                      o.showClose ? (r(), i("button", {
+                        key: 2,
+                        "aria-label": e(E)("el.drawer.close"),
+                        class: a(e(t).e("close-btn")),
+                        type: "button",
+                        onClick: m[0] || (m[0] = //@ts-ignore
+                        (...M) => e(c) && e(c)(...M))
+                      }, [
+                        s(e(le), {
+                          class: a(e(t).e("close"))
+                        }, {
+                          default: p(() => [
+                            s(e(oe))
+                          ]),
+                          _: 1
+                        }, 8, ["class"])
+                      ], 10, ue)) : n("", !0)
+                    ], 2)) : n("", !0),
+                    e(S) ? (r(), i("div", {
+                      key: 1,
+                      id: e(w),
+                      class: a([e(t).e("body"), o.bodyClass])
+                    }, [
+                      f(l.$slots, "default")
+                    ], 10, ye)) : n("", !0),
+                    l.$slots.footer ? (r(), i("div", {
+                      key: 2,
+                      class: a([e(t).e("footer"), o.footerClass])
+                    }, [
+                      f(l.$slots, "footer")
+                    ], 2)) : n("", !0),
+                    o.resizable ? (r(), i("div", {
+                      key: 3,
+                      ref_key: "draggerRef",
+                      ref: B,
+                      style: Z({ zIndex: e(g) }),
+                      class: a(e(t).e("dragger"))
+                    }, null, 6)) : n("", !0)
+                  ], 16, pe)
+                ]),
+                _: 3
+              }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
+            ]),
+            _: 3
+          }, 8, ["mask", "overlay-class", "z-index", "onClick"]), [
+            [_, e(y)]
+          ])
+        ]),
+        _: 3
+      }, 8, ["name", "onAfterEnter", "onAfterLeave", "onBeforeLeave"])
+    ], 8, ["to", "disabled"]));
+  }
+});
+export {
+  Ve as default
+};

package/dist/components/drawer/EpDrawer2.vue.js

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

package/dist/components/drawer/drawer.d.ts

@@ -0,0 +1,105 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type { DialogProps } from '@element-plus/components/dialog';
+export interface DrawerProps extends DialogProps {
+    /**
+     * @description Set the direction in which the Drawer opens
+     */
+    direction?: 'ltr' | 'rtl' | 'ttb' | 'btt';
+    /**
+     * @description Whether to enable the resizable function for the drawer
+     */
+    resizable?: boolean;
+    /**
+     * @description The size of the Drawer form, when using the number type, is measured in pixels. When using the string type, please pass in 'x%'; otherwise, it will be interpreted as the number type
+     */
+    size?: string | number;
+    /**
+     * @description You can remove the title from the drawer, so that your drawer will have more space on the screen. If you want to be visited, you must set the title attribute.
+     */
+    withHeader?: boolean;
+    /**
+     * @description The fade-in and fade-out animation switch of the mask layer
+     */
+    modalFade?: boolean;
+    /**
+     * @description Help assistive technologies such as screen readers identify content hierarchies
+     */
+    headerAriaLevel?: string;
+}
+export declare const drawerProps: {
+    readonly direction: import("@element-plus/utils").EpPropFinalized<StringConstructor, "ltr" | "rtl" | "ttb" | "btt", unknown, "rtl", boolean>;
+    readonly resizable: BooleanConstructor;
+    readonly size: import("@element-plus/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "30%", boolean>;
+    readonly withHeader: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modalFade: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly headerAriaLevel: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+    readonly appendToBody: BooleanConstructor;
+    readonly appendTo: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown, "body", boolean>;
+    readonly beforeClose: {
+        readonly type: import("vue").PropType<import("../dialog/dialog").DialogBeforeCloseFn>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly destroyOnClose: BooleanConstructor;
+    readonly closeOnClickModal: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly closeOnPressEscape: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly lockScroll: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modal: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly modalPenetrable: BooleanConstructor;
+    readonly openDelay: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly closeDelay: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly top: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly modelValue: BooleanConstructor;
+    readonly modalClass: StringConstructor;
+    readonly headerClass: StringConstructor;
+    readonly bodyClass: StringConstructor;
+    readonly footerClass: StringConstructor;
+    readonly width: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly zIndex: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly trapFocus: BooleanConstructor;
+    readonly transition: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | import("vue").TransitionProps) | (() => import("../dialog/dialog").DialogTransition) | (((new (...args: any[]) => string | import("vue").TransitionProps) | (() => import("../dialog/dialog").DialogTransition)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly center: BooleanConstructor;
+    readonly alignCenter: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly closeIcon: {
+        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 draggable: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly overflow: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly showClose: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+};
+export type DrawerPropsPublic = ExtractPublicPropTypes<typeof drawerProps>;
+export declare const drawerEmits: {
+    'resize-start': (evt: MouseEvent, size: number) => boolean;
+    resize: (evt: MouseEvent, size: number) => boolean;
+    'resize-end': (evt: MouseEvent, size: number) => boolean;
+    open: () => boolean;
+    opened: () => boolean;
+    close: () => boolean;
+    closed: () => boolean;
+    "update:modelValue": (value: boolean) => boolean;
+    openAutoFocus: () => boolean;
+    closeAutoFocus: () => boolean;
+};
+export type DrawerEmits = typeof drawerEmits;

package/dist/components/drawer/drawer.js

@@ -0,0 +1,42 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as r } from "../../utils/vue/props/runtime.js";
+import "vue";
+import "../dialog/index.js";
+import { dialogProps as o, dialogEmits as i } from "../dialog/dialog.js";
+r({
+  ...o,
+  direction: {
+    type: String,
+    default: "rtl",
+    values: ["ltr", "rtl", "ttb", "btt"]
+  },
+  resizable: Boolean,
+  size: {
+    type: [String, Number],
+    default: "30%"
+  },
+  withHeader: {
+    type: Boolean,
+    default: !0
+  },
+  modalFade: {
+    type: Boolean,
+    default: !0
+  },
+  headerAriaLevel: {
+    type: String,
+    default: "2"
+  }
+});
+const f = {
+  ...i,
+  "resize-start": (e, t) => e instanceof MouseEvent && typeof t == "number",
+  resize: (e, t) => e instanceof MouseEvent && typeof t == "number",
+  "resize-end": (e, t) => e instanceof MouseEvent && typeof t == "number"
+};
+export {
+  f as drawerEmits
+};

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

@@ -1,4 +1,16 @@
 import type { Plugin } from 'vue';
-import { ElDrawer } from 'element-plus';
-export declare const EpDrawer: typeof ElDrawer & Plugin;
+import _EpDrawer from './EpDrawer.vue';
+/**
+ * drawer 自持 barrel（vendor-batch-6 产出）。
+ *
+ * 抽屉复用本地 dialog barrel 的 `useDialog` / `dialogProps` /
+ * `dialogEmits` / `dialogPropsDefaults`，**不**引用上游 Dialog；遮罩与焦点约束
+ * 分别消费内部件 `../overlay` 与本地 `ElFocusTrap`。
+ *
+ * 不导出 `ElDrawer` 别名。三个尺寸调整事件由 `drawerEmits` 声明。
+ */
+export declare const EpDrawer: typeof _EpDrawer & Plugin;
 export default EpDrawer;
+export { drawerEmits, drawerProps } from './drawer';
+export type { DrawerEmits, DrawerProps, DrawerPropsPublic } from './drawer';
+export type { DrawerInstance } from './instance';

package/dist/components/drawer/index.js

@@ -1,6 +1,11 @@
-import { ElDrawer as r } from "element-plus";
-import { withInstall as e } from "../../utils/with-install.js";
-const a = Object.assign({}, r, { name: "EpDrawer" }), p = e(a, "ep-drawer");
+import { withInstall as r } from "../../utils/with-install.js";
+import o from "./EpDrawer.vue.js";
+import { drawerEmits as i } from "./drawer.js";
+const e = r(
+  o,
+  "ep-drawer"
+);
 export {
-  p as EpDrawer
+  e as EpDrawer,
+  i as drawerEmits
 };

package/dist/components/drawer/instance.d.ts

@@ -0,0 +1,2 @@
+import type EpDrawer from './EpDrawer.vue';
+export type DrawerInstance = InstanceType<typeof EpDrawer> & unknown;

package/dist/components/drawer/useResizable.d.ts

@@ -0,0 +1,7 @@
+import type { Ref, SetupContext } from 'vue';
+import type { DrawerEmits, DrawerProps } from './drawer';
+export declare function useResizable(props: DrawerProps & Required<Pick<DrawerProps, 'direction'>>, target: Ref<HTMLElement | undefined>, emit: SetupContext<DrawerEmits>['emit']): {
+    size: import("vue").ComputedRef<string | undefined>;
+    isResizing: Ref<boolean, boolean>;
+    isHorizontal: import("vue").ComputedRef<boolean>;
+};

package/dist/components/drawer/useResizable.js

@@ -0,0 +1,50 @@
+import { computed as u, ref as v, watch as H, onBeforeUnmount as R } from "vue";
+import "@vue/shared";
+import "lodash-unified";
+import { useWindowSize as W, clamp as A, useEventListener as m } from "@vueuse/core";
+import { addUnit as B } from "../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+function q(o, g, c) {
+  const { width: w, height: h } = W(), a = u(() => ["ltr", "rtl"].includes(o.direction)), S = u(
+    () => ["ltr", "ttb"].includes(o.direction) ? 1 : -1
+  ), p = u(
+    () => a.value ? w.value : h.value
+  ), f = u(() => A(
+    s.value + S.value * n.value,
+    4,
+    p.value
+  )), s = v(0), n = v(0), i = v(!1), l = v(!1);
+  let r = [], d = [];
+  const b = () => {
+    var t;
+    const e = (t = g.value) == null ? void 0 : t.closest('[aria-modal="true"]');
+    return e ? a.value ? e.offsetWidth : e.offsetHeight : 100;
+  };
+  H(
+    () => [o.size, o.resizable],
+    () => {
+      l.value = !1, s.value = 0, n.value = 0, z();
+    }
+  );
+  const M = (e) => {
+    o.resizable && (l.value || (s.value = b(), l.value = !0), r = [e.pageX, e.pageY], i.value = !0, c("resize-start", e, s.value), d.push(
+      m(window, "mouseup", z),
+      m(window, "mousemove", E)
+    ));
+  }, E = (e) => {
+    const { pageX: t, pageY: X } = e, Y = t - r[0], x = X - r[1];
+    n.value = a.value ? Y : x, c("resize", e, f.value);
+  }, z = (e) => {
+    i.value && (r = [], s.value = f.value, n.value = 0, i.value = !1, d.forEach((t) => t == null ? void 0 : t()), d = [], e && c("resize-end", e, s.value));
+  }, U = m(g, "mousedown", M);
+  return R(() => {
+    U(), z();
+  }), {
+    size: u(() => l.value ? `${f.value}px` : B(o.size)),
+    isResizing: i,
+    isHorizontal: a
+  };
+}
+export {
+  q as useResizable
+};

package/dist/components/empty/EpEmpty.vue.d.ts

@@ -0,0 +1,20 @@
+import type { EmptyProps } from './empty';
+declare var __VLS_1: {}, __VLS_6: {}, __VLS_8: {};
+type __VLS_Slots = {} & {
+    image?: (props: typeof __VLS_1) => any;
+} & {
+    description?: (props: typeof __VLS_6) => any;
+} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<EmptyProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<EmptyProps> & Readonly<{}>, {
+    description: string;
+    image: string;
+}, {}, {}, {}, 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/empty/EpEmpty.vue.js

@@ -0,0 +1,62 @@
+import { defineComponent as f, computed as p, openBlock as o, createElementBlock as i, normalizeClass as s, unref as m, createElementVNode as l, normalizeStyle as y, renderSlot as a, createVNode as g, toDisplayString as v, createCommentVNode as E } from "vue";
+import { useNamespace as S } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { addUnit as $ } from "../../utils/dom/style.js";
+import "@element-plus/icons-vue";
+import { useLocale as k } from "../../hooks/use-locale/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";
+import h from "./img-empty.vue.js";
+const z = ["src"], N = { key: 1 }, J = /* @__PURE__ */ f({
+  name: "EpEmpty",
+  __name: "EpEmpty",
+  props: {
+    image: { default: "" },
+    imageSize: {},
+    description: { default: "" }
+  },
+  setup(r) {
+    const n = r, { t: c } = k(), t = S("empty"), d = p(
+      () => n.description || c("el.table.emptyText")
+    ), u = p(() => ({
+      width: $(n.imageSize)
+    }));
+    return (e, b) => (o(), i("div", {
+      class: s(m(t).b())
+    }, [
+      l("div", {
+        class: s(m(t).e("image")),
+        style: y(u.value)
+      }, [
+        r.image ? (o(), i("img", {
+          key: 0,
+          src: r.image,
+          ondragstart: "return false"
+        }, null, 8, z)) : a(e.$slots, "image", {}, () => [
+          g(h)
+        ], void 0, 1)
+      ], 6),
+      l("div", {
+        class: s(m(t).e("description"))
+      }, [
+        e.$slots.description ? a(e.$slots, "description", {}, void 0, void 0, 0) : (o(), i("p", N, v(d.value), 1))
+      ], 2),
+      e.$slots.default ? (o(), i("div", {
+        key: 0,
+        class: s(m(t).e("bottom"))
+      }, [
+        a(e.$slots, "default")
+      ], 2)) : E("", !0)
+    ], 2));
+  }
+});
+export {
+  J as default
+};

package/dist/components/empty/EpEmpty2.vue.js

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

package/dist/components/empty/empty.d.ts

@@ -0,0 +1,27 @@
+import type { ExtractPublicPropTypes } from 'vue';
+export interface EmptyProps {
+    /**
+     * @description image URL of empty
+     */
+    image?: string;
+    /**
+     * @description image size (width) of empty
+     */
+    imageSize?: number;
+    /**
+     * @description description of empty
+     */
+    description?: string;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `EmptyProps` instead.
+ */
+export declare const emptyProps: {
+    readonly image: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly imageSize: NumberConstructor;
+    readonly description: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `EmptyProps` instead.
+ */
+export type EmptyPropsPublic = ExtractPublicPropTypes<typeof emptyProps>;

package/dist/components/empty/empty.js

@@ -0,0 +1,26 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as i } from "../../utils/vue/props/runtime.js";
+import "vue";
+i({
+  /**
+   * @description image URL of empty
+   */
+  image: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description image size (width) of empty
+   */
+  imageSize: Number,
+  /**
+   * @description description of empty
+   */
+  description: {
+    type: String,
+    default: ""
+  }
+});

package/dist/components/empty/img-empty.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;