amis-ui 2.6.0 → 2.7.0

package/lib/node_modules/rc-resize-observer/es/SingleObserver/index.js

@@ -0,0 +1,132 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var objectSpread2 = require('../../../@babel/runtime/helpers/esm/objectSpread2.js');
+var ref = require('../../../rc-util/es/ref.js');
+var React = require('react');
+var findDOMNode = require('../../../rc-util/es/Dom/findDOMNode.js');
+var observerUtil = require('../utils/observerUtil.js');
+var DomWrapper = require('./DomWrapper.js');
+var Collection = require('../Collection.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function SingleObserver(props) {
+  var children = props.children,
+      disabled = props.disabled;
+  var elementRef = React__namespace.useRef(null);
+  var wrapperRef = React__namespace.useRef(null);
+  var onCollectionResize = React__namespace.useContext(Collection.CollectionContext); // =========================== Children ===========================
+
+  var isRenderProps = typeof children === 'function';
+  var mergedChildren = isRenderProps ? children(elementRef) : children; // ============================= Size =============================
+
+  var sizeRef = React__namespace.useRef({
+    width: -1,
+    height: -1,
+    offsetWidth: -1,
+    offsetHeight: -1
+  }); // ============================= Ref ==============================
+
+  var canRef = !isRenderProps && /*#__PURE__*/React__namespace.isValidElement(mergedChildren) && ref.supportRef(mergedChildren);
+  var originRef = canRef ? mergedChildren.ref : null;
+  var mergedRef = React__namespace.useMemo(function () {
+    return ref.composeRef(originRef, elementRef);
+  }, [originRef, elementRef]); // =========================== Observe ============================
+
+  var propsRef = React__namespace.useRef(props);
+  propsRef.current = props; // Handler
+
+  var onInternalResize = React__namespace.useCallback(function (target) {
+    var _propsRef$current = propsRef.current,
+        onResize = _propsRef$current.onResize,
+        data = _propsRef$current.data;
+
+    var _target$getBoundingCl = target.getBoundingClientRect(),
+        width = _target$getBoundingCl.width,
+        height = _target$getBoundingCl.height;
+
+    var offsetWidth = target.offsetWidth,
+        offsetHeight = target.offsetHeight;
+    /**
+     * Resize observer trigger when content size changed.
+     * In most case we just care about element size,
+     * let's use `boundary` instead of `contentRect` here to avoid shaking.
+     */
+
+    var fixedWidth = Math.floor(width);
+    var fixedHeight = Math.floor(height);
+
+    if (sizeRef.current.width !== fixedWidth || sizeRef.current.height !== fixedHeight || sizeRef.current.offsetWidth !== offsetWidth || sizeRef.current.offsetHeight !== offsetHeight) {
+      var size = {
+        width: fixedWidth,
+        height: fixedHeight,
+        offsetWidth: offsetWidth,
+        offsetHeight: offsetHeight
+      };
+      sizeRef.current = size; // IE is strange, right?
+
+      var mergedOffsetWidth = offsetWidth === Math.round(width) ? width : offsetWidth;
+      var mergedOffsetHeight = offsetHeight === Math.round(height) ? height : offsetHeight;
+
+      var sizeInfo = objectSpread2["default"](objectSpread2["default"]({}, size), {}, {
+        offsetWidth: mergedOffsetWidth,
+        offsetHeight: mergedOffsetHeight
+      }); // Let collection know what happened
+
+
+      onCollectionResize === null || onCollectionResize === void 0 ? void 0 : onCollectionResize(sizeInfo, target, data);
+
+      if (onResize) {
+        // defer the callback but not defer to next frame
+        Promise.resolve().then(function () {
+          onResize(sizeInfo, target);
+        });
+      }
+    }
+  }, []); // Dynamic observe
+
+  React__namespace.useEffect(function () {
+    var currentElement = findDOMNode["default"](elementRef.current) || findDOMNode["default"](wrapperRef.current);
+
+    if (currentElement && !disabled) {
+      observerUtil.observe(currentElement, onInternalResize);
+    }
+
+    return function () {
+      return observerUtil.unobserve(currentElement, onInternalResize);
+    };
+  }, [elementRef.current, disabled]); // ============================ Render ============================
+
+  return /*#__PURE__*/React__namespace.createElement(DomWrapper["default"], {
+    ref: wrapperRef
+  }, canRef ? /*#__PURE__*/React__namespace.cloneElement(mergedChildren, {
+    ref: mergedRef
+  }) : mergedChildren);
+}
+
+exports["default"] = SingleObserver;

package/lib/node_modules/rc-resize-observer/es/index.js

@@ -0,0 +1,61 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _extends = require('../../@babel/runtime/helpers/esm/extends.js');
+var React = require('react');
+var toArray = require('../../rc-util/es/Children/toArray.js');
+var warning = require('../../rc-util/es/warning.js');
+var index = require('./SingleObserver/index.js');
+var Collection = require('./Collection.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var INTERNAL_PREFIX_KEY = 'rc-observer-key';
+
+function ResizeObserver(props) {
+  var children = props.children;
+  var childNodes = typeof children === 'function' ? [children] : toArray["default"](children);
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (childNodes.length > 1) {
+      warning.warning(false, 'Find more than one child node with `children` in ResizeObserver. Please use ResizeObserver.Collection instead.');
+    } else if (childNodes.length === 0) {
+      warning.warning(false, '`children` of ResizeObserver is empty. Nothing is in observe.');
+    }
+  }
+
+  return childNodes.map(function (child, index$1) {
+    var key = (child === null || child === void 0 ? void 0 : child.key) || "".concat(INTERNAL_PREFIX_KEY, "-").concat(index$1);
+    return /*#__PURE__*/React__namespace.createElement(index["default"], _extends["default"]({}, props, {
+      key: key
+    }), child);
+  });
+}
+
+ResizeObserver.Collection = Collection.Collection;
+
+exports["default"] = ResizeObserver;

package/lib/node_modules/rc-resize-observer/es/utils/observerUtil.js

@@ -0,0 +1,53 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ResizeObserver_es = require('../../../resize-observer-polyfill/dist/ResizeObserver.es.js');
+
+var elementListeners = new Map();
+
+function onResize(entities) {
+  entities.forEach(function (entity) {
+    var _elementListeners$get;
+
+    var target = entity.target;
+    (_elementListeners$get = elementListeners.get(target)) === null || _elementListeners$get === void 0 ? void 0 : _elementListeners$get.forEach(function (listener) {
+      return listener(target);
+    });
+  });
+} // Note: ResizeObserver polyfill not support option to measure border-box resize
+
+
+var resizeObserver = new ResizeObserver_es["default"](onResize); // Dev env only
+
+process.env.NODE_ENV !== 'production' ? elementListeners : null; // eslint-disable-line
+
+process.env.NODE_ENV !== 'production' ? onResize : null; // eslint-disable-line
+// ============================== Observe ==============================
+
+function observe(element, callback) {
+  if (!elementListeners.has(element)) {
+    elementListeners.set(element, new Set());
+    resizeObserver.observe(element);
+  }
+
+  elementListeners.get(element).add(callback);
+}
+function unobserve(element, callback) {
+  if (elementListeners.has(element)) {
+    elementListeners.get(element).delete(callback);
+
+    if (!elementListeners.get(element).size) {
+      resizeObserver.unobserve(element);
+      elementListeners.delete(element);
+    }
+  }
+}
+
+exports.observe = observe;
+exports.unobserve = unobserve;

package/lib/node_modules/rc-util/es/Children/toArray.js

@@ -0,0 +1,36 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+require('../../node_modules/react-is/index.js');
+var index = require('../../../../_virtual/index.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+function toArray(children) {
+  var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var ret = [];
+  React__default["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 (index.reactIs.exports.isFragment(child) && child.props) {
+      ret = ret.concat(toArray(child.props.children, option));
+    } else {
+      ret.push(child);
+    }
+  });
+  return ret;
+}
+
+exports["default"] = toArray;

package/lib/node_modules/rc-util/es/Dom/canUseDom.js

@@ -0,0 +1,14 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function canUseDom() {
+  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+}
+
+exports["default"] = canUseDom;

package/lib/node_modules/rc-util/es/Dom/findDOMNode.js

@@ -0,0 +1,31 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var ReactDOM = require('react-dom');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
+
+/**
+ * Return if a node is a DOM node. Else will return by `findDOMNode`
+ */
+function findDOMNode(node) {
+  if (node instanceof HTMLElement) {
+    return node;
+  }
+  if (node instanceof React__default["default"].Component) {
+    return ReactDOM__default["default"].findDOMNode(node);
+  }
+  return null;
+}
+
+exports["default"] = findDOMNode;

package/lib/node_modules/rc-util/es/hooks/useLayoutEffect.js

@@ -0,0 +1,38 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var canUseDom = require('../Dom/canUseDom.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+/**
+ * Wrap `React.useLayoutEffect` which will not throw warning message in test env
+ */
+var useLayoutEffect = process.env.NODE_ENV !== 'test' && canUseDom["default"]() ? React__namespace.useLayoutEffect : React__namespace.useEffect;
+
+exports["default"] = useLayoutEffect;

package/lib/node_modules/rc-util/es/hooks/useState.js

@@ -0,0 +1,59 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var slicedToArray = require('../../../@babel/runtime/helpers/esm/slicedToArray.js');
+var React = require('react');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+/**
+ * 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__namespace.useRef(false);
+  var _React$useState = React__namespace.useState(defaultValue),
+    _React$useState2 = slicedToArray["default"](_React$useState, 2),
+    value = _React$useState2[0],
+    setValue = _React$useState2[1];
+  React__namespace.useEffect(function () {
+    destroyRef.current = false;
+    return function () {
+      destroyRef.current = true;
+    };
+  }, []);
+  function safeSetState(updater, ignoreDestroy) {
+    if (ignoreDestroy && destroyRef.current) {
+      return;
+    }
+    setValue(updater);
+  }
+  return [value, safeSetState];
+}
+
+exports["default"] = useSafeState;

package/lib/node_modules/rc-util/es/raf.js

@@ -0,0 +1,59 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var raf = function raf(callback) {
+  return +setTimeout(callback, 16);
+};
+var caf = function caf(num) {
+  return clearTimeout(num);
+};
+if (typeof window !== 'undefined' && 'requestAnimationFrame' in window) {
+  raf = function raf(callback) {
+    return window.requestAnimationFrame(callback);
+  };
+  caf = function caf(handle) {
+    return window.cancelAnimationFrame(handle);
+  };
+}
+var rafUUID = 0;
+var rafIds = new Map();
+function cleanup(id) {
+  rafIds.delete(id);
+}
+var wrapperRaf = function wrapperRaf(callback) {
+  var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  rafUUID += 1;
+  var id = rafUUID;
+  function callRef(leftTimes) {
+    if (leftTimes === 0) {
+      // Clean up
+      cleanup(id);
+
+      // Trigger
+      callback();
+    } else {
+      // Next raf
+      var realId = raf(function () {
+        callRef(leftTimes - 1);
+      });
+
+      // Bind real raf id
+      rafIds.set(id, realId);
+    }
+  }
+  callRef(times);
+  return id;
+};
+wrapperRaf.cancel = function (id) {
+  var realId = rafIds.get(id);
+  cleanup(realId);
+  return caf(realId);
+};
+
+exports["default"] = wrapperRaf;

package/lib/node_modules/rc-util/es/ref.js

@@ -0,0 +1,61 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _typeof = require('../../@babel/runtime/helpers/esm/typeof.js');
+require('../node_modules/react-is/index.js');
+require('react');
+var index = require('../../../_virtual/index.js');
+
+function fillRef(ref, node) {
+  if (typeof ref === 'function') {
+    ref(node);
+  } else if (_typeof["default"](ref) === 'object' && ref && 'current' in ref) {
+    ref.current = node;
+  }
+}
+
+/**
+ * Merge refs into one ref function to support ref passing.
+ */
+function composeRef() {
+  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+    refs[_key] = arguments[_key];
+  }
+  var refList = refs.filter(function (ref) {
+    return ref;
+  });
+  if (refList.length <= 1) {
+    return refList[0];
+  }
+  return function (node) {
+    refs.forEach(function (ref) {
+      fillRef(ref, node);
+    });
+  };
+}
+function supportRef(nodeOrComponent) {
+  var _type$prototype, _nodeOrComponent$prot;
+  var type = index.reactIs.exports.isMemo(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
+
+  // Function component node
+  if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
+    return false;
+  }
+
+  // Class component
+  if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render)) {
+    return false;
+  }
+  return true;
+}
+/* eslint-enable */
+
+exports.composeRef = composeRef;
+exports.fillRef = fillRef;
+exports.supportRef = supportRef;

package/lib/node_modules/rc-util/es/warning.js

@@ -0,0 +1,19 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable no-console */
+function warning(valid, message) {
+  // Support uglify
+  if (process.env.NODE_ENV !== 'production' && !valid && console !== undefined) {
+    console.error("Warning: ".concat(message));
+  }
+}
+/* eslint-enable */
+
+exports.warning = warning;