@para-ui/core 4.0.53 → 4.0.54

package/_verture/useState-f2419d68.js

@@ -0,0 +1,353 @@
+import React__default from 'react';
+import { r as reactIs } from './index-1856bbeb.js';
+import { t as toPropertyKey } from './defineProperty-6f62bb2a.js';
+import { _ as _typeof } from './typeof-adeedc13.js';
+import { c as _arrayWithHoles, b as _unsupportedIterableToArray, d as _nonIterableRest } from './slicedToArray-61604a6c.js';
+import { a as _iterableToArray } from './toConsumableArray-599cd94a.js';
+import { _ as _typeof$1 } from './typeof-6ec38efd.js';
+
+function toArray(children) {
+  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var ret = [];
+  React__default.Children.forEach(children, function (child) {
+    if ((child === undefined || child === null) && !option.keepEmpty) {
+      return;
+    }
+    if (Array.isArray(child)) {
+      ret = ret.concat(toArray(child));
+    } else if (reactIs.exports.isFragment(child) && child.props) {
+      ret = ret.concat(toArray(child.props.children, option));
+    } else {
+      ret.push(child);
+    }
+  });
+  return ret;
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+    return !!t;
+  })();
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived),
+      result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn(this, result);
+  };
+}
+
+function _toArray(arr) {
+  return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest();
+}
+
+var interopRequireDefault = {exports: {}};
+
+(function (module) {
+	function _interopRequireDefault(obj) {
+	  return obj && obj.__esModule ? obj : {
+	    "default": obj
+	  };
+	}
+	module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (interopRequireDefault));
+
+var slicedToArray = {exports: {}};
+
+var arrayWithHoles = {exports: {}};
+
+(function (module) {
+	function _arrayWithHoles(arr) {
+	  if (Array.isArray(arr)) return arr;
+	}
+	module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (arrayWithHoles));
+
+var iterableToArrayLimit = {exports: {}};
+
+(function (module) {
+	function _iterableToArrayLimit(r, l) {
+	  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+	  if (null != t) {
+	    var e,
+	      n,
+	      i,
+	      u,
+	      a = [],
+	      f = !0,
+	      o = !1;
+	    try {
+	      if (i = (t = t.call(r)).next, 0 === l) {
+	        if (Object(t) !== t) return;
+	        f = !1;
+	      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+	    } catch (r) {
+	      o = !0, n = r;
+	    } finally {
+	      try {
+	        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+	      } finally {
+	        if (o) throw n;
+	      }
+	    }
+	    return a;
+	  }
+	}
+	module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (iterableToArrayLimit));
+
+var unsupportedIterableToArray = {exports: {}};
+
+var arrayLikeToArray = {exports: {}};
+
+(function (module) {
+	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;
+	}
+	module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (arrayLikeToArray));
+
+(function (module) {
+	var arrayLikeToArray$1 = arrayLikeToArray.exports;
+	function _unsupportedIterableToArray(o, minLen) {
+	  if (!o) return;
+	  if (typeof o === "string") return arrayLikeToArray$1(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$1(o, minLen);
+	}
+	module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (unsupportedIterableToArray));
+
+var nonIterableRest = {exports: {}};
+
+(function (module) {
+	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.");
+	}
+	module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (nonIterableRest));
+
+(function (module) {
+	var arrayWithHoles$1 = arrayWithHoles.exports;
+	var iterableToArrayLimit$1 = iterableToArrayLimit.exports;
+	var unsupportedIterableToArray$1 = unsupportedIterableToArray.exports;
+	var nonIterableRest$1 = nonIterableRest.exports;
+	function _slicedToArray(arr, i) {
+	  return arrayWithHoles$1(arr) || iterableToArrayLimit$1(arr, i) || unsupportedIterableToArray$1(arr, i) || nonIterableRest$1();
+	}
+	module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (slicedToArray));
+
+var canUseDom = {};
+
+var hasRequiredCanUseDom;
+
+function requireCanUseDom () {
+	if (hasRequiredCanUseDom) return canUseDom;
+	hasRequiredCanUseDom = 1;
+
+	Object.defineProperty(canUseDom, "__esModule", {
+	  value: true
+	});
+	canUseDom.default = canUseDom$1;
+	function canUseDom$1() {
+	  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+	}
+	return canUseDom;
+}
+
+var interopRequireWildcard = {exports: {}};
+
+(function (module) {
+	var _typeof = _typeof$1.exports["default"];
+	function _getRequireWildcardCache(e) {
+	  if ("function" != typeof WeakMap) return null;
+	  var r = new WeakMap(),
+	    t = new WeakMap();
+	  return (_getRequireWildcardCache = function _getRequireWildcardCache(e) {
+	    return e ? t : r;
+	  })(e);
+	}
+	function _interopRequireWildcard(e, r) {
+	  if (!r && e && e.__esModule) return e;
+	  if (null === e || "object" != _typeof(e) && "function" != typeof e) return {
+	    "default": e
+	  };
+	  var t = _getRequireWildcardCache(r);
+	  if (t && t.has(e)) return t.get(e);
+	  var n = {
+	      __proto__: null
+	    },
+	    a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+	  for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) {
+	    var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+	    i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+	  }
+	  return n["default"] = e, t && t.set(e, n), n;
+	}
+	module.exports = _interopRequireWildcard, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} (interopRequireWildcard));
+
+var useLayoutEffect$1 = {};
+
+var default_1;
+
+var _interopRequireDefault$1 = interopRequireDefault.exports.default;
+var _interopRequireWildcard$1 = interopRequireWildcard.exports.default;
+Object.defineProperty(useLayoutEffect$1, "__esModule", {
+  value: true
+});
+useLayoutEffect$1.useLayoutUpdateEffect = default_1 = useLayoutEffect$1.default = void 0;
+var React$1 = _interopRequireWildcard$1(React__default);
+var _canUseDom = _interopRequireDefault$1(requireCanUseDom());
+/**
+ * Wrap `React.useLayoutEffect` which will not throw warning message in test env
+ */
+var useInternalLayoutEffect = process.env.NODE_ENV !== 'test' && (0, _canUseDom.default)() ? React$1.useLayoutEffect : React$1.useEffect;
+var useLayoutEffect = function useLayoutEffect(callback, deps) {
+  var firstMountRef = React$1.useRef(true);
+  useInternalLayoutEffect(function () {
+    return callback(firstMountRef.current);
+  }, deps);
+
+  // We tell react that first mount has passed
+  useInternalLayoutEffect(function () {
+    firstMountRef.current = false;
+    return function () {
+      firstMountRef.current = true;
+    };
+  }, []);
+};
+useLayoutEffect$1.useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) {
+  useLayoutEffect(function (firstMount) {
+    if (!firstMount) {
+      return callback();
+    }
+  }, deps);
+};
+default_1 = useLayoutEffect$1.default = useLayoutEffect;
+
+var useState = {};
+
+var _interopRequireWildcard = interopRequireWildcard.exports.default;
+var _interopRequireDefault = interopRequireDefault.exports.default;
+Object.defineProperty(useState, "__esModule", {
+  value: true
+});
+var _default = useState.default = useSafeState;
+var _slicedToArray2 = _interopRequireDefault(slicedToArray.exports);
+var React = _interopRequireWildcard(React__default);
+/**
+ * Same as React.useState but `setState` accept `ignoreDestroy` param to not to setState after destroyed.
+ * We do not make this auto is to avoid real memory leak.
+ * Developer should confirm it's safe to ignore themselves.
+ */
+function useSafeState(defaultValue) {
+  var destroyRef = React.useRef(false);
+  var _React$useState = React.useState(defaultValue),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    value = _React$useState2[0],
+    setValue = _React$useState2[1];
+  React.useEffect(function () {
+    destroyRef.current = false;
+    return function () {
+      destroyRef.current = true;
+    };
+  }, []);
+  function safeSetState(updater, ignoreDestroy) {
+    if (ignoreDestroy && destroyRef.current) {
+      return;
+    }
+    setValue(updater);
+  }
+  return [value, safeSetState];
+}
+
+export { _inherits as _, _createSuper as a, _classCallCheck as b, _createClass as c, _toArray as d, interopRequireWildcard as e, useLayoutEffect$1 as f, _isNativeReflectConstruct as g, _setPrototypeOf as h, interopRequireDefault as i, _getPrototypeOf as j, _assertThisInitialized as k, default_1 as l, _default as m, requireCanUseDom as r, slicedToArray as s, toArray as t, useState as u };

package/index.d.ts

@@ -64,6 +64,8 @@ export { default as DynamicMultiBox } from './DynamicMultiBox';
 export * from './DynamicMultiBox';
 export { default as Empty } from './Empty';
 export * from './Empty';
+export { default as FieldForm } from './FieldForm';
+export * from './FieldForm';
 export { default as Form } from './Form';
 export * from './Form';
 export { default as FormItem } from './FormItem';

package/index.js

@@ -10,7 +10,7 @@ export { Button } from './Button/index.js';
 export { ButtonGroup } from './ButtonGroup/index.js';
 export { Card } from './Card/index.js';
 export { Carousel } from './Carousel/index.js';
-export { C as Cascader } from './_verture/index-063009f8.js';
+export { C as Cascader } from './_verture/index-0a300edb.js';
 export { Checkbox } from './Checkbox/index.js';
 export { CheckboxGroup } from './CheckboxGroup/index.js';
 export { default as CodeEditor, CompletionItemKind } from './CodeEditor/index.js';
@@ -31,9 +31,10 @@ export { Drawer } from './Drawer/index.js';
 export { D as Dropdown } from './_verture/index-bde7aabe.js';
 export { default as DynamicMultiBox } from './DynamicMultiBox/index.js';
 export { default as Empty } from './Empty/index.js';
+export { default as FieldForm } from './FieldForm/index.js';
 export { default as Form } from './Form/index.js';
-export { F as FormItem } from './_verture/index-f30ae73e.js';
-export { u as FunctionModal, F as FunctionModalProvider, a as useClose } from './_verture/modalContext-8a48c400.js';
+export { F as FormItem } from './_verture/index-43c653bb.js';
+export { u as FunctionModal, F as FunctionModalProvider, a as useClose } from './_verture/modalContext-6ac2e323.js';
 export { G as GlobalContext, c as changeConfirmLocale, g as getConfirmLocale } from './_verture/index-ca413216.js';
 export { default as Help } from './Help/index.js';
 export { default as HelperText } from './HelperText/index.js';
@@ -87,7 +88,7 @@ export { Title } from './Title/index.js';
 export { ToggleButton, ToggleButtonGroup } from './ToggleButton/index.js';
 export { Tooltip } from './Tooltip/index.js';
 export { SSortablejs, Transfer } from './Transfer/index.js';
-export { T as Tree } from './_verture/index-d728b0ce.js';
+export { T as Tree } from './_verture/index-320d67c4.js';
 export { default as Upload } from './Upload/index.js';
 export { default as Utils, getDateYYYYMMddHHMM, isObject, pixelReplacement } from './Utils/index.js';
 export { default as locale } from './locale/index.js';
@@ -114,12 +115,15 @@ import '@para-ui/icons/LoadingF';
 import 'react-slick';
 import '@para-ui/icons/RightCircleF';
 import '@para-ui/icons/LeftCircleF';
-import './_verture/Portal-42560ff0.js';
-import './_verture/slicedToArray-75fa4188.js';
-import './_verture/defineProperty-f0e15205.js';
-import './_verture/toConsumableArray-c7a8028f.js';
-import 'rc-motion';
+import './_verture/index-1856bbeb.js';
+import './_verture/defineProperty-6f62bb2a.js';
+import './_verture/typeof-adeedc13.js';
+import './_verture/toConsumableArray-599cd94a.js';
+import './_verture/slicedToArray-61604a6c.js';
+import './_verture/Portal-502bb85e.js';
+import './_verture/useState-f2419d68.js';
 import './_verture/typeof-6ec38efd.js';
+import 'rc-motion';
 import 'rc-tree/lib/utils/conductUtil';
 import '@para-ui/icons/Right';
 import '@para-ui/icons/CloseCircleF';
@@ -157,6 +161,9 @@ import '@para-ui/icons/Panel';
 import '@para-ui/icons/Drag';
 import './_verture/index-0f5ee6f7.js';
 import './_verture/sortable.esm-76fe46a4.js';
+import './_verture/isEqual-30b6f859.js';
+import '@para-ui/icons/Loading';
+import '@para-ui/icons/CheckCircleF';
 import '@para-ui/icons/LinkGroup';
 import '@para-ui/icons/UploadFile';
 import '@para-ui/icons/Help';
@@ -172,7 +179,6 @@ import 'rc-input-number';
 import '@para-ui/icons/Up';
 import '@para-ui/icons/IndentRightFill';
 import '@para-ui/icons/IndentLeftFill';
-import '@para-ui/icons/CheckCircleF';
 import 'rc-notification';
 import 'rc-pagination';
 import '@para-ui/icons/DoubleLeft';
@@ -182,7 +188,6 @@ import '@para-ui/icons/Plus';
 import '@para-ui/icons/EditOutline';
 import '@para-ui/icons/Message';
 import '@para-ui/icons/Set';
-import '@para-ui/icons/Loading';
 import './_verture/index-8ac46bd9.js';
 import 'rc-slider';
 import './_verture/tinycolor-ece3542d.js';

package/locale/en-US.d.ts

@@ -187,6 +187,52 @@ declare const _default: {
         click: string;
         refresh: string;
     };
+    FieldForm: {
+        default: string;
+        required: string;
+        enum: string;
+        whitespace: string;
+        date: string;
+        types: {
+            string: string;
+            method: string;
+            array: string;
+            object: string;
+            number: string;
+            date: string;
+            boolean: string;
+            integer: string;
+            float: string;
+            regexp: string;
+            email: string;
+            url: string;
+            hex: string;
+        };
+        string: string;
+        number: string;
+        array: string;
+        pattern: {
+            mismatch: string;
+        };
+        format: string;
+        parse: string;
+        invalid: string;
+        method: string;
+        object: string;
+        boolean: string;
+        integer: string;
+        float: string;
+        regexp: string;
+        email: string;
+        url: string;
+        hex: string;
+        len: string;
+        min: string;
+        max: string;
+        range: string;
+        mismatch: string;
+        colon: string;
+    };
     FormItem: {
         choseFile: string;
         unEmpty: string;

package/locale/index.d.ts

@@ -188,6 +188,52 @@ declare const _default: {
             click: string;
             refresh: string;
         };
+        FieldForm: {
+            default: string;
+            required: string;
+            enum: string;
+            whitespace: string;
+            date: string;
+            types: {
+                string: string;
+                method: string;
+                array: string;
+                object: string;
+                number: string;
+                date: string;
+                boolean: string;
+                integer: string;
+                float: string;
+                regexp: string;
+                email: string;
+                url: string;
+                hex: string;
+            };
+            string: string;
+            number: string;
+            array: string;
+            pattern: {
+                mismatch: string;
+            };
+            format: string;
+            parse: string;
+            invalid: string;
+            method: string;
+            object: string;
+            boolean: string;
+            integer: string;
+            float: string;
+            regexp: string;
+            email: string;
+            url: string;
+            hex: string;
+            len: string;
+            min: string;
+            max: string;
+            range: string;
+            mismatch: string;
+            colon: string;
+        };
         FormItem: {
             choseFile: string;
             unEmpty: string;
@@ -502,6 +548,52 @@ declare const _default: {
             click: string;
             refresh: string;
         };
+        FieldForm: {
+            default: string;
+            required: string;
+            enum: string;
+            whitespace: string;
+            date: string;
+            types: {
+                string: string;
+                method: string;
+                array: string;
+                object: string;
+                number: string;
+                date: string;
+                boolean: string;
+                integer: string;
+                float: string;
+                regexp: string;
+                email: string;
+                url: string;
+                hex: string;
+            };
+            string: string;
+            number: string;
+            array: string;
+            pattern: {
+                mismatch: string;
+            };
+            format: string;
+            parse: string;
+            invalid: string;
+            method: string;
+            object: string;
+            boolean: string;
+            integer: string;
+            float: string;
+            regexp: string;
+            email: string;
+            url: string;
+            hex: string;
+            len: string;
+            min: string;
+            max: string;
+            range: string;
+            mismatch: string;
+            colon: string;
+        };
         FormItem: {
             choseFile: string;
             unEmpty: string;