amis-ui 2.6.0 → 2.7.0

package/lib/node_modules/@babel/runtime/helpers/esm/createClass.js

@@ -0,0 +1,30 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var toPropertyKey = require('./toPropertyKey.js');
+
+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["default"](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;
+}
+
+exports["default"] = _createClass;

package/lib/node_modules/@babel/runtime/helpers/esm/createSuper.js

@@ -0,0 +1,29 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getPrototypeOf = require('./getPrototypeOf.js');
+var isNativeReflectConstruct = require('./isNativeReflectConstruct.js');
+var possibleConstructorReturn = require('./possibleConstructorReturn.js');
+
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = isNativeReflectConstruct["default"]();
+  return function _createSuperInternal() {
+    var Super = getPrototypeOf["default"](Derived),
+      result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = getPrototypeOf["default"](this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return possibleConstructorReturn["default"](this, result);
+  };
+}
+
+exports["default"] = _createSuper;

package/lib/node_modules/@babel/runtime/helpers/esm/defineProperty.js

@@ -0,0 +1,27 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var toPropertyKey = require('./toPropertyKey.js');
+
+function _defineProperty(obj, key, value) {
+  key = toPropertyKey["default"](key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+exports["default"] = _defineProperty;

package/lib/node_modules/@babel/runtime/helpers/esm/extends.js

@@ -0,0 +1,25 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+exports["default"] = _extends;

package/lib/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js

@@ -0,0 +1,17 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+exports["default"] = _getPrototypeOf;

package/lib/node_modules/@babel/runtime/helpers/esm/inherits.js

@@ -0,0 +1,29 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var setPrototypeOf = require('./setPrototypeOf.js');
+
+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["default"](subClass, superClass);
+}
+
+exports["default"] = _inherits;

package/lib/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js

@@ -0,0 +1,22 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+exports["default"] = _isNativeReflectConstruct;

package/lib/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js

@@ -0,0 +1,40 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (_x = (_i = _i.call(arr)).next, 0 === i) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0) {
+        ;
+      }
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+
+exports["default"] = _iterableToArrayLimit;

package/lib/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js

@@ -0,0 +1,14 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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.");
+}
+
+exports["default"] = _nonIterableRest;

package/lib/node_modules/@babel/runtime/helpers/esm/objectSpread2.js

@@ -0,0 +1,34 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var defineProperty = require('./defineProperty.js');
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      defineProperty["default"](target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+
+exports["default"] = _objectSpread2;

package/lib/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js

@@ -0,0 +1,28 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var objectWithoutPropertiesLoose = require('./objectWithoutPropertiesLoose.js');
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = objectWithoutPropertiesLoose["default"](source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+
+exports["default"] = _objectWithoutProperties;

package/lib/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js

@@ -0,0 +1,23 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+exports["default"] = _objectWithoutPropertiesLoose;

package/lib/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js

@@ -0,0 +1,22 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _typeof = require('./typeof.js');
+var assertThisInitialized = require('./assertThisInitialized.js');
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof["default"](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["default"](self);
+}
+
+exports["default"] = _possibleConstructorReturn;

package/lib/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js

@@ -0,0 +1,18 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+exports["default"] = _setPrototypeOf;

package/lib/node_modules/@babel/runtime/helpers/esm/slicedToArray.js

@@ -0,0 +1,19 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var arrayWithHoles = require('./arrayWithHoles.js');
+var iterableToArrayLimit = require('./iterableToArrayLimit.js');
+var unsupportedIterableToArray = require('./unsupportedIterableToArray.js');
+var nonIterableRest = require('./nonIterableRest.js');
+
+function _slicedToArray(arr, i) {
+  return arrayWithHoles["default"](arr) || iterableToArrayLimit["default"](arr, i) || unsupportedIterableToArray["default"](arr, i) || nonIterableRest["default"]();
+}
+
+exports["default"] = _slicedToArray;

package/lib/node_modules/@babel/runtime/helpers/esm/toPrimitive.js

@@ -0,0 +1,23 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _typeof = require('./typeof.js');
+
+function _toPrimitive(input, hint) {
+  if (_typeof["default"](input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof["default"](res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+exports["default"] = _toPrimitive;

package/lib/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js

@@ -0,0 +1,18 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _typeof = require('./typeof.js');
+var toPrimitive = require('./toPrimitive.js');
+
+function _toPropertyKey(arg) {
+  var key = toPrimitive["default"](arg, "string");
+  return _typeof["default"](key) === "symbol" ? key : String(key);
+}
+
+exports["default"] = _toPropertyKey;

package/lib/node_modules/@babel/runtime/helpers/esm/typeof.js

@@ -0,0 +1,20 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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);
+}
+
+exports["default"] = _typeof;

package/lib/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js

@@ -0,0 +1,21 @@
+/**
+ * amis-ui v2.7.0
+ * Copyright 2018-2023 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var arrayLikeToArray = require('./arrayLikeToArray.js');
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return arrayLikeToArray["default"](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["default"](o, minLen);
+}
+
+exports["default"] = _unsupportedIterableToArray;

package/lib/node_modules/rc-overflow/es/Item.js

@@ -0,0 +1,117 @@
+/**
+ * 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 objectSpread2 = require('../../@babel/runtime/helpers/esm/objectSpread2.js');
+var objectWithoutProperties = require('../../@babel/runtime/helpers/esm/objectWithoutProperties.js');
+var React = require('react');
+var cx = require('classnames');
+var index = require('../../rc-resize-observer/es/index.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+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 cx__default = /*#__PURE__*/_interopDefaultLegacy(cx);
+
+var _excluded = ["prefixCls", "invalidate", "item", "renderItem", "responsive", "responsiveDisabled", "registerSize", "itemKey", "className", "style", "children", "display", "order", "component"];
+
+var UNDEFINED = undefined;
+
+function InternalItem(props, ref) {
+  var prefixCls = props.prefixCls,
+      invalidate = props.invalidate,
+      item = props.item,
+      renderItem = props.renderItem,
+      responsive = props.responsive,
+      responsiveDisabled = props.responsiveDisabled,
+      registerSize = props.registerSize,
+      itemKey = props.itemKey,
+      className = props.className,
+      style = props.style,
+      children = props.children,
+      display = props.display,
+      order = props.order,
+      _props$component = props.component,
+      Component = _props$component === void 0 ? 'div' : _props$component,
+      restProps = objectWithoutProperties["default"](props, _excluded);
+
+  var mergedHidden = responsive && !display; // ================================ Effect ================================
+
+  function internalRegisterSize(width) {
+    registerSize(itemKey, width);
+  }
+
+  React__namespace.useEffect(function () {
+    return function () {
+      internalRegisterSize(null);
+    };
+  }, []); // ================================ Render ================================
+
+  var childNode = renderItem && item !== UNDEFINED ? renderItem(item) : children;
+  var overflowStyle;
+
+  if (!invalidate) {
+    overflowStyle = {
+      opacity: mergedHidden ? 0 : 1,
+      height: mergedHidden ? 0 : UNDEFINED,
+      overflowY: mergedHidden ? 'hidden' : UNDEFINED,
+      order: responsive ? order : UNDEFINED,
+      pointerEvents: mergedHidden ? 'none' : UNDEFINED,
+      position: mergedHidden ? 'absolute' : UNDEFINED
+    };
+  }
+
+  var overflowProps = {};
+
+  if (mergedHidden) {
+    overflowProps['aria-hidden'] = true;
+  }
+
+  var itemNode = /*#__PURE__*/React__namespace.createElement(Component, _extends["default"]({
+    className: cx__default["default"](!invalidate && prefixCls, className),
+    style: objectSpread2["default"](objectSpread2["default"]({}, overflowStyle), style)
+  }, overflowProps, restProps, {
+    ref: ref
+  }), childNode);
+
+  if (responsive) {
+    itemNode = /*#__PURE__*/React__namespace.createElement(index["default"], {
+      onResize: function onResize(_ref) {
+        var offsetWidth = _ref.offsetWidth;
+        internalRegisterSize(offsetWidth);
+      },
+      disabled: responsiveDisabled
+    }, itemNode);
+  }
+
+  return itemNode;
+}
+
+var Item = /*#__PURE__*/React__namespace.forwardRef(InternalItem);
+Item.displayName = 'Item';
+
+exports["default"] = Item;