antd3-esm 1.0.1

package/dist/scrollTo.js

@@ -0,0 +1,66 @@
+import { r as raf } from './menu.js';
+
+function getScroll(target, top) {
+  if (typeof window === 'undefined') {
+    return 0;
+  }
+
+  var prop = 'pageYOffset' ;
+  var method = 'scrollTop' ;
+  var isWindow = target === window;
+  var ret = isWindow ? target[prop] : target[method]; // ie6,7,8 standard mode
+
+  if (isWindow && typeof ret !== 'number') {
+    ret = document.documentElement[method];
+  }
+
+  return ret;
+}
+
+// eslint-disable-next-line import/prefer-default-export
+function easeInOutCubic(t, b, c, d) {
+  var cc = c - b;
+  t /= d / 2;
+
+  if (t < 1) {
+    return cc / 2 * t * t * t + b;
+  }
+
+  return cc / 2 * ((t -= 2) * t * t + 2) + b;
+}
+
+function scrollTo(y) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _options$getContainer = options.getContainer,
+      getContainer = _options$getContainer === void 0 ? function () {
+    return window;
+  } : _options$getContainer,
+      callback = options.callback,
+      _options$duration = options.duration,
+      duration = _options$duration === void 0 ? 450 : _options$duration;
+  var container = getContainer();
+  var scrollTop = getScroll(container);
+  var startTime = Date.now();
+
+  var frameFunc = function frameFunc() {
+    var timestamp = Date.now();
+    var time = timestamp - startTime;
+    var nextScrollTop = easeInOutCubic(time > duration ? duration : time, scrollTop, y, duration);
+
+    if (container === window) {
+      window.scrollTo(window.pageXOffset, nextScrollTop);
+    } else {
+      container.scrollTop = nextScrollTop;
+    }
+
+    if (time < duration) {
+      raf(frameFunc);
+    } else if (typeof callback === 'function') {
+      callback();
+    }
+  };
+
+  raf(frameFunc);
+}
+
+export { getScroll as g, scrollTo as s };

package/dist/toInteger.js

@@ -0,0 +1,123 @@
+import { b as requireToNumber } from './tree.js';
+
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+
+var _baseProperty;
+var hasRequired_baseProperty;
+
+function require_baseProperty () {
+	if (hasRequired_baseProperty) return _baseProperty;
+	hasRequired_baseProperty = 1;
+	function baseProperty(key) {
+	  return function(object) {
+	    return object == null ? undefined : object[key];
+	  };
+	}
+
+	_baseProperty = baseProperty;
+	return _baseProperty;
+}
+
+var toFinite_1;
+var hasRequiredToFinite;
+
+function requireToFinite () {
+	if (hasRequiredToFinite) return toFinite_1;
+	hasRequiredToFinite = 1;
+	var toNumber = requireToNumber();
+
+	/** Used as references for various `Number` constants. */
+	var INFINITY = 1 / 0,
+	    MAX_INTEGER = 1.7976931348623157e+308;
+
+	/**
+	 * Converts `value` to a finite number.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.12.0
+	 * @category Lang
+	 * @param {*} value The value to convert.
+	 * @returns {number} Returns the converted number.
+	 * @example
+	 *
+	 * _.toFinite(3.2);
+	 * // => 3.2
+	 *
+	 * _.toFinite(Number.MIN_VALUE);
+	 * // => 5e-324
+	 *
+	 * _.toFinite(Infinity);
+	 * // => 1.7976931348623157e+308
+	 *
+	 * _.toFinite('3.2');
+	 * // => 3.2
+	 */
+	function toFinite(value) {
+	  if (!value) {
+	    return value === 0 ? value : 0;
+	  }
+	  value = toNumber(value);
+	  if (value === INFINITY || value === -INFINITY) {
+	    var sign = (value < 0 ? -1 : 1);
+	    return sign * MAX_INTEGER;
+	  }
+	  return value === value ? value : 0;
+	}
+
+	toFinite_1 = toFinite;
+	return toFinite_1;
+}
+
+var toInteger_1;
+var hasRequiredToInteger;
+
+function requireToInteger () {
+	if (hasRequiredToInteger) return toInteger_1;
+	hasRequiredToInteger = 1;
+	var toFinite = requireToFinite();
+
+	/**
+	 * Converts `value` to an integer.
+	 *
+	 * **Note:** This method is loosely based on
+	 * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to convert.
+	 * @returns {number} Returns the converted integer.
+	 * @example
+	 *
+	 * _.toInteger(3.2);
+	 * // => 3
+	 *
+	 * _.toInteger(Number.MIN_VALUE);
+	 * // => 0
+	 *
+	 * _.toInteger(Infinity);
+	 * // => 1.7976931348623157e+308
+	 *
+	 * _.toInteger('3.2');
+	 * // => 3
+	 */
+	function toInteger(value) {
+	  var result = toFinite(value),
+	      remainder = result % 1;
+
+	  return result === result ? (remainder ? result - remainder : result) : 0;
+	}
+
+	toInteger_1 = toInteger;
+	return toInteger_1;
+}
+
+export { requireToInteger as a, require_baseProperty as r };

package/dist/toString.js

@@ -0,0 +1,84 @@
+import { r as require_Symbol, a as requireIsSymbol } from './tree.js';
+import { r as requireIsArray, a as require_arrayMap } from './_arrayMap.js';
+
+var _baseToString;
+var hasRequired_baseToString;
+
+function require_baseToString () {
+	if (hasRequired_baseToString) return _baseToString;
+	hasRequired_baseToString = 1;
+	var Symbol = require_Symbol(),
+	    arrayMap = require_arrayMap(),
+	    isArray = requireIsArray(),
+	    isSymbol = requireIsSymbol();
+
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : undefined,
+	    symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+	/**
+	 * The base implementation of `_.toString` which doesn't convert nullish
+	 * values to empty strings.
+	 *
+	 * @private
+	 * @param {*} value The value to process.
+	 * @returns {string} Returns the string.
+	 */
+	function baseToString(value) {
+	  // Exit early for strings to avoid a performance hit in some environments.
+	  if (typeof value == 'string') {
+	    return value;
+	  }
+	  if (isArray(value)) {
+	    // Recursively convert values (susceptible to call stack limits).
+	    return arrayMap(value, baseToString) + '';
+	  }
+	  if (isSymbol(value)) {
+	    return symbolToString ? symbolToString.call(value) : '';
+	  }
+	  var result = (value + '');
+	  return (result == '0' && (1 / value) == -Infinity) ? '-0' : result;
+	}
+
+	_baseToString = baseToString;
+	return _baseToString;
+}
+
+var toString_1;
+var hasRequiredToString;
+
+function requireToString () {
+	if (hasRequiredToString) return toString_1;
+	hasRequiredToString = 1;
+	var baseToString = require_baseToString();
+
+	/**
+	 * Converts `value` to a string. An empty string is returned for `null`
+	 * and `undefined` values. The sign of `-0` is preserved.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to convert.
+	 * @returns {string} Returns the converted string.
+	 * @example
+	 *
+	 * _.toString(null);
+	 * // => ''
+	 *
+	 * _.toString(-0);
+	 * // => '-0'
+	 *
+	 * _.toString([1, 2, 3]);
+	 * // => '1,2,3'
+	 */
+	function toString(value) {
+	  return value == null ? '' : baseToString(value);
+	}
+
+	toString_1 = toString;
+	return toString_1;
+}
+
+export { requireToString as a, require_baseToString as r };

package/dist/transButton.js

@@ -0,0 +1,121 @@
+import * as React from 'react';
+import { K as KeyCode } from './menu.js';
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _extends() { _extends = Object.assign || 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); }
+
+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, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+
+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 } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+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 _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var __rest = undefined && undefined.__rest || function (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;
+};
+var inlineStyle = {
+  border: 0,
+  background: 'transparent',
+  padding: 0,
+  lineHeight: 'inherit',
+  display: 'inline-block'
+};
+
+var TransButton = /*#__PURE__*/function (_React$Component) {
+  _inherits(TransButton, _React$Component);
+
+  var _super = _createSuper(TransButton);
+
+  function TransButton() {
+    var _this;
+
+    _classCallCheck(this, TransButton);
+
+    _this = _super.apply(this, arguments);
+
+    _this.onKeyDown = function (event) {
+      var keyCode = event.keyCode;
+
+      if (keyCode === KeyCode.ENTER) {
+        event.preventDefault();
+      }
+    };
+
+    _this.onKeyUp = function (event) {
+      var keyCode = event.keyCode;
+      var onClick = _this.props.onClick;
+
+      if (keyCode === KeyCode.ENTER && onClick) {
+        onClick();
+      }
+    };
+
+    _this.setRef = function (btn) {
+      _this.div = btn;
+    };
+
+    return _this;
+  }
+
+  _createClass(TransButton, [{
+    key: "focus",
+    value: function focus() {
+      if (this.div) {
+        this.div.focus();
+      }
+    }
+  }, {
+    key: "blur",
+    value: function blur() {
+      if (this.div) {
+        this.div.blur();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _a = this.props,
+          style = _a.style,
+          noStyle = _a.noStyle,
+          restProps = __rest(_a, ["style", "noStyle"]);
+
+      return /*#__PURE__*/React.createElement("div", _extends({
+        role: "button",
+        tabIndex: 0,
+        ref: this.setRef
+      }, restProps, {
+        onKeyDown: this.onKeyDown,
+        onKeyUp: this.onKeyUp,
+        style: _extends(_extends({}, !noStyle ? inlineStyle : null), style)
+      }));
+    }
+  }]);
+
+  return TransButton;
+}(React.Component);
+
+export { TransButton as T };