@hi-ui/layout 4.0.0

package/lib/esm/node_modules/react-draggable/build/cjs/utils/domFns.js

@@ -0,0 +1,361 @@
+/** @LICENSE
+ * @hi-ui/layout
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/layout#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { __exports as domFns } from '../../../../../_virtual/domFns.js';
+import './shims.js';
+import './getPrefix.js';
+import { __exports as shims } from '../../../../../_virtual/shims.js';
+import { __exports as getPrefix } from '../../../../../_virtual/getPrefix.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);
+}
+Object.defineProperty(domFns, "__esModule", {
+  value: true
+});
+domFns.matchesSelector = matchesSelector;
+domFns.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;
+domFns.addEvent = addEvent;
+domFns.removeEvent = removeEvent;
+domFns.outerHeight = outerHeight;
+domFns.outerWidth = outerWidth;
+domFns.innerHeight = innerHeight;
+domFns.innerWidth = innerWidth;
+domFns.offsetXYFromParent = offsetXYFromParent;
+domFns.createCSSTransform = createCSSTransform;
+domFns.createSVGTransform = createSVGTransform;
+domFns.getTranslation = getTranslation;
+domFns.getTouch = getTouch;
+domFns.getTouchIdentifier = getTouchIdentifier;
+domFns.addUserSelectStyles = addUserSelectStyles;
+domFns.removeUserSelectStyles = removeUserSelectStyles;
+domFns.addClassName = addClassName;
+domFns.removeClassName = removeClassName;
+var _shims = shims;
+var _getPrefix = _interopRequireWildcard(getPrefix);
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== "function") return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function _getRequireWildcardCache() {
+    return cache;
+  };
+  return cache;
+}
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+    return {
+      "default": obj
+    };
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj["default"] = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var matchesSelectorFunc = '';
+function matchesSelector(el
+/*: Node*/, selector
+/*: string*/) /*: boolean*/
+{
+  if (!matchesSelectorFunc) {
+    matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {
+      // $FlowIgnore: Doesn't think elements are indexable
+      return (0, _shims.isFunction)(el[method]);
+    });
+  } // Might not be found entirely (not an Element?) - in that case, bail
+  // $FlowIgnore: Doesn't think elements are indexable
+
+  if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false; // $FlowIgnore: Doesn't think elements are indexable
+
+  return el[matchesSelectorFunc](selector);
+} // Works up the tree to the draggable itself attempting to match selector.
+
+function matchesSelectorAndParentsTo(el
+/*: Node*/, selector
+/*: string*/, baseNode
+/*: Node*/) /*: boolean*/
+{
+  var node = el;
+  do {
+    if (matchesSelector(node, selector)) return true;
+    if (node === baseNode) return false;
+    node = node.parentNode;
+  } while (node);
+  return false;
+}
+function addEvent(el
+/*: ?Node*/, event
+/*: string*/, handler
+/*: Function*/, inputOptions
+/*: Object*/) /*: void*/
+{
+  if (!el) return;
+  var options = _objectSpread({
+    capture: true
+  }, inputOptions);
+  if (el.addEventListener) {
+    el.addEventListener(event, handler, options);
+  } else if (el.attachEvent) {
+    el.attachEvent('on' + event, handler);
+  } else {
+    // $FlowIgnore: Doesn't think elements are indexable
+    el['on' + event] = handler;
+  }
+}
+function removeEvent(el
+/*: ?Node*/, event
+/*: string*/, handler
+/*: Function*/, inputOptions
+/*: Object*/) /*: void*/
+{
+  if (!el) return;
+  var options = _objectSpread({
+    capture: true
+  }, inputOptions);
+  if (el.removeEventListener) {
+    el.removeEventListener(event, handler, options);
+  } else if (el.detachEvent) {
+    el.detachEvent('on' + event, handler);
+  } else {
+    // $FlowIgnore: Doesn't think elements are indexable
+    el['on' + event] = null;
+  }
+}
+function outerHeight(node
+/*: HTMLElement*/) /*: number*/
+{
+  // This is deliberately excluding margin for our calculations, since we are using
+  // offsetTop which is including margin. See getBoundPosition
+  var height = node.clientHeight;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  height += (0, _shims["int"])(computedStyle.borderTopWidth);
+  height += (0, _shims["int"])(computedStyle.borderBottomWidth);
+  return height;
+}
+function outerWidth(node
+/*: HTMLElement*/) /*: number*/
+{
+  // This is deliberately excluding margin for our calculations, since we are using
+  // offsetLeft which is including margin. See getBoundPosition
+  var width = node.clientWidth;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  width += (0, _shims["int"])(computedStyle.borderLeftWidth);
+  width += (0, _shims["int"])(computedStyle.borderRightWidth);
+  return width;
+}
+function innerHeight(node
+/*: HTMLElement*/) /*: number*/
+{
+  var height = node.clientHeight;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  height -= (0, _shims["int"])(computedStyle.paddingTop);
+  height -= (0, _shims["int"])(computedStyle.paddingBottom);
+  return height;
+}
+function innerWidth(node
+/*: HTMLElement*/) /*: number*/
+{
+  var width = node.clientWidth;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  width -= (0, _shims["int"])(computedStyle.paddingLeft);
+  width -= (0, _shims["int"])(computedStyle.paddingRight);
+  return width;
+} // Get from offsetParent
+
+function offsetXYFromParent(evt
+/*: {clientX: number, clientY: number}*/, offsetParent
+/*: HTMLElement*/, scale
+/*: number*/) /*: ControlPosition*/
+{
+  var isBody = offsetParent === offsetParent.ownerDocument.body;
+  var offsetParentRect = isBody ? {
+    left: 0,
+    top: 0
+  } : offsetParent.getBoundingClientRect();
+  var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;
+  var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;
+  return {
+    x: x,
+    y: y
+  };
+}
+function createCSSTransform(controlPos
+/*: ControlPosition*/, positionOffset
+/*: PositionOffsetControlPosition*/) /*: Object*/
+{
+  var translation = getTranslation(controlPos, positionOffset, 'px');
+  return _defineProperty({}, (0, _getPrefix.browserPrefixToKey)('transform', _getPrefix["default"]), translation);
+}
+function createSVGTransform(controlPos
+/*: ControlPosition*/, positionOffset
+/*: PositionOffsetControlPosition*/) /*: string*/
+{
+  var translation = getTranslation(controlPos, positionOffset, '');
+  return translation;
+}
+function getTranslation(_ref2, positionOffset
+/*: PositionOffsetControlPosition*/, unitSuffix
+/*: string*/) /*: string*/
+{
+  var x = _ref2.x,
+    y = _ref2.y;
+  var translation = "translate(".concat(x).concat(unitSuffix, ",").concat(y).concat(unitSuffix, ")");
+  if (positionOffset) {
+    var defaultX = "".concat(typeof positionOffset.x === 'string' ? positionOffset.x : positionOffset.x + unitSuffix);
+    var defaultY = "".concat(typeof positionOffset.y === 'string' ? positionOffset.y : positionOffset.y + unitSuffix);
+    translation = "translate(".concat(defaultX, ", ").concat(defaultY, ")") + translation;
+  }
+  return translation;
+}
+function getTouch(e
+/*: MouseTouchEvent*/, identifier
+/*: number*/) /*: ?{clientX: number, clientY: number}*/
+{
+  return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, function (t) {
+    return identifier === t.identifier;
+  }) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, function (t) {
+    return identifier === t.identifier;
+  });
+}
+function getTouchIdentifier(e
+/*: MouseTouchEvent*/) /*: ?number*/
+{
+  if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;
+  if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;
+} // User-select Hacks:
+//
+// Useful for preventing blue highlights all over everything when dragging.
+// Note we're passing `document` b/c we could be iframed
+
+function addUserSelectStyles(doc
+/*: ?Document*/) {
+  if (!doc) return;
+  var styleEl = doc.getElementById('react-draggable-style-el');
+  if (!styleEl) {
+    styleEl = doc.createElement('style');
+    styleEl.type = 'text/css';
+    styleEl.id = 'react-draggable-style-el';
+    styleEl.innerHTML = '.react-draggable-transparent-selection *::-moz-selection {all: inherit;}\n';
+    styleEl.innerHTML += '.react-draggable-transparent-selection *::selection {all: inherit;}\n';
+    doc.getElementsByTagName('head')[0].appendChild(styleEl);
+  }
+  if (doc.body) addClassName(doc.body, 'react-draggable-transparent-selection');
+}
+function removeUserSelectStyles(doc
+/*: ?Document*/) {
+  if (!doc) return;
+  try {
+    if (doc.body) removeClassName(doc.body, 'react-draggable-transparent-selection'); // $FlowIgnore: IE
+
+    if (doc.selection) {
+      // $FlowIgnore: IE
+      doc.selection.empty();
+    } else {
+      // Remove selection caused by scroll, unless it's a focused input
+      // (we use doc.defaultView in case we're in an iframe)
+      var selection = (doc.defaultView || window).getSelection();
+      if (selection && selection.type !== 'Caret') {
+        selection.removeAllRanges();
+      }
+    }
+  } catch (e) {// probably IE
+  }
+}
+function addClassName(el
+/*: HTMLElement*/, className
+/*: string*/) {
+  if (el.classList) {
+    el.classList.add(className);
+  } else {
+    if (!el.className.match(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)")))) {
+      el.className += " ".concat(className);
+    }
+  }
+}
+function removeClassName(el
+/*: HTMLElement*/, className
+/*: string*/) {
+  if (el.classList) {
+    el.classList.remove(className);
+  } else {
+    el.className = el.className.replace(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)"), 'g'), '');
+  }
+}
+export { domFns as default };

package/lib/esm/node_modules/react-draggable/build/cjs/utils/getPrefix.js

@@ -0,0 +1,67 @@
+/** @LICENSE
+ * @hi-ui/layout
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/layout#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { __exports as getPrefix$1 } from '../../../../../_virtual/getPrefix.js';
+Object.defineProperty(getPrefix$1, "__esModule", {
+  value: true
+});
+getPrefix$1.getPrefix = getPrefix;
+getPrefix$1.browserPrefixToKey = browserPrefixToKey;
+getPrefix$1.browserPrefixToStyle = browserPrefixToStyle;
+getPrefix$1["default"] = void 0;
+var prefixes = ['Moz', 'Webkit', 'O', 'ms'];
+function getPrefix() /*: string*/
+{
+  var prop
+  /*: string*/ = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';
+  // Checking specifically for 'window.document' is for pseudo-browser server-side
+  // environments that define 'window' as the global context.
+  // E.g. React-rails (see https://github.com/reactjs/react-rails/pull/84)
+  if (typeof window === 'undefined' || typeof window.document === 'undefined') return '';
+  var style = window.document.documentElement.style;
+  if (prop in style) return '';
+  for (var i = 0; i < prefixes.length; i++) {
+    if (browserPrefixToKey(prop, prefixes[i]) in style) return prefixes[i];
+  }
+  return '';
+}
+function browserPrefixToKey(prop
+/*: string*/, prefix
+/*: string*/) /*: string*/
+{
+  return prefix ? "".concat(prefix).concat(kebabToTitleCase(prop)) : prop;
+}
+function browserPrefixToStyle(prop
+/*: string*/, prefix
+/*: string*/) /*: string*/
+{
+  return prefix ? "-".concat(prefix.toLowerCase(), "-").concat(prop) : prop;
+}
+function kebabToTitleCase(str
+/*: string*/) /*: string*/
+{
+  var out = '';
+  var shouldCapitalize = true;
+  for (var i = 0; i < str.length; i++) {
+    if (shouldCapitalize) {
+      out += str[i].toUpperCase();
+      shouldCapitalize = false;
+    } else if (str[i] === '-') {
+      shouldCapitalize = true;
+    } else {
+      out += str[i];
+    }
+  }
+  return out;
+} // Default export is the prefix itself, like 'Moz', 'Webkit', etc
+// Note that you may have to re-test for certain things; for instance, Chrome 50
+// can handle unprefixed `transform`, but not unprefixed `user-select`
+
+var _default = getPrefix();
+getPrefix$1["default"] = _default;

package/lib/esm/node_modules/react-draggable/build/cjs/utils/log.js

@@ -0,0 +1,17 @@
+/** @LICENSE
+ * @hi-ui/layout
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/layout#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { __exports as log$1 } from '../../../../../_virtual/log.js';
+Object.defineProperty(log$1, "__esModule", {
+  value: true
+});
+log$1["default"] = log;
+
+/*eslint no-console:0*/
+function log() {}

package/lib/esm/node_modules/react-draggable/build/cjs/utils/positionFns.js

@@ -0,0 +1,171 @@
+/** @LICENSE
+ * @hi-ui/layout
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/layout#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { __exports as positionFns } from '../../../../../_virtual/positionFns.js';
+import './shims.js';
+import './domFns.js';
+import { __exports as shims } from '../../../../../_virtual/shims.js';
+import { __exports as domFns } from '../../../../../_virtual/domFns.js';
+Object.defineProperty(positionFns, "__esModule", {
+  value: true
+});
+positionFns.getBoundPosition = getBoundPosition;
+positionFns.snapToGrid = snapToGrid;
+positionFns.canDragX = canDragX;
+positionFns.canDragY = canDragY;
+positionFns.getControlPosition = getControlPosition;
+positionFns.createCoreData = createCoreData;
+positionFns.createDraggableData = createDraggableData;
+var _shims = shims;
+var _domFns = domFns;
+function getBoundPosition(draggable
+/*: Draggable*/, x
+/*: number*/, y
+/*: number*/) /*: [number, number]*/
+{
+  // If no bounds, short-circuit and move on
+  if (!draggable.props.bounds) return [x, y]; // Clone new bounds
+
+  var bounds = draggable.props.bounds;
+  bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);
+  var node = findDOMNode(draggable);
+  if (typeof bounds === 'string') {
+    var ownerDocument = node.ownerDocument;
+    var ownerWindow = ownerDocument.defaultView;
+    var boundNode;
+    if (bounds === 'parent') {
+      boundNode = node.parentNode;
+    } else {
+      boundNode = ownerDocument.querySelector(bounds);
+    }
+    if (!(boundNode instanceof ownerWindow.HTMLElement)) {
+      throw new Error('Bounds selector "' + bounds + '" could not find an element.');
+    }
+    var nodeStyle = ownerWindow.getComputedStyle(node);
+    var boundNodeStyle = ownerWindow.getComputedStyle(boundNode); // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.
+
+    bounds = {
+      left: -node.offsetLeft + (0, _shims["int"])(boundNodeStyle.paddingLeft) + (0, _shims["int"])(nodeStyle.marginLeft),
+      top: -node.offsetTop + (0, _shims["int"])(boundNodeStyle.paddingTop) + (0, _shims["int"])(nodeStyle.marginTop),
+      right: (0, _domFns.innerWidth)(boundNode) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims["int"])(boundNodeStyle.paddingRight) - (0, _shims["int"])(nodeStyle.marginRight),
+      bottom: (0, _domFns.innerHeight)(boundNode) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims["int"])(boundNodeStyle.paddingBottom) - (0, _shims["int"])(nodeStyle.marginBottom)
+    };
+  } // Keep x and y below right and bottom limits...
+
+  if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);
+  if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom); // But above left and top limits.
+
+  if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);
+  if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);
+  return [x, y];
+}
+function snapToGrid(grid
+/*: [number, number]*/, pendingX
+/*: number*/, pendingY
+/*: number*/) /*: [number, number]*/
+{
+  var x = Math.round(pendingX / grid[0]) * grid[0];
+  var y = Math.round(pendingY / grid[1]) * grid[1];
+  return [x, y];
+}
+function canDragX(draggable
+/*: Draggable*/) /*: boolean*/
+{
+  return draggable.props.axis === 'both' || draggable.props.axis === 'x';
+}
+function canDragY(draggable
+/*: Draggable*/) /*: boolean*/
+{
+  return draggable.props.axis === 'both' || draggable.props.axis === 'y';
+} // Get {x, y} positions from event.
+
+function getControlPosition(e
+/*: MouseTouchEvent*/, touchIdentifier
+/*: ?number*/, draggableCore
+/*: DraggableCore*/) /*: ?ControlPosition*/
+{
+  var touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;
+  if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch
+
+  var node = findDOMNode(draggableCore); // User can provide an offsetParent if desired.
+
+  var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;
+  return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);
+} // Create an data object exposed by <DraggableCore>'s events
+
+function createCoreData(draggable
+/*: DraggableCore*/, x
+/*: number*/, y
+/*: number*/) /*: DraggableData*/
+{
+  var state = draggable.state;
+  var isStart = !(0, _shims.isNum)(state.lastX);
+  var node = findDOMNode(draggable);
+  if (isStart) {
+    // If this is our first move, use the x and y as last coords.
+    return {
+      node: node,
+      deltaX: 0,
+      deltaY: 0,
+      lastX: x,
+      lastY: y,
+      x: x,
+      y: y
+    };
+  } else {
+    // Otherwise calculate proper values.
+    return {
+      node: node,
+      deltaX: x - state.lastX,
+      deltaY: y - state.lastY,
+      lastX: state.lastX,
+      lastY: state.lastY,
+      x: x,
+      y: y
+    };
+  }
+} // Create an data exposed by <Draggable>'s events
+
+function createDraggableData(draggable
+/*: Draggable*/, coreData
+/*: DraggableData*/) /*: DraggableData*/
+{
+  var scale = draggable.props.scale;
+  return {
+    node: coreData.node,
+    x: draggable.state.x + coreData.deltaX / scale,
+    y: draggable.state.y + coreData.deltaY / scale,
+    deltaX: coreData.deltaX / scale,
+    deltaY: coreData.deltaY / scale,
+    lastX: draggable.state.x,
+    lastY: draggable.state.y
+  };
+} // A lot faster than stringify/parse
+
+function cloneBounds(bounds
+/*: Bounds*/) /*: Bounds*/
+{
+  return {
+    left: bounds.left,
+    top: bounds.top,
+    right: bounds.right,
+    bottom: bounds.bottom
+  };
+}
+function findDOMNode(draggable
+/*: Draggable | DraggableCore*/) /*: HTMLElement*/
+{
+  var node = draggable.findDOMNode();
+  if (!node) {
+    throw new Error('<DraggableCore>: Unmounted during event!');
+  } // $FlowIgnore we can't assert on HTMLElement due to tests... FIXME
+
+  return node;
+}
+export { positionFns as default };

package/lib/esm/node_modules/react-draggable/build/cjs/utils/shims.js

@@ -0,0 +1,52 @@
+/** @LICENSE
+ * @hi-ui/layout
+ * https://github.com/XiaoMi/hiui/tree/master/packages/ui/layout#readme
+ *
+ * Copyright (c) HiUI <mi-hiui@xiaomi.com>.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { __exports as shims } from '../../../../../_virtual/shims.js';
+Object.defineProperty(shims, "__esModule", {
+  value: true
+});
+shims.findInArray = findInArray;
+shims.isFunction = isFunction;
+shims.isNum = isNum;
+shims["int"] = _int;
+shims.dontSetMe = dontSetMe;
+
+// @credits https://gist.github.com/rogozhnikoff/a43cfed27c41e4e68cdc
+function findInArray(array
+/*: Array<any> | TouchList*/, callback
+/*: Function*/) /*: any*/
+{
+  for (var i = 0, length = array.length; i < length; i++) {
+    if (callback.apply(callback, [array[i], i, array])) return array[i];
+  }
+}
+function isFunction(func
+/*: any*/) /*: boolean %checks*/
+{
+  return typeof func === 'function' || Object.prototype.toString.call(func) === '[object Function]';
+}
+function isNum(num
+/*: any*/) /*: boolean %checks*/
+{
+  return typeof num === 'number' && !isNaN(num);
+}
+function _int(a
+/*: string*/) /*: number*/
+{
+  return parseInt(a, 10);
+}
+function dontSetMe(props
+/*: Object*/, propName
+/*: string*/, componentName
+/*: string*/) {
+  if (props[propName]) {
+    return new Error("Invalid prop ".concat(propName, " passed to ").concat(componentName, " - do not set this, set it on the child."));
+  }
+}
+export { shims as default };