antd-mobile 5.0.0-rc.0 → 5.0.0-rc.4

package/cjs/components/modal/alert.d.ts

@@ -0,0 +1,7 @@
+import { ModalProps } from './index';
+import { ReactNode } from 'react';
+export declare type ModalAlertProps = Omit<ModalProps, 'visible' | 'closeOnAction' | 'actions'> & {
+    confirmText?: ReactNode;
+    onConfirm?: () => void | Promise<void>;
+};
+export declare function alert(p: ModalAlertProps): Promise<void>;

package/cjs/components/modal/alert.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.alert = alert;
+
+var _show = require("./show");
+
+var _withDefaultProps = require("../../utils/with-default-props");
+
+var _configProvider = require("../config-provider");
+
+function alert(p) {
+  var defaultProps = {
+    confirmText: (0, _configProvider.getDefaultConfig)().locale.Modal.ok
+  };
+  var props = (0, _withDefaultProps.mergeProps)(defaultProps, p);
+  return new Promise(function (resolve) {
+    (0, _show.show)(Object.assign(Object.assign({}, props), {
+      closeOnAction: true,
+      actions: [{
+        key: 'confirm',
+        text: props.confirmText,
+        primary: true
+      }],
+      onAction: props.onConfirm,
+      onClose: function onClose() {
+        resolve();
+      }
+    }));
+  });
+}

package/cjs/components/modal/confirm.d.ts

@@ -0,0 +1,9 @@
+import { ModalProps } from './index';
+import { ReactNode } from 'react';
+export declare type ModalConfirmProps = Omit<ModalProps, 'visible' | 'closeOnAction' | 'actions'> & {
+    confirmText?: ReactNode;
+    cancelText?: ReactNode;
+    onConfirm?: () => void | Promise<void>;
+    onCancel?: () => void | Promise<void>;
+};
+export declare function confirm(p: ModalConfirmProps): Promise<boolean>;

package/cjs/components/modal/confirm.js

@@ -0,0 +1,116 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.confirm = confirm;
+
+var _show = require("./show");
+
+var _withDefaultProps = require("../../utils/with-default-props");
+
+var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+var defaultProps = {
+  confirmText: '确认',
+  cancelText: '取消'
+};
+
+function confirm(p) {
+  var _this = this;
+
+  var props = (0, _withDefaultProps.mergeProps)(defaultProps, p);
+  return new Promise(function (resolve) {
+    (0, _show.show)(Object.assign(Object.assign({}, props), {
+      closeOnAction: true,
+      onClose: function onClose() {
+        var _a;
+
+        (_a = props.onClose) === null || _a === void 0 ? void 0 : _a.call(props);
+        resolve(false);
+      },
+      actions: [{
+        key: 'confirm',
+        text: props.confirmText,
+        primary: true,
+        onClick: function onClick() {
+          return __awaiter(_this, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+            var _a;
+
+            return regeneratorRuntime.wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    _context.next = 2;
+                    return (_a = props.onConfirm) === null || _a === void 0 ? void 0 : _a.call(props);
+
+                  case 2:
+                    resolve(true);
+
+                  case 3:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee);
+          }));
+        }
+      }, {
+        key: 'cancel',
+        text: props.cancelText,
+        onClick: function onClick() {
+          return __awaiter(_this, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
+            var _b;
+
+            return regeneratorRuntime.wrap(function _callee2$(_context2) {
+              while (1) {
+                switch (_context2.prev = _context2.next) {
+                  case 0:
+                    _context2.next = 2;
+                    return (_b = props.onCancel) === null || _b === void 0 ? void 0 : _b.call(props);
+
+                  case 2:
+                    resolve(false);
+
+                  case 3:
+                  case "end":
+                    return _context2.stop();
+                }
+              }
+            }, _callee2);
+          }));
+        }
+      }]
+    }));
+  });
+}

package/cjs/components/modal/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import './modal.less';
+import { show } from './show';
+import { alert } from './alert';
+import { confirm } from './confirm';
+export type { ModalProps } from './modal';
+export type { Action } from './modal-action-button';
+export type { ModalShowProps, ModalShowRef } from './show';
+export type { ModalAlertProps } from './alert';
+export type { ModalConfirmProps } from './confirm';
+declare const _default: import("react").FC<import("./modal").ModalProps> & {
+    show: typeof show;
+    alert: typeof alert;
+    confirm: typeof confirm;
+};
+export default _default;

package/cjs/components/modal/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+require("./modal.css");
+
+var _show = require("./show");
+
+var _alert = require("./alert");
+
+var _confirm = require("./confirm");
+
+var _attachPropertiesToComponent = require("../../utils/attach-properties-to-component");
+
+var _modal2 = require("./modal");
+
+var _default = (0, _attachPropertiesToComponent.attachPropertiesToComponent)(_modal2.Modal, {
+  show: _show.show,
+  alert: _alert.alert,
+  confirm: _confirm.confirm
+});
+
+exports["default"] = _default;

package/cjs/components/modal/modal-action-button.d.ts

@@ -0,0 +1,14 @@
+import { FC } from 'react';
+import { NativeProps } from '../../utils/native-props';
+export declare type Action = {
+    key: string | number;
+    text: string;
+    disabled?: boolean;
+    danger?: boolean;
+    primary?: boolean;
+    onClick?: () => void | Promise<void>;
+} & NativeProps;
+export declare const ModalActionButton: FC<{
+    action: Action;
+    onAction: () => void | Promise<void>;
+}>;

package/cjs/components/modal/modal-action-button.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ModalActionButton = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _button = _interopRequireDefault(require("../button"));
+
+var _nativeProps = require("../../utils/native-props");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+var ModalActionButton = function ModalActionButton(props) {
+  var action = props.action;
+
+  var _useState = (0, _react.useState)(false),
+      loading = _useState[0],
+      setLoading = _useState[1];
+
+  function handleClick() {
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+      var promise;
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              setLoading(true);
+              _context.prev = 1;
+              promise = props.onAction();
+              _context.next = 5;
+              return promise;
+
+            case 5:
+              setLoading(false);
+              _context.next = 12;
+              break;
+
+            case 8:
+              _context.prev = 8;
+              _context.t0 = _context["catch"](1);
+              setLoading(false);
+              throw _context.t0;
+
+            case 12:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, null, [[1, 8]]);
+    }));
+  }
+
+  return (0, _nativeProps.withNativeProps)(props.action, /*#__PURE__*/_react["default"].createElement(_button["default"], {
+    key: action.key,
+    onClick: handleClick,
+    className: (0, _classnames["default"])('adm-modal-button', {
+      'adm-modal-button-primary': props.action.primary
+    }),
+    fill: props.action.primary ? 'solid' : 'none',
+    size: props.action.primary ? 'large' : 'middle',
+    block: true,
+    color: action.danger ? 'danger' : 'primary',
+    loading: loading,
+    disabled: action.disabled
+  }, action.text));
+};
+
+exports.ModalActionButton = ModalActionButton;

package/cjs/components/modal/modal.css

@@ -0,0 +1,75 @@
+.adm-modal {
+  --z-index: var(--adm-modal-z-index, 1000);
+  position: fixed;
+  z-index: var(--z-index);
+}
+.adm-modal .adm-modal-mask {
+  z-index: 0;
+}
+.adm-modal-wrap {
+  position: fixed;
+  z-index: 1;
+  top: 50%;
+  left: 50%;
+  width: auto;
+  min-width: 280px;
+  max-width: 75vw;
+  transform: translate(-50%, -50%);
+}
+.adm-modal-main {
+  width: 100%;
+  font-size: 14px;
+  background-color: white;
+  border-radius: 8px;
+  overflow: hidden;
+}
+.adm-modal-main .adm-modal-body {
+  padding: 20px 12px 12px;
+}
+.adm-modal-main .adm-modal-body .adm-modal-close {
+  position: absolute;
+  right: 12px;
+  top: 12px;
+  color: var(--adm-color-weak);
+  padding: 2px;
+}
+.adm-modal-main .adm-modal-body-header-wrapper {
+  display: flex;
+  justify-content: center;
+}
+.adm-modal-main .adm-modal-body-title {
+  font-weight: bold;
+  font-size: 18px;
+  line-height: 25px;
+  text-align: center;
+}
+.adm-modal-main .adm-modal-body-content {
+  max-height: 70vh;
+  overflow-x: hidden;
+  overflow-y: auto;
+  font-size: 15px;
+  line-height: 1.4;
+  color: #333;
+}
+.adm-modal-main .adm-modal-footer {
+  user-select: none;
+  padding: 8px 12px 12px;
+}
+.adm-modal-main .adm-modal-footer .adm-modal-button {
+  font-size: 18px;
+  line-height: 25px;
+  border-right: solid 0.5px var(--adm-border-color);
+}
+.adm-modal-main .adm-modal-footer .adm-modal-button:last-child {
+  border-right: none;
+}
+.adm-modal-main .adm-modal-footer .adm-modal-button:not(.adm-modal-button-primary) {
+  padding-top: 0;
+  padding-bottom: 0;
+}
+.adm-modal-main .adm-modal-footer .adm-modal-button:not(.adm-modal-button-primary)::before {
+  display: none;
+}
+.adm-modal-main .adm-modal-footer .adm-modal-button:not(.adm-modal-button-primary):active {
+  opacity: 0.7;
+}

package/cjs/components/modal/modal.d.ts

@@ -0,0 +1,26 @@
+import React, { FC, ReactNode } from 'react';
+import { Action } from './modal-action-button';
+import { GetContainer } from '../../utils/render-to-container';
+import { PropagationEvent } from '../../utils/with-stop-propagation';
+import { NativeProps } from '../../utils/native-props';
+export declare type ModalProps = {
+    afterClose?: () => void;
+    image?: string;
+    header?: ReactNode;
+    title?: ReactNode;
+    content?: ReactNode;
+    actions?: Action[];
+    onAction?: (action: Action, index: number) => void | Promise<void>;
+    closeOnAction?: boolean;
+    onClose?: () => void;
+    closeOnMaskClick?: boolean;
+    visible?: boolean;
+    getContainer?: GetContainer;
+    bodyStyle?: React.CSSProperties;
+    bodyClassName?: string;
+    maskStyle?: React.CSSProperties;
+    maskClassName?: string;
+    stopPropagation?: PropagationEvent[];
+    showCloseButton?: boolean;
+} & NativeProps;
+export declare const Modal: FC<ModalProps>;

package/cjs/components/modal/modal.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Modal = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _withDefaultProps = require("../../utils/with-default-props");
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _ahooks = require("ahooks");
+
+var _mask = _interopRequireDefault(require("../mask"));
+
+var _modalActionButton = require("./modal-action-button");
+
+var _image = _interopRequireDefault(require("../image"));
+
+var _space = _interopRequireDefault(require("../space"));
+
+var _withStopPropagation = require("../../utils/with-stop-propagation");
+
+var _autoCenter = _interopRequireDefault(require("../auto-center"));
+
+var _web = require("@react-spring/web");
+
+var _nativeProps = require("../../utils/native-props");
+
+var _antdMobileIcons = require("antd-mobile-icons");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+var classPrefix = "adm-modal";
+var defaultProps = {
+  visible: false,
+  actions: [],
+  closeOnAction: false,
+  closeOnMaskClick: false,
+  stopPropagation: ['click'],
+  showCloseButton: false
+};
+
+var Modal = function Modal(p) {
+  var props = (0, _withDefaultProps.mergeProps)(defaultProps, p);
+  var unmountedRef = (0, _ahooks.useUnmountedRef)();
+  var style = (0, _web.useSpring)({
+    scale: props.visible ? 1 : 0.8,
+    opacity: props.visible ? 1 : 0,
+    config: {
+      mass: 1,
+      tension: 200,
+      friction: 30,
+      clamp: true
+    },
+    onStart: function onStart() {
+      setActive(true);
+    },
+    onRest: function onRest() {
+      var _a;
+
+      if (unmountedRef.current) return;
+      setActive(props.visible);
+
+      if (!props.visible) {
+        (_a = props.afterClose) === null || _a === void 0 ? void 0 : _a.call(props);
+      }
+    }
+  });
+
+  var _useState = (0, _react.useState)(props.visible),
+      active = _useState[0],
+      setActive = _useState[1];
+
+  return (0, _withStopPropagation.withStopPropagation)(props.stopPropagation, (0, _nativeProps.withNativeProps)(props, /*#__PURE__*/_react["default"].createElement("div", {
+    className: classPrefix,
+    style: {
+      display: active ? 'unset' : 'none'
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_mask["default"], {
+    visible: props.visible,
+    getContainer: props.getContainer,
+    onMaskClick: props.closeOnMaskClick ? props.onClose : undefined,
+    style: props.maskStyle,
+    className: (0, _classnames["default"])(classPrefix + "-mask", props.maskClassName)
+  }), /*#__PURE__*/_react["default"].createElement("div", {
+    className: classPrefix + "-wrap",
+    style: {
+      pointerEvents: props.visible ? 'unset' : 'none'
+    }
+  }, /*#__PURE__*/_react["default"].createElement(_web.animated.div, {
+    style: Object.assign({}, style),
+    onClick: function onClick(e) {
+      return e.stopPropagation();
+    },
+    className: classPrefix + "-main"
+  }, !!props.image && /*#__PURE__*/_react["default"].createElement(_image["default"], {
+    src: props.image,
+    alt: 'modal header image',
+    width: '100%'
+  }), /*#__PURE__*/_react["default"].createElement("div", {
+    style: props.bodyStyle,
+    className: (0, _classnames["default"])(classPrefix + "-body", props.bodyClassName)
+  }, props.showCloseButton && /*#__PURE__*/_react["default"].createElement("a", {
+    className: (0, _classnames["default"])(classPrefix + "-close", 'adm-plain-anchor'),
+    onClick: props.onClose
+  }, /*#__PURE__*/_react["default"].createElement(_antdMobileIcons.CloseOutline, null)), /*#__PURE__*/_react["default"].createElement(_space["default"], {
+    direction: 'vertical',
+    block: true
+  }, !!props.header && /*#__PURE__*/_react["default"].createElement("div", {
+    className: classPrefix + "-body-header-wrapper"
+  }, /*#__PURE__*/_react["default"].createElement("div", {
+    className: classPrefix + "-body-header"
+  }, props.header)), !!props.title && /*#__PURE__*/_react["default"].createElement("div", {
+    className: classPrefix + "-body-title"
+  }, props.title), !!props.content && /*#__PURE__*/_react["default"].createElement("div", {
+    className: classPrefix + "-body-content"
+  }, typeof props.content === 'string' ? /*#__PURE__*/_react["default"].createElement(_autoCenter["default"], null, props.content) : props.content))), /*#__PURE__*/_react["default"].createElement("div", {
+    className: classPrefix + "-footer"
+  }, /*#__PURE__*/_react["default"].createElement(_space["default"], {
+    direction: 'vertical',
+    block: true
+  }, props.actions.map(function (action, index) {
+    return /*#__PURE__*/_react["default"].createElement(_modalActionButton.ModalActionButton, {
+      key: action.key,
+      action: action,
+      onAction: function onAction() {
+        return __awaiter(void 0, void 0, void 0, /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+          var _a, _b, _c;
+
+          return regeneratorRuntime.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 2;
+                  return Promise.all([(_a = action.onClick) === null || _a === void 0 ? void 0 : _a.call(action), (_b = props.onAction) === null || _b === void 0 ? void 0 : _b.call(props, action, index)]);
+
+                case 2:
+                  if (props.closeOnAction) {
+                    (_c = props.onClose) === null || _c === void 0 ? void 0 : _c.call(props);
+                  }
+
+                case 3:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
+      }
+    });
+  }))))))));
+};
+
+exports.Modal = Modal;

package/cjs/components/modal/show.d.ts

@@ -0,0 +1,8 @@
+import { ModalProps } from './modal';
+export declare type ModalShowProps = Omit<ModalProps, 'visible'>;
+export declare type ModalShowRef = {
+    close: () => void;
+};
+export declare function show(props: ModalShowProps): {
+    close: () => void;
+};