@qsxy/element-plus-react 1.0.0-next.1

package/dist/Descriptions/DescriptionsCell.js

@@ -0,0 +1,84 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Descriptions/DescriptionsCell.tsx
+var DescriptionsCell_exports = {};
+__export(DescriptionsCell_exports, {
+  default: () => DescriptionsCell_default
+});
+module.exports = __toCommonJS(DescriptionsCell_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = require("react");
+var import_hooks = require("../hooks");
+var import_DescriptionsContext = require("./DescriptionsContext");
+var DescriptionsCell = ({ cell, tag, type }) => {
+  const { label, span, align, labelAlign, className, labelClassName, width, minWidth, children } = cell.props;
+  const { direction, border } = (0, import_react.useContext)(import_DescriptionsContext.DescriptionsContext);
+  const { e, is } = (0, import_hooks.useClassNames)("descriptions");
+  const isVertical = (0, import_react.useMemo)(() => direction === "vertical", [direction]);
+  const style = (0, import_react.useMemo)(() => {
+    return { width, minWidth };
+  }, [minWidth, width]);
+  switch (type) {
+    case "label":
+      return (0, import_react.createElement)(
+        tag,
+        {
+          style,
+          className: (0, import_classnames.default)(e`cell`, e`label`, is({ "bordered-label": border, "vertical-label": isVertical, [labelAlign]: labelAlign }), labelClassName),
+          colSpan: isVertical ? span : 1
+        },
+        label
+      );
+    case "content":
+      return (0, import_react.createElement)(
+        tag,
+        {
+          style,
+          className: (0, import_classnames.default)(e`cell`, e`content`, is({ "bordered-label": border, "vertical-label": isVertical, [align]: align }), className),
+          colSpan: isVertical ? span : span * 2 - 1
+        },
+        children
+      );
+    default:
+      return (0, import_react.createElement)(
+        "td",
+        {
+          style,
+          className: (0, import_classnames.default)(e`cell`, is({ [align]: align })),
+          colSpan: span
+        },
+        [
+          (0, import_react.createElement)("span", { className: (0, import_classnames.default)(e`label`, labelClassName) }, label),
+          (0, import_react.createElement)("span", { className: (0, import_classnames.default)(e`content`, className) }, children)
+        ]
+      );
+  }
+};
+DescriptionsCell.displayName = "DescriptionsCell";
+var DescriptionsCell_default = (0, import_react.memo)(DescriptionsCell);

package/dist/Descriptions/DescriptionsContext.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+interface DescriptionsContextProps {
+    direction?: 'vertical' | 'horizontal';
+    border?: boolean;
+}
+export declare const DescriptionsContext: import("react").Context<DescriptionsContextProps>;
+export {};

package/dist/Descriptions/DescriptionsContext.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Descriptions/DescriptionsContext.ts
+var DescriptionsContext_exports = {};
+__export(DescriptionsContext_exports, {
+  DescriptionsContext: () => DescriptionsContext
+});
+module.exports = __toCommonJS(DescriptionsContext_exports);
+var import_react = require("react");
+var DescriptionsContext = (0, import_react.createContext)({
+  direction: "horizontal",
+  border: true
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DescriptionsContext
+});

package/dist/Descriptions/DescriptionsItem.d.ts

@@ -0,0 +1,6 @@
+import { DescriptionsItemProps } from './typings';
+declare const DescriptionsItem: {
+    (props: DescriptionsItemProps): any;
+    displayName: string;
+};
+export default DescriptionsItem;

package/dist/Descriptions/DescriptionsItem.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Descriptions/DescriptionsItem.tsx
+var DescriptionsItem_exports = {};
+__export(DescriptionsItem_exports, {
+  default: () => DescriptionsItem_default
+});
+module.exports = __toCommonJS(DescriptionsItem_exports);
+var DescriptionsItem = (props) => {
+  return null;
+};
+DescriptionsItem.displayName = "DescriptionsItem";
+var DescriptionsItem_default = DescriptionsItem;

package/dist/Descriptions/DescriptionsRow.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { DescriptionsItemProps } from './typings';
+interface Props {
+    row: React.ReactElement<DescriptionsItemProps>[];
+}
+declare const _default: React.MemoExoticComponent<{
+    ({ row }: Props): React.JSX.Element;
+    displayName: string;
+}>;
+export default _default;

package/dist/Descriptions/DescriptionsRow.js

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Descriptions/DescriptionsRow.tsx
+var DescriptionsRow_exports = {};
+__export(DescriptionsRow_exports, {
+  default: () => DescriptionsRow_default
+});
+module.exports = __toCommonJS(DescriptionsRow_exports);
+var import_react = __toESM(require("react"));
+var import_DescriptionsCell = __toESM(require("./DescriptionsCell"));
+var import_DescriptionsContext = require("./DescriptionsContext");
+var DescriptionsRow = ({ row }) => {
+  const { direction, border } = (0, import_react.useContext)(import_DescriptionsContext.DescriptionsContext);
+  return direction === "vertical" ? /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, /* @__PURE__ */ import_react.default.createElement("tr", null, row.map((cell, index) => /* @__PURE__ */ import_react.default.createElement(import_DescriptionsCell.default, { key: `tr1-${index}`, cell, tag: "th", type: "label" }))), /* @__PURE__ */ import_react.default.createElement("tr", null, row.map((cell, index) => /* @__PURE__ */ import_react.default.createElement(import_DescriptionsCell.default, { key: `tr2-${index}`, cell, tag: "td", type: "content" })))) : /* @__PURE__ */ import_react.default.createElement("tr", null, row.map(
+    (cell, index) => border ? /* @__PURE__ */ import_react.default.createElement(import_react.Fragment, { key: `tr1-${index}` }, /* @__PURE__ */ import_react.default.createElement(import_DescriptionsCell.default, { cell, tag: "th", type: "label" }), /* @__PURE__ */ import_react.default.createElement(import_DescriptionsCell.default, { cell, tag: "th", type: "content" })) : /* @__PURE__ */ import_react.default.createElement(import_DescriptionsCell.default, { key: `tr3-${index}`, cell, tag: "th", type: "both" })
+  ));
+};
+DescriptionsRow.displayName = "DescriptionsRow";
+var DescriptionsRow_default = (0, import_react.memo)(DescriptionsRow);

package/dist/Descriptions/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Descriptions } from './Descriptions';
+export { default as DescriptionsItem } from './DescriptionsItem';
+export type { DescriptionsItemProps, DescriptionsProps } from './typings';

package/dist/Descriptions/index.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Descriptions/index.ts
+var Descriptions_exports = {};
+__export(Descriptions_exports, {
+  Descriptions: () => import_Descriptions.default,
+  DescriptionsItem: () => import_DescriptionsItem.default
+});
+module.exports = __toCommonJS(Descriptions_exports);
+var import_Descriptions = __toESM(require("./Descriptions"));
+var import_DescriptionsItem = __toESM(require("./DescriptionsItem"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Descriptions,
+  DescriptionsItem
+});

package/dist/Descriptions/typings.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { BaseProps, NativeProps, TypeAttributes } from '../types/common';
+export interface DescriptionsProps extends BaseProps<React.ReactElement<DescriptionsItemProps> | React.ReactElement<DescriptionsItemProps>[]>, NativeProps<'--el-descriptions-table-border' | '--el-descriptions-item-bordered-label-background'> {
+    border?: boolean;
+    column?: number;
+    direction?: 'vertical' | 'horizontal';
+    size?: TypeAttributes.Size;
+    title?: string | React.ReactElement<any>;
+    extra?: string | React.ReactElement<any>;
+}
+export interface DescriptionsItemProps extends BaseProps, NativeProps {
+    label?: string | React.ReactElement<any>;
+    span?: number;
+    width?: number | string;
+    minWidth?: number | string;
+    align?: 'left' | 'center' | 'right';
+    labelAlign?: 'left' | 'center' | 'right';
+    labelClassName?: string;
+}

package/dist/Descriptions/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Descriptions/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Dialog/Dialog.d.ts

@@ -0,0 +1,16 @@
+import React, { RefObject } from 'react';
+import DialogBody from './DialogBody';
+import DialogFooter from './DialogFooter';
+import { DialogProps } from './typings';
+declare const Comp: (props: DialogProps & {
+    ref?: RefObject<HTMLDivElement> | React.ForwardedRef<HTMLDivElement>;
+}) => React.ReactElement;
+type InternalType = typeof Comp;
+interface CompInterface extends InternalType {
+    displayName?: string;
+    defaultProps?: Partial<DialogProps>;
+    body: typeof DialogBody;
+    footer: typeof DialogFooter;
+}
+declare const Dialog: CompInterface;
+export default Dialog;

package/dist/Dialog/Dialog.js

@@ -0,0 +1,212 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Dialog/Dialog.tsx
+var Dialog_exports = {};
+__export(Dialog_exports, {
+  default: () => Dialog_default
+});
+module.exports = __toCommonJS(Dialog_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_dom_lib = require("dom-lib");
+var import_react = __toESM(require("react"));
+var import_react_dom = require("react-dom");
+var import_Transition = require("../Transition");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var import_prefix = require("../hooks/prefix");
+var import_DialogBody = __toESM(require("./DialogBody"));
+var import_DialogContext = require("./DialogContext");
+var import_DialogFooter = __toESM(require("./DialogFooter"));
+var import_DialogHeader = __toESM(require("./DialogHeader"));
+var import_useDraggable = require("./useDraggable");
+function InternalElDialog(props, ref) {
+  const {
+    modal,
+    closeOnClickModal = true,
+    width = "50%",
+    overflow,
+    title,
+    showClose,
+    border,
+    children,
+    center,
+    alignCenter,
+    draggable,
+    fullscreen,
+    top,
+    close,
+    beforeClose,
+    lockScroll = true,
+    zIndex,
+    classPrefix = "dialog"
+  } = props;
+  const { b, m, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const [visible, setVisible, isControlled] = (0, import_hooks.useControlled)(props.visible, props.defaultVisible);
+  const haveTitle = (0, import_react.useRef)(false);
+  const haveFooter = (0, import_react.useRef)(false);
+  const wrapperRef = (0, import_react.useRef)();
+  const dialogRef = (0, import_react.useRef)();
+  const overlayRef = (0, import_react.useRef)();
+  const headerRef = (0, import_react.useRef)(null);
+  (0, import_useDraggable.useDraggable)(dialogRef, headerRef, draggable, overflow);
+  const getInstancesFromChildren = (0, import_react.useCallback)((_children) => {
+    const componentChildren = _children instanceof Array ? _children : [_children];
+    componentChildren.forEach((node) => {
+      let nodeType = node == null ? void 0 : node.type;
+      nodeType = (nodeType == null ? void 0 : nodeType.displayName) || nodeType;
+      if (nodeType === "ElDialogHeader") {
+        haveTitle.current = true;
+      } else if (nodeType === "ElDialogFooter") {
+        haveFooter.current = true;
+      } else if (nodeType === "Fragment") {
+        getInstancesFromChildren(node);
+      }
+    });
+  }, []);
+  const doClose = (0, import_react.useCallback)(() => {
+    if (beforeClose) {
+      beforeClose == null ? void 0 : beforeClose((value) => {
+        if (value) {
+          return;
+        }
+        setVisible(false);
+        close == null ? void 0 : close();
+      });
+    } else {
+      setVisible(false);
+      close == null ? void 0 : close();
+    }
+  }, [beforeClose, close, setVisible]);
+  (0, import_react.useEffect)(() => {
+    if (visible) {
+      let mousedown;
+      const shadowRef = wrapperRef == null ? void 0 : wrapperRef.current;
+      shadowRef == null ? void 0 : shadowRef.addEventListener("mousedown", (e) => mousedown = e);
+      shadowRef == null ? void 0 : shadowRef.addEventListener("mouseup", (mouseup) => {
+        var _a, _b;
+        const mouseUpTarget = mouseup == null ? void 0 : mouseup.target;
+        const mouseDownTarget = mousedown == null ? void 0 : mousedown.target;
+        const isTargetExists = !mouseUpTarget || !mouseDownTarget;
+        const isContainedByPopper = ((_a = dialogRef == null ? void 0 : dialogRef.current) == null ? void 0 : _a.contains(mouseUpTarget)) || ((_b = dialogRef == null ? void 0 : dialogRef.current) == null ? void 0 : _b.contains(mouseDownTarget));
+        if (isTargetExists || isContainedByPopper) {
+          return;
+        }
+        if (!closeOnClickModal) {
+          (0, import_dom_lib.addClass)(dialogRef.current, b("dialog-shake", false));
+          setTimeout(() => {
+            (0, import_dom_lib.removeClass)(dialogRef.current, b("dialog-shake", false));
+          }, 300);
+        } else if (modal === true) {
+          doClose();
+        }
+      });
+    }
+  }, [b, modal, beforeClose, doClose, ref, setVisible, visible, closeOnClickModal]);
+  (0, import_react.useEffect)(() => {
+    getInstancesFromChildren(children);
+  }, []);
+  (0, import_react.useImperativeHandle)(ref, () => wrapperRef.current);
+  return /* @__PURE__ */ import_react.default.createElement(import_DialogContext.DialogContext.Provider, { value: { backdrop: modal, setVisible, isControlled, doClose, center, overflow, haveTitle: haveTitle.current, haveFooter: haveFooter.current } }, (0, import_react_dom.createPortal)(
+    /* @__PURE__ */ import_react.default.createElement(
+      import_Transition.Transition,
+      {
+        visible,
+        transitionAppear: true,
+        unmountOnExit: props.unmountOnExit || !draggable,
+        beforeEnter: () => {
+          var _a;
+          (_a = props.beforeEnter) == null ? void 0 : _a.call(props);
+          (0, import_dom_lib.addClass)(overlayRef.current, b("anim-bounce-in", false));
+        },
+        onEnter: () => {
+          var _a, _b;
+          (_a = props.onOpen) == null ? void 0 : _a.call(props);
+          (_b = props.onEnter) == null ? void 0 : _b.call(props);
+          if (draggable && dialogRef.current) {
+          }
+          if (lockScroll) {
+            (0, import_dom_lib.addClass)(document.body, b("popup-parent--hidden", false));
+          }
+        },
+        afterEnter: () => {
+          var _a, _b;
+          (_a = props.afterEnter) == null ? void 0 : _a.call(props);
+          (_b = props.onOpened) == null ? void 0 : _b.call(props);
+          (0, import_dom_lib.removeClass)(overlayRef.current, b("anim-bounce-in", false));
+        },
+        beforeLeave: () => {
+          var _a;
+          (0, import_dom_lib.addClass)(overlayRef.current, b("anim-bounce-out", false));
+          (_a = props.beforeLeave) == null ? void 0 : _a.call(props);
+        },
+        onLeave: () => {
+          var _a, _b;
+          (_a = props.onClose) == null ? void 0 : _a.call(props);
+          (_b = props.onLeave) == null ? void 0 : _b.call(props);
+        },
+        afterLeave: () => {
+          var _a, _b;
+          (_a = props.afterLeave) == null ? void 0 : _a.call(props);
+          (_b = props.onClosed) == null ? void 0 : _b.call(props);
+          if (lockScroll) {
+            (0, import_dom_lib.removeClass)(document.body, b("popup-parent--hidden", false));
+          }
+          (0, import_dom_lib.removeClass)(overlayRef.current, b("anim-bounce-out", false));
+        },
+        duration: 300
+      },
+      /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b("overlay", false), props.className), style: { zIndex: zIndex || import_Util.PopupManager.nextZIndex() }, ref: wrapperRef }, /* @__PURE__ */ import_react.default.createElement("div", { ref: overlayRef, className: b(`overlay-${classPrefix}`, false), style: { display: alignCenter ? "flex" : "block" } }, /* @__PURE__ */ import_react.default.createElement(
+        "div",
+        {
+          className: (0, import_classnames.default)(b(), is({ draggable, "align-center": alignCenter, fullscreen }), { [m`center`]: center }),
+          style: {
+            ...props.style,
+            // @ts-ignore
+            [`--${import_prefix.globalKey}-dialog-width`]: fullscreen || classPrefix !== "dialog" ? "" : (0, import_Util.addUnit)(width),
+            [`--${import_prefix.globalKey}-dialog-margin-top`]: (0, import_Util.addUnit)(top)
+          },
+          ref: dialogRef
+        },
+        /* @__PURE__ */ import_react.default.createElement(import_DialogHeader.default, { ref: headerRef, classPrefix, showClose, border }, title),
+        children
+      )))
+    ),
+    document.body
+  ));
+}
+var Comp = (0, import_react.memo)((0, import_react.forwardRef)(InternalElDialog));
+var Dialog = Comp;
+Dialog.defaultProps = {
+  modal: true,
+  overflow: false
+};
+Dialog.body = import_DialogBody.default;
+Dialog.footer = import_DialogFooter.default;
+Dialog.displayName = "ElDialog";
+var Dialog_default = Dialog;

package/dist/Dialog/DialogBody.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { DialogBodyProps } from './typings';
+declare const DialogBody: React.ForwardRefExoticComponent<DialogBodyProps & React.RefAttributes<HTMLDivElement>>;
+export default DialogBody;

package/dist/Dialog/DialogBody.js

@@ -0,0 +1,63 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Dialog/DialogBody.tsx
+var DialogBody_exports = {};
+__export(DialogBody_exports, {
+  default: () => DialogBody_default
+});
+module.exports = __toCommonJS(DialogBody_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var DialogBody = (0, import_react.memo)(
+  (0, import_react.forwardRef)((props, ref) => {
+    const { classPrefix = "dialog" } = props;
+    const { e } = (0, import_hooks.useClassNames)(classPrefix);
+    const contentRef = (0, import_react.useRef)();
+    (0, import_react.useImperativeHandle)(ref, () => contentRef.current);
+    return /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        className: (0, import_classnames.default)(e`body`, props.className),
+        ref: contentRef,
+        style: {
+          ...props.style
+          // overflow: overflow ? 'hidden' : 'auto',
+          // [overflow ? 'height' : 'maxHeight']: document.body.clientHeight - 150 - 20 - (haveFooter && 30),
+        }
+      },
+      props.children
+    );
+  })
+);
+DialogBody.displayName = "ElDialogBody";
+DialogBody.defaultProps = {
+  padding: "0 20px"
+};
+var DialogBody_default = DialogBody;

package/dist/Dialog/DialogContext.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+interface DialogContentProps {
+    backdrop: boolean | 'static';
+    setVisible: (visible: boolean) => void;
+    doClose: () => void;
+    isControlled: boolean;
+    center: boolean;
+    overflow: boolean;
+    mounted?: boolean;
+    haveTitle: boolean;
+    haveFooter: boolean;
+}
+export declare const DialogContext: import("react").Context<DialogContentProps>;
+export {};