ep-craft 0.1.35 → 0.1.37

package/dist/components/skeleton/skeleton.d.ts

@@ -0,0 +1,53 @@
+import type EpSkeleton from './EpSkeleton.vue';
+import type { ExtractPublicPropTypes } from 'vue';
+import type { ThrottleType } from '@element-plus/hooks';
+export interface SkeletonProps {
+    /**
+     * @description whether showing the animation
+     */
+    animated?: boolean;
+    /**
+     * @description how many fake items to render to the DOM
+     */
+    count?: number;
+    /**
+     * @description numbers of the row, only useful when no template slot were given
+     */
+    rows?: number;
+    /**
+     * @description whether showing the real DOM
+     */
+    loading?: boolean;
+    /**
+     * @description rendering delay in milliseconds
+     */
+    throttle?: ThrottleType;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `SkeletonProps` instead.
+ */
+export declare const skeletonProps: {
+    readonly animated: BooleanConstructor;
+    readonly count: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+    readonly rows: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 3, boolean>;
+    readonly loading: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly throttle: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => number | {
+            leading?: number;
+            trailing?: number;
+            initVal?: boolean;
+        }) | (() => ThrottleType) | (((new (...args: any[]) => number | {
+            leading?: number;
+            trailing?: number;
+            initVal?: boolean;
+        }) | (() => ThrottleType)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `SkeletonProps` instead.
+ */
+export type SkeletonPropsPublic = ExtractPublicPropTypes<typeof skeletonProps>;
+export type SkeletonInstance = InstanceType<typeof EpSkeleton> & unknown;

package/dist/components/skeleton/skeleton.js

@@ -0,0 +1,39 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as t, definePropType as e } from "../../utils/vue/props/runtime.js";
+import "vue";
+t({
+  /**
+   * @description whether showing the animation
+   */
+  animated: Boolean,
+  /**
+   * @description how many fake items to render to the DOM
+   */
+  count: {
+    type: Number,
+    default: 1
+  },
+  /**
+   * @description numbers of the row, only useful when no template slot were given
+   */
+  rows: {
+    type: Number,
+    default: 3
+  },
+  /**
+   * @description whether showing the real DOM
+   */
+  loading: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description rendering delay in milliseconds
+   */
+  throttle: {
+    type: e([Number, Object])
+  }
+});

package/dist/components/skeleton-item/EpSkeletonItem.vue.d.ts

@@ -0,0 +1,5 @@
+import type { SkeletonItemProps } from './skeleton-item';
+declare const _default: import("vue").DefineComponent<SkeletonItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonItemProps> & Readonly<{}>, {
+    variant: "circle" | "rect" | "h1" | "h3" | "text" | "caption" | "p" | "image" | "button";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/skeleton-item/EpSkeletonItem.vue.js

@@ -0,0 +1,31 @@
+import { defineComponent as m, openBlock as r, createElementBlock as i, normalizeClass as a, unref as e, createBlock as n, createCommentVNode as p } from "vue";
+import { useNamespace as c } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { PictureFilled as l } 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";
+const h = /* @__PURE__ */ m({
+  name: "EpSkeletonItem",
+  __name: "EpSkeletonItem",
+  props: {
+    variant: { default: "text" }
+  },
+  setup(t) {
+    const o = c("skeleton");
+    return (s, u) => (r(), i("div", {
+      class: a([e(o).e("item"), e(o).e(t.variant)])
+    }, [
+      t.variant === "image" ? (r(), n(e(l), { key: 0 })) : p("", !0)
+    ], 2));
+  }
+});
+export {
+  h as default
+};

package/dist/components/skeleton-item/EpSkeletonItem2.vue.js

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

package/dist/components/skeleton-item/index.d.ts

@@ -1,4 +1,10 @@
 import type { Plugin } from 'vue';
-import { ElSkeletonItem } from 'element-plus';
-export declare const EpSkeletonItem: typeof ElSkeletonItem & Plugin;
+import _EpSkeletonItem from './EpSkeletonItem.vue';
+/**
+ * skeleton-item 自持 barrel（vendor-batch-4 产出）。
+ * 不导出 `ElSkeletonItem` 别名。
+ */
+export declare const EpSkeletonItem: typeof _EpSkeletonItem & Plugin;
 export default EpSkeletonItem;
+export { skeletonItemProps } from './skeleton-item';
+export type { SkeletonItemInstance, SkeletonItemProps, SkeletonItemPropsPublic, } from './skeleton-item';

package/dist/components/skeleton-item/index.js

@@ -1,6 +1,10 @@
-import { ElSkeletonItem as e } from "element-plus";
 import { withInstall as t } from "../../utils/with-install.js";
-const o = Object.assign({}, e, { name: "EpSkeletonItem" }), l = t(o, "ep-skeleton-item");
+import o from "./EpSkeletonItem.vue.js";
+import "./skeleton-item.js";
+const p = t(
+  o,
+  "ep-skeleton-item"
+);
 export {
-  l as EpSkeletonItem
+  p as EpSkeletonItem
 };

package/dist/components/skeleton-item/skeleton-item.d.ts

@@ -0,0 +1,19 @@
+import type EpSkeletonItem from './EpSkeletonItem.vue';
+import type { ExtractPublicPropTypes } from 'vue';
+export interface SkeletonItemProps {
+    /**
+     * @description the current rendering skeleton type
+     */
+    variant?: 'circle' | 'rect' | 'h1' | 'h3' | 'text' | 'caption' | 'p' | 'image' | 'button';
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `SkeletonItemProps` instead.
+ */
+export declare const skeletonItemProps: {
+    readonly variant: import("@element-plus/utils").EpPropFinalized<StringConstructor, "button" | "text" | "caption" | "circle" | "h1" | "h3" | "p" | "image" | "rect", unknown, "text", boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `SkeletonItemProps` instead.
+ */
+export type SkeletonItemPropsPublic = ExtractPublicPropTypes<typeof skeletonItemProps>;
+export type SkeletonItemInstance = InstanceType<typeof EpSkeletonItem> & unknown;

package/dist/components/skeleton-item/skeleton-item.js

@@ -0,0 +1,26 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as t } from "../../utils/vue/props/runtime.js";
+import "vue";
+t({
+  /**
+   * @description the current rendering skeleton type
+   */
+  variant: {
+    type: String,
+    values: [
+      "circle",
+      "rect",
+      "h1",
+      "h3",
+      "text",
+      "caption",
+      "p",
+      "image",
+      "button"
+    ],
+    default: "text"
+  }
+});

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

@@ -1,4 +1,17 @@
 import type { Plugin } from 'vue';
-import { ElSpace } from 'element-plus';
-export declare const EpSpace: typeof ElSpace & Plugin;
+import _EpSpace from './space';
+/**
+ * space 自持 barrel（vendor-batch-5 产出）。
+ *
+ * 本体保持 `.ts` 渲染式组件形态（上游无 SFC），内部子项与间距计算
+ * 随本体落到本地。按上游契约导出 `spaceItemProps` / `useSpace`；
+ * 内部子项组件不对外公开。不导出 `ElSpace` 别名。
+ */
+export declare const EpSpace: typeof _EpSpace & Plugin;
 export default EpSpace;
+export { spaceItemProps } from './item';
+export { spaceProps } from './space';
+export { useSpace } from './use-space';
+export type { SpaceItemProps, SpaceItemPropsPublic, } from './item';
+export type { SpaceProps, SpacePropsPublic } from './space';
+export type { SpaceInstance } from './instance';

package/dist/components/space/index.js

@@ -1,6 +1,25 @@
-import { ElSpace as p } from "element-plus";
-import { withInstall as e } from "../../utils/with-install.js";
-const a = Object.assign({}, p, { name: "EpSpace" }), o = e(a, "ep-space");
+import { withInstall as p } from "../../utils/with-install.js";
+import o from "./space.js";
+import { spaceProps as E } from "./space.js";
+import { spaceItemProps as d } from "./item.js";
+import "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@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";
+const S = p(
+  o,
+  "ep-space"
+);
 export {
-  o as EpSpace
+  S as EpSpace,
+  d as spaceItemProps,
+  E as spaceProps
 };

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

@@ -0,0 +1,2 @@
+import type Space from './space';
+export type SpaceInstance = InstanceType<typeof Space> & unknown;

package/dist/components/space/item.d.ts

@@ -0,0 +1,29 @@
+import type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+export declare const spaceItemProps: {
+    readonly prefixCls: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type SpaceItemProps = ExtractPropTypes<typeof spaceItemProps>;
+export type SpaceItemPropsPublic = ExtractPublicPropTypes<typeof spaceItemProps>;
+declare const SpaceItem: import("vue").DefineComponent<ExtractPropTypes<{
+    readonly prefixCls: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, () => 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 prefixCls: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default SpaceItem;

package/dist/components/space/item.js

@@ -0,0 +1,30 @@
+import { defineComponent as r, computed as m, h as i, renderSlot as s } from "vue";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { buildProps as a } from "../../utils/vue/props/runtime.js";
+import { useNamespace as c } 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 n = a({
+  prefixCls: {
+    type: String
+  }
+}), y = r({
+  name: "EpSpaceItem",
+  props: n,
+  setup(t, { slots: p }) {
+    const o = c("space"), e = m(() => `${t.prefixCls || o.b()}__item`);
+    return () => i("div", { class: e.value }, s(p, "default"));
+  }
+});
+export {
+  y as default,
+  n as spaceItemProps
+};

package/dist/components/space/space.d.ts

@@ -0,0 +1,92 @@
+import type { ExtractPropTypes, ExtractPublicPropTypes, StyleValue, VNode, VNodeChild } from 'vue';
+import type { Arrayable } from '@element-plus/utils';
+export declare const spaceProps: {
+    readonly direction: import("@element-plus/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "horizontal", boolean>;
+    readonly class: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => Arrayable<string | Record<string, boolean>>) | (((new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => Arrayable<string | Record<string, boolean>>)) | null)[], unknown, unknown, "", boolean>;
+    readonly style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue)) | null)[], unknown, unknown, "", boolean>;
+    readonly alignment: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => import("csstype").Property.AlignItems | undefined) | (((new (...args: any[]) => string) | (() => import("csstype").Property.AlignItems | undefined)) | null)[], unknown, unknown, "center", boolean>;
+    readonly prefixCls: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly spacer: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => VNodeChild & {}) | (() => VNodeChild) | (((new (...args: any[]) => VNodeChild & {}) | (() => VNodeChild)) | null)[], unknown, string | number | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, null, boolean>;
+    readonly wrap: BooleanConstructor;
+    readonly fill: BooleanConstructor;
+    readonly fillRatio: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 100, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor, NumberConstructor], "" | "small" | "default" | "large", number | [number, number]>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type SpaceProps = ExtractPropTypes<typeof spaceProps>;
+export type SpacePropsPublic = ExtractPublicPropTypes<typeof spaceProps>;
+declare const Space: import("vue").DefineComponent<ExtractPropTypes<{
+    readonly direction: import("@element-plus/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "horizontal", boolean>;
+    readonly class: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => Arrayable<string | Record<string, boolean>>) | (((new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => Arrayable<string | Record<string, boolean>>)) | null)[], unknown, unknown, "", boolean>;
+    readonly style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue)) | null)[], unknown, unknown, "", boolean>;
+    readonly alignment: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => import("csstype").Property.AlignItems | undefined) | (((new (...args: any[]) => string) | (() => import("csstype").Property.AlignItems | undefined)) | null)[], unknown, unknown, "center", boolean>;
+    readonly prefixCls: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly spacer: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => VNodeChild & {}) | (() => VNodeChild) | (((new (...args: any[]) => VNodeChild & {}) | (() => VNodeChild)) | null)[], unknown, string | number | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, null, boolean>;
+    readonly wrap: BooleanConstructor;
+    readonly fill: BooleanConstructor;
+    readonly fillRatio: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 100, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor, NumberConstructor], "" | "small" | "default" | "large", number | [number, number]>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>, () => string | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | {
+    [name: string]: unknown;
+    $stable?: boolean;
+} | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    readonly direction: import("@element-plus/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "horizontal", boolean>;
+    readonly class: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => Arrayable<string | Record<string, boolean>>) | (((new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => Arrayable<string | Record<string, boolean>>)) | null)[], unknown, unknown, "", boolean>;
+    readonly style: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | StyleValue[]) | (() => StyleValue)) | null)[], unknown, unknown, "", boolean>;
+    readonly alignment: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => import("csstype").Property.AlignItems | undefined) | (((new (...args: any[]) => string) | (() => import("csstype").Property.AlignItems | undefined)) | null)[], unknown, unknown, "center", boolean>;
+    readonly prefixCls: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly spacer: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => VNodeChild & {}) | (() => VNodeChild) | (((new (...args: any[]) => VNodeChild & {}) | (() => VNodeChild)) | null)[], unknown, string | number | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, null, boolean>;
+    readonly wrap: BooleanConstructor;
+    readonly fill: BooleanConstructor;
+    readonly fillRatio: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 100, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor, NumberConstructor], "" | "small" | "default" | "large", number | [number, number]>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {
+    readonly fill: boolean;
+    readonly style: StyleValue;
+    readonly direction: import("@element-plus/utils").EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>;
+    readonly wrap: boolean;
+    readonly spacer: import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => VNodeChild & {}) | (() => VNodeChild) | (((new (...args: any[]) => VNodeChild & {}) | (() => VNodeChild)) | null)[], unknown, string | number | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>>;
+    readonly class: import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => Arrayable<string | Record<string, boolean>>) | (((new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => Arrayable<string | Record<string, boolean>>)) | null)[], unknown, unknown>;
+    readonly alignment: import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("csstype").Property.AlignItems | undefined) | (((new (...args: any[]) => string) | (() => import("csstype").Property.AlignItems | undefined)) | null)[], unknown, unknown>;
+    readonly fillRatio: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default Space;

package/dist/components/space/space.js

@@ -0,0 +1,182 @@
+import { isVNode as S, defineComponent as P, renderSlot as T, createVNode as s, createTextVNode as A, Comment as L } from "vue";
+import { isNumber as y } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import { isArray as c, isString as C } from "@vue/shared";
+import { componentSizes as O } from "../../constants/size.js";
+import "@element-plus/icons-vue";
+import { buildProps as z, definePropType as u } from "../../utils/vue/props/runtime.js";
+import { PatchFlags as i, isFragment as g, isValidElementNode as V } from "../../utils/vue/vnode.js";
+import E from "./item.js";
+import { useSpace as Y } from "./use-space.js";
+const j = z({
+  /**
+   * @description Placement direction
+   */
+  direction: {
+    type: String,
+    values: ["horizontal", "vertical"],
+    default: "horizontal"
+  },
+  /**
+   * @description Classname
+   */
+  class: {
+    type: u([
+      String,
+      Object,
+      Array
+    ]),
+    default: ""
+  },
+  /**
+   * @description Extra style rules
+   */
+  style: {
+    type: u([String, Array, Object, Boolean]),
+    default: ""
+  },
+  /**
+   * @description Controls the alignment of items
+   */
+  alignment: {
+    type: u(String),
+    default: "center"
+  },
+  /**
+   * @description Prefix for space-items
+   */
+  prefixCls: {
+    type: String
+  },
+  /**
+   * @description Spacer
+   */
+  spacer: {
+    type: u([Object, String, Number, Array]),
+    default: null,
+    validator: (e) => S(e) || y(e) || C(e)
+  },
+  /**
+   * @description Auto wrapping
+   */
+  wrap: Boolean,
+  /**
+   * @description Whether to fill the container
+   */
+  fill: Boolean,
+  /**
+   * @description Ratio of fill
+   */
+  fillRatio: {
+    type: Number,
+    default: 100
+  },
+  /**
+   * @description Spacing size
+   */
+  size: {
+    type: [String, Array, Number],
+    values: O,
+    validator: (e) => y(e) || c(e) && e.length === 2 && e.every(y)
+  }
+}), G = P({
+  name: "EpSpace",
+  props: j,
+  setup(e, { slots: b }) {
+    const { classes: v, containerStyle: N, itemStyle: f } = Y(e);
+    function d(n, a = "", t = []) {
+      const { prefixCls: l } = e;
+      return n.forEach((o, m) => {
+        g(o) ? c(o.children) && o.children.forEach((r, p) => {
+          g(r) && c(r.children) ? d(
+            r.children,
+            `${a + p}-`,
+            t
+          ) : S(r) && (r == null ? void 0 : r.type) === L ? t.push(r) : t.push(
+            s(
+              E,
+              {
+                style: f.value,
+                prefixCls: l,
+                key: `nested-${a + p}`
+              },
+              {
+                default: () => [r]
+              },
+              i.PROPS | i.STYLE,
+              ["style", "prefixCls"]
+            )
+          );
+        }) : V(o) && t.push(
+          s(
+            E,
+            {
+              style: f.value,
+              prefixCls: l,
+              key: `LoopKey${a + m}`
+            },
+            {
+              default: () => [o]
+            },
+            i.PROPS | i.STYLE,
+            ["style", "prefixCls"]
+          )
+        );
+      }), t;
+    }
+    return () => {
+      const { spacer: n, direction: a } = e, t = T(b, "default", { key: 0 }, () => []);
+      if ((t.children ?? []).length === 0) return null;
+      if (c(t.children)) {
+        let l = d(t.children);
+        if (n) {
+          const o = l.length - 1;
+          l = l.reduce(
+            (m, r, p) => {
+              const h = [...m, r];
+              return p !== o && h.push(
+                s(
+                  "span",
+                  // adding width 100% for vertical alignment,
+                  // when the spacer inherit the width from the
+                  // parent, this span's width was not set, so space
+                  // might disappear
+                  {
+                    style: [
+                      f.value,
+                      a === "vertical" ? "width: 100%" : null
+                    ],
+                    key: p
+                  },
+                  [
+                    // if spacer is already a valid vnode, then append it to the current
+                    // span element.
+                    // otherwise, treat it as string.
+                    S(n) ? n : A(n, i.TEXT)
+                  ],
+                  i.STYLE
+                )
+              ), h;
+            },
+            []
+          );
+        }
+        return s(
+          "div",
+          {
+            class: v.value,
+            style: N.value
+          },
+          l,
+          i.STYLE | i.CLASS
+        );
+      }
+      return t.children;
+    };
+  }
+});
+export {
+  G as default,
+  j as spaceProps
+};

package/dist/components/space/use-space.d.ts

@@ -0,0 +1,7 @@
+import type { SpaceProps } from './space';
+import type { StyleValue } from 'vue';
+export declare function useSpace(props: SpaceProps): {
+    classes: import("vue").ComputedRef<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => import("@element-plus/utils").Arrayable<string | Record<string, boolean>>) | (((new (...args: any[]) => string | Record<string, boolean> | (string | Record<string, boolean>)[]) | (() => import("@element-plus/utils").Arrayable<string | Record<string, boolean>>)) | null)[], unknown, unknown>[]>;
+    containerStyle: import("vue").ComputedRef<StyleValue>;
+    itemStyle: import("vue").ComputedRef<StyleValue>;
+};