ele-admin-plus 1.0.0-beta.1

package/es/ele-breadcrumb/index.d.ts

@@ -0,0 +1,194 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    items: {
+        type: import("vue").PropType<import("./types").BreadcrumbItem[]>;
+        required: boolean;
+    };
+    separator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "/", boolean>;
+    separatorIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {
+    breadcrumbRef: import("vue").Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly separator?: string | undefined;
+            key?: string | number | symbol | undefined;
+            readonly separatorIcon?: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown> | undefined;
+            ref?: import("vue").VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            class?: unknown;
+            style?: unknown;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            readonly separator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "/", boolean>;
+            readonly separatorIcon: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly separator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "/", boolean>;
+                readonly separatorIcon: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & {
+                [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+            }>>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string | undefined) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            breadcrumb: import("vue").Ref<HTMLDivElement | undefined>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
+            readonly separator: string;
+        }, {}, string, {}> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        readonly separator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "/", boolean>;
+        readonly separatorIcon: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & import("vue").ShallowUnwrapRef<{
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly separator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "/", boolean>;
+            readonly separatorIcon: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+        }>>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string | undefined) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        breadcrumb: import("vue").Ref<HTMLDivElement | undefined>;
+    }> & {} & import("vue").ComponentCustomProperties & {}) | null>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    items: {
+        type: import("vue").PropType<import("./types").BreadcrumbItem[]>;
+        required: boolean;
+    };
+    separator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "/", boolean>;
+    separatorIcon: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {
+    separator: string;
+}, {}>;
+export default _sfc_main;

package/es/ele-breadcrumb/index.js

@@ -0,0 +1,64 @@
+import { defineComponent, ref, resolveComponent, openBlock, createBlock, withCtx, createElementBlock, Fragment, renderList, renderSlot, normalizeProps, mergeProps, resolveDynamicComponent, normalizeStyle, createCommentVNode, toDisplayString } from "vue";
+import { ElBreadcrumb, ElBreadcrumbItem, ElIcon } from "element-plus";
+import { breadcrumbProps } from "./props";
+const _sfc_main = defineComponent({
+  name: "EleBreadcrumb",
+  components: { ElBreadcrumb, ElBreadcrumbItem, ElIcon },
+  props: breadcrumbProps,
+  setup(_props) {
+    const breadcrumbRef = ref(null);
+    return { breadcrumbRef };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { key: 1 };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_ElBreadcrumbItem = resolveComponent("ElBreadcrumbItem");
+  const _component_ElBreadcrumb = resolveComponent("ElBreadcrumb");
+  return openBlock(), createBlock(_component_ElBreadcrumb, {
+    ref: "breadcrumbRef",
+    separator: _ctx.separator,
+    separatorIcon: _ctx.separatorIcon,
+    class: "ele-breadcrumb"
+  }, {
+    default: withCtx(() => [
+      (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.items, (item) => {
+        return openBlock(), createBlock(_component_ElBreadcrumbItem, {
+          key: item.key || item.title,
+          replace: item.replace,
+          to: item.to
+        }, {
+          default: withCtx(() => [
+            item.slot && _ctx.$slots[item.slot] ? renderSlot(_ctx.$slots, item.slot, {
+              key: 0,
+              item
+            }) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+              item.icon ? (openBlock(), createBlock(_component_ElIcon, normalizeProps(mergeProps({ key: 0 }, item.iconProps || {})), {
+                default: withCtx(() => [
+                  (openBlock(), createBlock(resolveDynamicComponent(item.icon), {
+                    style: normalizeStyle(item.iconStyle)
+                  }, null, 8, ["style"]))
+                ]),
+                _: 2
+              }, 1040)) : createCommentVNode("", true),
+              item.title ? (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(item.title), 1)) : createCommentVNode("", true)
+            ], 64))
+          ]),
+          _: 2
+        }, 1032, ["replace", "to"]);
+      }), 128))
+    ]),
+    _: 3
+  }, 8, ["separator", "separatorIcon"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  index as default
+};

package/es/ele-breadcrumb/props.d.ts

@@ -0,0 +1,19 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+import type { BreadcrumbItem } from './types';
+/**
+ * 属性
+ */
+export declare const breadcrumbProps: {
+    items: {
+        type: PropType<BreadcrumbItem[]>;
+        required: boolean;
+    };
+    separator: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "/", boolean>;
+    separatorIcon: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type BreadcrumbProps = ExtractPropTypes<typeof breadcrumbProps>;

package/es/ele-breadcrumb/props.js

@@ -0,0 +1,12 @@
+import { breadcrumbProps as breadcrumbProps$1 } from "element-plus";
+const breadcrumbProps = {
+  ...breadcrumbProps$1,
+  // 面包屑数据
+  items: {
+    type: Array,
+    required: true
+  }
+};
+export {
+  breadcrumbProps
+};

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

@@ -0,0 +1,3 @@
+import 'element-plus/es/components/breadcrumb/style/index';
+import 'element-plus/es/components/breadcrumb-item/style/index';
+import './index.scss';

package/es/ele-breadcrumb/style/index.scss

@@ -0,0 +1,30 @@
+@use '../../style/themes/default.scss' as *;
+
+.ele-breadcrumb {
+  white-space: nowrap;
+  font-size: inherit;
+
+  &::after,
+  &::before {
+    display: none;
+  }
+
+  .el-breadcrumb__item {
+    float: none;
+    display: inline;
+    vertical-align: -2px;
+
+    .el-breadcrumb__inner {
+      color: elVar('text-color', 'secondary');
+      font-weight: normal;
+
+      &.is-link:hover {
+        color: elVar('color-primary');
+      }
+    }
+
+    &:last-child .el-breadcrumb__inner {
+      color: elVar('text-color', 'regular');
+    }
+  }
+}

package/es/ele-breadcrumb/types/index.d.ts

@@ -0,0 +1,22 @@
+import type { CSSProperties, Component } from 'vue';
+import type { BreadcrumbItemProps, IconProps } from 'element-plus';
+/**
+ * 面包屑数据
+ */
+export interface BreadcrumbItem extends Partial<BreadcrumbItemProps> {
+    key?: string | number;
+    title?: string;
+    icon?: string | Component;
+    iconProps?: BreadcrumbItemIconProps;
+    iconStyle?: CSSProperties;
+    slot?: string;
+}
+/**
+ * 面包屑图标属性
+ */
+export interface BreadcrumbItemIconProps extends Partial<IconProps> {
+    /** 样式 */
+    style?: CSSProperties;
+    /** 类名 */
+    class?: string;
+}

package/es/ele-card/index.d.ts

@@ -0,0 +1,26 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    header: StringConstructor;
+    bodyStyle: import("vue").PropType<import("vue").CSSProperties>;
+    shadow: {
+        type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "always" | "never" | "hover", unknown>>;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    headerStyle: import("vue").PropType<import("vue").CSSProperties>;
+    flexTable: BooleanConstructor;
+}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    header: StringConstructor;
+    bodyStyle: import("vue").PropType<import("vue").CSSProperties>;
+    shadow: {
+        type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "always" | "never" | "hover", unknown>>;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    headerStyle: import("vue").PropType<import("vue").CSSProperties>;
+    flexTable: BooleanConstructor;
+}>>, {
+    shadow: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "always" | "never" | "hover", unknown>;
+    bordered: boolean;
+    flexTable: boolean;
+}, {}>;
+export default _sfc_main;

package/es/ele-card/index.js

@@ -0,0 +1,55 @@
+import { defineComponent, resolveComponent, openBlock, createBlock, normalizeClass, createSlots, withCtx, renderSlot, createElementVNode, normalizeStyle, createTextVNode, toDisplayString } from "vue";
+import { ElCard } from "element-plus";
+import { cardProps } from "./props";
+const _sfc_main = defineComponent({
+  name: "EleCard",
+  components: { ElCard },
+  props: cardProps
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-card-title" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElCard = resolveComponent("ElCard");
+  return openBlock(), createBlock(_component_ElCard, {
+    bodyStyle: _ctx.bodyStyle,
+    shadow: _ctx.shadow,
+    class: normalizeClass([
+      "ele-card",
+      { "is-plain": !_ctx.bordered },
+      { "is-flex-table": _ctx.flexTable }
+    ])
+  }, createSlots({
+    default: withCtx(() => [
+      renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 2
+  }, [
+    _ctx.header || _ctx.$slots.header || _ctx.$slots.extra ? {
+      name: "header",
+      fn: withCtx(() => [
+        createElementVNode("div", {
+          class: "ele-card-header",
+          style: normalizeStyle(_ctx.headerStyle)
+        }, [
+          createElementVNode("div", _hoisted_1, [
+            renderSlot(_ctx.$slots, "header", {}, () => [
+              createTextVNode(toDisplayString(_ctx.header), 1)
+            ])
+          ]),
+          renderSlot(_ctx.$slots, "extra")
+        ], 4)
+      ]),
+      key: "0"
+    } : void 0
+  ]), 1032, ["bodyStyle", "shadow", "class"]);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  index as default
+};

package/es/ele-card/props.d.ts

@@ -0,0 +1,16 @@
+import type { ExtractPropTypes, PropType, CSSProperties } from 'vue';
+/**
+ * 属性
+ */
+export declare const cardProps: {
+    header: StringConstructor;
+    bodyStyle: PropType<CSSProperties>;
+    shadow: {
+        type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "always" | "never" | "hover", unknown>>;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    headerStyle: PropType<CSSProperties>;
+    flexTable: BooleanConstructor;
+};
+export type CardProps = ExtractPropTypes<typeof cardProps>;

package/es/ele-card/props.js

@@ -0,0 +1,20 @@
+const cardProps = {
+  // 标题
+  header: String,
+  // 主体样式
+  bodyStyle: Object,
+  // 阴影
+  shadow: {
+    type: String,
+    default: "never"
+  },
+  // 边框
+  bordered: Boolean,
+  // 标题栏样式
+  headerStyle: Object,
+  // 内部表格是否弹性布局
+  flexTable: Boolean
+};
+export {
+  cardProps
+};

package/es/ele-card/style/css-var.scss

@@ -0,0 +1,7 @@
+@use '../../style/themes/default.scss' as *;
+
+@mixin set-card-var($var) {
+  .ele-card .el-card__header {
+    @include set-ele-var('card-header', $var);
+  }
+}

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

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/card/style/index';
+import './index.scss';

package/es/ele-card/style/index.scss

@@ -0,0 +1,61 @@
+@use '../../style/themes/default.scss' as *;
+@use './css-var.scss' as *;
+
+@include set-card-var($ele);
+
+.ele-card {
+  box-sizing: border-box;
+
+  .el-card__body {
+    box-sizing: border-box;
+  }
+
+  .el-card__header {
+    padding: 0;
+    font-size: eleVar('card-header', 'font-size');
+    line-height: eleVar('card-header', 'line-height');
+  }
+
+  .ele-card-header {
+    display: flex;
+    align-items: center;
+    padding: eleVar('card-header', 'padding');
+    box-sizing: border-box;
+  }
+
+  .ele-card-title {
+    flex: 1;
+  }
+
+  // 去掉边框
+  &.is-plain {
+    border-width: 0;
+  }
+
+  // 内部表格弹性布局
+  &.is-flex-table {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    overflow: auto;
+
+    & > .el-card__body {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      overflow: auto;
+
+      & > .ele-pro-table {
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        overflow: auto;
+
+        & > .el-table {
+          flex: 1;
+          height: 100%;
+        }
+      }
+    }
+  }
+}

package/es/ele-config-provider/index.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("vue").DefineComponent<{
+    table: import("vue").PropType<Partial<Pick<import("../ele-pro-table/props").ProTableProps, "size" | "request" | "response" | "ascendingValue" | "descendingValue">>>;
+    mapKey: StringConstructor;
+    license: StringConstructor;
+    locale: import("vue").PropType<import("./types").EleLocale>;
+    keepAlive: BooleanConstructor;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    table: import("vue").PropType<Partial<Pick<import("../ele-pro-table/props").ProTableProps, "size" | "request" | "response" | "ascendingValue" | "descendingValue">>>;
+    mapKey: StringConstructor;
+    license: StringConstructor;
+    locale: import("vue").PropType<import("./types").EleLocale>;
+    keepAlive: BooleanConstructor;
+}>>, {
+    keepAlive: boolean;
+}, {}>;
+export default _default;

package/es/ele-config-provider/index.js

@@ -0,0 +1,49 @@
+import { defineComponent, reactive, provide, watch } from "vue";
+import { PROVIDE_KEY } from "./keys";
+import { configProviderProps } from "./props";
+const index = defineComponent({
+  name: "EleConfigProvider",
+  props: configProviderProps,
+  setup(props, { slots }) {
+    const config = reactive({ ...props });
+    provide(PROVIDE_KEY, config);
+    watch(
+      () => props.table,
+      () => {
+        config.table = props.table;
+      },
+      { deep: true }
+    );
+    watch(
+      () => props.mapKey,
+      () => {
+        config.mapKey = props.mapKey;
+      }
+    );
+    watch(
+      () => props.license,
+      () => {
+        config.license = props.license;
+      }
+    );
+    watch(
+      () => props.locale,
+      () => {
+        config.locale = props.locale;
+      }
+    );
+    watch(
+      () => props.keepAlive,
+      () => {
+        config.keepAlive = props.keepAlive;
+      }
+    );
+    return () => {
+      var _a;
+      return (_a = slots.default) == null ? void 0 : _a.call(slots);
+    };
+  }
+});
+export {
+  index as default
+};

package/es/ele-config-provider/keys.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 全局配置键名
+ */
+export declare const PROVIDE_KEY = "EleGlobalConfig";
+/**
+ * 布局状态共享键名
+ */
+export declare const LAYOUT_KEY = "EleLayoutState";

package/es/ele-config-provider/keys.js

@@ -0,0 +1,6 @@
+const PROVIDE_KEY = "EleGlobalConfig";
+const LAYOUT_KEY = "EleLayoutState";
+export {
+  LAYOUT_KEY,
+  PROVIDE_KEY
+};

package/es/ele-config-provider/props.d.ts

@@ -0,0 +1,13 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+import type { EleLocale } from './types';
+/**
+ * 属性
+ */
+export declare const configProviderProps: {
+    table: PropType<Partial<Pick<import("../ele-pro-table/props").ProTableProps, "size" | "request" | "response" | "ascendingValue" | "descendingValue">>>;
+    mapKey: StringConstructor;
+    license: StringConstructor;
+    locale: PropType<EleLocale>;
+    keepAlive: BooleanConstructor;
+};
+export type ConfigProviderProps = ExtractPropTypes<typeof configProviderProps>;