@para-ui/core 2.2.4 → 2.2.5-beta

package/_verture/modalContext-25890584.js

@@ -0,0 +1,228 @@
+import { _ as _toConsumableArray } from './toConsumableArray-f8047a75.js';
+import { _ as _slicedToArray } from './slicedToArray-d7722f4b.js';
+import { r as regenerator } from './index-342379c6.js';
+import { a as __awaiter } from './tslib.es6-55ed4bd2.js';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import React__default from 'react';
+import { Modal } from '../Modal/index.js';
+import clsx from 'clsx';
+import { s as styleInject } from './style-inject.es-300983ab.js';
+
+var css_248z = ".function-modal-default [class*=makeStyles-md] {\n  width: 440px;\n  height: auto;\n  max-height: initial;\n}";
+styleInject(css_248z);
+
+var FDialog = function FDialog(props) {
+  var open = props.open,
+      title = props.title,
+      size = props.size,
+      context = props.context,
+      content = props.content,
+      onSubmit = props.onSubmit,
+      onClose = props.onClose,
+      getClose = props.getClose,
+      listIndex = props.listIndex,
+      ModalProps = props.ModalProps;
+  /**
+  * 外部想要单独关闭弹窗传出
+  */
+
+  React__default.useEffect(function () {
+    getClose && getClose(function () {
+      return onClose(listIndex);
+    });
+  }, [getClose, listIndex, onClose]);
+  return jsx(Modal, Object.assign({}, ModalProps, {
+    className: clsx('function-modal', !size && 'function-modal-default'),
+    open: open,
+    title: title,
+    onCancel: function onCancel() {
+      return onClose(listIndex);
+    },
+    onOk: function onOk() {
+      return onSubmit(listIndex);
+    },
+    size: size || 'md',
+    children: content || context,
+    okButtonProps: {
+      onClick: function onClick() {
+        return onSubmit(listIndex);
+      }
+    },
+    cancelButtonProps: {
+      onClick: function onClick() {
+        return onClose(listIndex);
+      }
+    }
+  }));
+};
+
+/**
+* 创建模态框的上下文
+*/
+
+var FunctionModalContext = /*#__PURE__*/React__default.createContext(Promise.reject);
+/**
+ * 弹出框组件
+ * @param context 主体内容
+ * @param title 弹出框标题
+ * @param hideClose 隐藏右上角关闭图标 boolean 默认 false
+ * @param checkFunction 检查方法，返回 boolean 值，true则关闭弹窗，false反之
+ **/
+
+var useModal = function useModal() {
+  return React__default.useContext(FunctionModalContext);
+};
+var setState;
+/**
+* 函数弹窗组件Provider
+*/
+
+var FunctionModalProvider = function FunctionModalProvider(_ref) {
+  var children = _ref.children;
+
+  // 模态框组 配置
+  var _React$useState = React__default.useState([]),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      confirmationState = _React$useState2[0],
+      setConfirmationState = _React$useState2[1]; // 传出设置模态框数组hook，用于关闭所有弹窗
+
+
+  setState = function setState() {
+    setConfirmationState([]);
+    awaitingPromiseRef.current = [];
+  }; // 存储每个模态框的 promise 方法
+
+
+  var awaitingPromiseRef = React__default.useRef([]);
+  /**
+  * 模态框初始化方法
+  * @param options 模态框配置
+  * @return 返回一个promise 用于外部判断弹窗状态
+  */
+
+  var openConfirmation = function openConfirmation(options) {
+    setConfirmationState(function (pre) {
+      pre.push(options);
+      return _toConsumableArray(pre);
+    });
+    return new Promise(function (resolve, reject) {
+      awaitingPromiseRef.current.push({
+        resolve: resolve,
+        reject: reject
+      });
+    });
+  };
+  /**
+  * 模态框关闭方法
+  * @param idx 模态框在模态框数组里的下标，用于拿到对应的配置 和 promise
+  * @description 关闭后会清空相关配置
+  */
+
+
+  var handleClose = function handleClose(idx) {
+    // 是否有禁用取消停止功能的配置
+    if (confirmationState[idx] && !confirmationState[idx].disCatchOnCancel && awaitingPromiseRef.current[idx]) {
+      awaitingPromiseRef.current[idx].resolve(false);
+    } else if (awaitingPromiseRef.current[idx]) {
+      awaitingPromiseRef.current[idx].resolve(true);
+    }
+
+    hideDialog(idx);
+    deleteOption(idx);
+  };
+  /**
+  * 模态框确定触发的方法
+  * @param idx 模态框在模态框数组里的下标，用于拿到对应的配置 和 promise
+  */
+
+
+  var handleSubmit = function handleSubmit(idx) {
+    return __awaiter(void 0, void 0, void 0, /*#__PURE__*/regenerator.mark(function _callee() {
+      var checkFuc, jude, pRef;
+      return regenerator.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              checkFuc = confirmationState && confirmationState[idx] && confirmationState[idx].checkFunction;
+              jude = true; // 判断是否有检查方法，如果有则先执行检查方法
+
+              if (!checkFuc) {
+                _context.next = 6;
+                break;
+              }
+
+              _context.next = 5;
+              return checkFuc();
+
+            case 5:
+              jude = _context.sent;
+
+            case 6:
+              if (jude) {
+                _context.next = 8;
+                break;
+              }
+
+              return _context.abrupt("return");
+
+            case 8:
+              hideDialog(idx);
+              pRef = awaitingPromiseRef.current[idx];
+              deleteOption(idx, pRef);
+
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+  };
+  /**
+  * 删除模态框配置，promise 执行成功操作
+  * @param pRef 模态框的promise
+  * @param idx 模态框在模态框组里的下标
+  */
+
+
+  var deleteOption = function deleteOption(idx, pRef) {
+    setTimeout(function () {
+      pRef && pRef.resolve(true);
+      setConfirmationState(function (pre) {
+        pre.splice(idx, 1);
+        awaitingPromiseRef.current.splice(idx, 1);
+        return _toConsumableArray(pre);
+      });
+    }, 200);
+  };
+  /**
+  * 隐藏模态框对应的dom
+  * @param idx 模态框在模态框数组里的下标
+  * @desc 解决异步导致的闪烁问题
+  */
+
+
+  var hideDialog = function hideDialog(idx) {
+    var dialogEl = document.querySelectorAll('.function-modal .MuiDialog-container')[idx];
+    if (dialogEl) dialogEl.style.opacity = '0';
+  };
+
+  return jsxs(Fragment, {
+    children: [jsx(FunctionModalContext.Provider, {
+      value: openConfirmation,
+      children: children
+    }), confirmationState && confirmationState.map(function (option, idx) {
+      return jsx(FDialog, Object.assign({
+        listIndex: idx,
+        open: Boolean(option),
+        onSubmit: handleSubmit,
+        onClose: handleClose
+      }, option), "modal-item-".concat(idx));
+    })]
+  });
+};
+var useClose = function useClose() {
+  return setState;
+};
+
+export { FunctionModalProvider as F, useClose as a, useModal as u };

package/_verture/modalContext-639f2787.js

@@ -0,0 +1,58 @@
+import { ReactElement } from 'react';
+import { ModalProps } from '../Modal/index.js';
+import { JsxElement } from 'typescript';
+import styleInject from './node_modules/style-inject/dist/style-inject.es.js';
+
+var css_248z = ".function-modal-default [class*=makeStyles-md] {\n  width: 440px;\n  height: auto;\n  max-height: initial;\n}";
+styleInject(css_248z);
+
+/**
+* 弹窗配置
+*/
+interface modalOptions extends ModalProps {
+    /**
+    * 非正常关闭仍然返回true
+    */
+    disCatchOnCancel?: boolean;
+    /**
+    * 模态框大小
+    */
+    size?: 'sm' | 'md' | 'lg' | 'auto' | 'fullScreen';
+    /**
+    * 模态框标题
+    */
+    title?: string;
+    context?: ReactElement | JsxElement;
+    /**
+    * 内容
+    */
+    content?: ReactElement | JsxElement;
+    /**
+    * 检查方法，根据返回值判断是否关闭模态框
+    */
+    checkFunction?: () => boolean | Promise<boolean>;
+    /**
+    * 获得关闭模态框方法
+    */
+    getClose?: (close: Function) => void;
+    /**
+    * 模态框其他配置
+    */
+    ModalProps?: ModalProps;
+}
+
+/**
+ * 弹出框组件
+ * @param context 主体内容
+ * @param title 弹出框标题
+ * @param hideClose 隐藏右上角关闭图标 boolean 默认 false
+ * @param checkFunction 检查方法，返回 boolean 值，true则关闭弹窗，false反之
+ **/
+declare const useModal: () => (options: modalOptions) => Promise<boolean>;
+/**
+* 函数弹窗组件Provider
+*/
+declare const FunctionModalProvider: ({ children }: any) => JSX.Element;
+declare const useClose: () => Function;
+
+export { FunctionModalProvider as F, useClose as a, useModal as u };

package/_verture/slicedToArray-d7722f4b.js

@@ -0,0 +1,62 @@
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+
+  return arr2;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+export { _slicedToArray as _, _arrayLikeToArray as a, _unsupportedIterableToArray as b };

package/_verture/style-inject.es-300983ab.js

@@ -0,0 +1,28 @@
+function styleInject(css, ref) {
+  if ( ref === void 0 ) ref = {};
+  var insertAt = ref.insertAt;
+
+  if (!css || typeof document === 'undefined') { return; }
+
+  var head = document.head || document.getElementsByTagName('head')[0];
+  var style = document.createElement('style');
+  style.type = 'text/css';
+
+  if (insertAt === 'top') {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
+}
+
+export { styleInject as s };

package/_verture/toConsumableArray-f8047a75.js

@@ -0,0 +1,19 @@
+import { a as _arrayLikeToArray, b as _unsupportedIterableToArray } from './slicedToArray-d7722f4b.js';
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+
+export { _toConsumableArray as _ };

package/_verture/tslib.es6-55ed4bd2.js

@@ -0,0 +1,38 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(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());
+    });
+}
+
+export { __rest as _, __awaiter as a };

package/_verture/typeof-498dd2b1.js

@@ -0,0 +1,11 @@
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+export { _typeof as _ };

package/_verture/useFormatMessage-ac9d6acf.js

@@ -0,0 +1,20 @@
+import React__default from 'react';
+import GlobalContext from '@para-ui/core/GlobalContext';
+
+/**
+* @author linhd
+* @date 2022/3/15 4:03 PM
+* @description 国际化钩子
+*/
+
+var useFormatMessage = function useFormatMessage(comName, defI18nData) {
+  var _React$useContext = React__default.useContext(GlobalContext),
+      intlFormat = _React$useContext.intlFormat;
+
+  defI18nData.zh_CN = defI18nData.zh;
+  defI18nData.en_US = defI18nData.en;
+  var intl = intlFormat && intlFormat(comName, defI18nData);
+  return intl;
+};
+
+export { useFormatMessage as u };

package/_verture/useGlobalProps-af9a2af6.js

@@ -0,0 +1,12 @@
+import React__default from 'react';
+import GlobalContext from '@para-ui/core/GlobalContext';
+
+function useGlobalProps(comProps, comName) {
+  var _React$useContext = React__default.useContext(GlobalContext),
+      componentsProps = _React$useContext.componentsProps;
+
+  var globalProps = componentsProps && componentsProps[comName];
+  return Object.assign(Object.assign({}, globalProps), comProps);
+}
+
+export { useGlobalProps as u };