@elliemae/ds-query-builder 1.60.0 → 2.0.0-alpha.12

package/esm/components/Nestable/Nestable.js

@@ -1,12 +1,15 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
-import _createClass from '@babel/runtime/helpers/esm/createClass';
-import _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';
-import _inherits from '@babel/runtime/helpers/esm/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/esm/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/esm/getPrototypeOf';
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import { Component } from 'react';
 import cn from 'classnames';
 import { listWithChildren } from '@elliemae/ds-shared/utils';
 import { isEqualWith } from '@elliemae/ds-utilities';
@@ -17,99 +20,79 @@ import { getItemDepth, getPathById, getItemByPath, getSplicePath, getRealNextPat
 import { onDragStart, onDragEnd, onMouseMove, onMouseEnter, onToggleCollapse, onKeyDown } from './actions/events.js';
 import { getItemOptions } from './actions/getItemOptions.js';
 import NestableItem from './NestableItem.js';
-import 'react-addons-update';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '@babel/runtime/helpers/esm/extends';
 
 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 _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); }; }
+const shallowCompare = (instance, nextProps, nextState) => !isEqualWith(instance.props, nextProps) || !isEqualWith(instance.state, nextState);
 
-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; } }
+class Nestable extends Component {
+  constructor(props) {
+    super(props);
 
-var shallowCompare = function shallowCompare(instance, nextProps, nextState) {
-  return !isEqualWith(instance.props, nextProps) || !isEqualWith(instance.state, nextState);
-};
-
-var Nestable = /*#__PURE__*/function (_Component) {
-  _inherits(Nestable, _Component);
-
-  var _super = _createSuper(Nestable);
-
-  function Nestable(props) {
-    var _this;
-
-    _classCallCheck(this, Nestable);
-
-    _this = _super.call(this, props);
-
-    _this.onDragStart = function (e, item) {
-      onDragStart.call(_assertThisInitialized(_this), e, item);
+    this.onDragStart = (e, item) => {
+      onDragStart.call(this, e, item);
     };
 
-    _this.onDragEnd = function (e, isCancel) {
-      return onDragEnd.call(_assertThisInitialized(_this), e, isCancel);
-    };
+    this.onDragEnd = (e, isCancel) => onDragEnd.call(this, e, isCancel);
 
-    _this.onMouseMove = function (e) {
-      return onMouseMove.call(_assertThisInitialized(_this), e);
-    };
+    this.onMouseMove = e => onMouseMove.call(this, e);
 
-    _this.onMouseEnter = function (e, item) {
-      return onMouseEnter.call(_assertThisInitialized(_this), e, item);
-    };
+    this.onMouseEnter = (e, item) => onMouseEnter.call(this, e, item);
 
-    _this.onToggleCollapse = function (item, isGetter) {
-      return onToggleCollapse.call(_assertThisInitialized(_this), item, isGetter);
-    };
+    this.onToggleCollapse = (item, isGetter) => onToggleCollapse.call(this, item, isGetter);
 
-    _this.onKeyDown = function (e) {
-      return onKeyDown.call(_assertThisInitialized(_this), e);
-    };
+    this.onKeyDown = e => onKeyDown.call(this, e);
 
-    _this.getDefaultItems = function () {
-      var items = _this.state.items;
+    this.getDefaultItems = () => {
+      const {
+        items
+      } = this.state;
       return items;
     };
 
-    _this.getItemDepth = function (item) {
-      return getItemDepth.call(_assertThisInitialized(_this), item);
-    };
+    this.getItemDepth = item => getItemDepth.call(this, item);
 
-    _this.startTrackMouse = function () {
-      document.addEventListener('mousemove', _this.onMouseMove);
-      document.addEventListener('mouseup', _this.onDragEnd);
-      document.addEventListener('keydown', _this.onKeyDown);
+    this.startTrackMouse = () => {
+      document.addEventListener('mousemove', this.onMouseMove);
+      document.addEventListener('mouseup', this.onDragEnd);
+      document.addEventListener('keydown', this.onKeyDown);
     };
 
-    _this.stopTrackMouse = function () {
-      document.removeEventListener('mousemove', _this.onMouseMove);
-      document.removeEventListener('mouseup', _this.onDragEnd);
-      document.removeEventListener('keydown', _this.onKeyDown);
-      _this.elCopyStyles = null;
+    this.stopTrackMouse = () => {
+      document.removeEventListener('mousemove', this.onMouseMove);
+      document.removeEventListener('mouseup', this.onDragEnd);
+      document.removeEventListener('keydown', this.onKeyDown);
+      this.elCopyStyles = null;
     };
 
-    _this.isCollapsed = function (item) {
-      var collapsed = _this.props.collapsed;
-      var collapsedGroups = _this.state.collapsedGroups;
+    this.isCollapsed = item => {
+      const {
+        collapsed
+      } = this.props;
+      const {
+        collapsedGroups
+      } = this.state;
       return !!(collapsedGroups.indexOf(item.id) > -1 ^ collapsed);
     };
 
-    _this.checkFilterChildren = function (items) {
-      return items.find(function (current) {
-        var type = current.element.type,
-            children = current.children;
-        if (type === 'filter' && children.length > 0) return true;
-        return _this.checkFilterChildren(children);
-      });
-    };
-
-    _this.dragRevert = function () {
-      var itemsOld = _this.state.itemsOld;
-
-      _this.setState({
+    this.checkFilterChildren = items => items.find(current => {
+      const {
+        element: {
+          type
+        },
+        children
+      } = current;
+      if (type === 'filter' && children.length > 0) return true;
+      return this.checkFilterChildren(children);
+    });
+
+    this.dragRevert = () => {
+      const {
+        itemsOld
+      } = this.state;
+      this.setState({
         items: itemsOld,
         itemsOld: null,
         dragItem: null,
@@ -117,18 +100,18 @@ var Nestable = /*#__PURE__*/function (_Component) {
       });
     };
 
-    _this.state = {
+    this.state = {
       items: [],
       itemsOld: null,
       dragItem: null,
       isDirty: false,
       collapsedGroups: [],
-      stopTrackingMouse: _this.stopTrackMouse.bind(_assertThisInitialized(_this)),
+      stopTrackingMouse: this.stopTrackMouse.bind(this),
       oldProps: props
     };
-    _this.el = null;
-    _this.elCopyStyles = null;
-    _this.mouse = {
+    this.el = null;
+    this.elCopyStyles = null;
+    this.mouse = {
       last: {
         x: 0
       },
@@ -136,210 +119,194 @@ var Nestable = /*#__PURE__*/function (_Component) {
         x: 0
       }
     };
-    return _this;
   }
 
-  _createClass(Nestable, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var childrenProp = this.props.childrenProp;
-      var items = this.props.items; // make sure every item has property 'children'
+  componentDidMount() {
+    const {
+      childrenProp
+    } = this.props;
+    let {
+      items
+    } = this.props; // make sure every item has property 'children'
+
+    items = listWithChildren(items, childrenProp);
+    this.setState({
+      items
+    });
+  }
 
-      items = listWithChildren(items, childrenProp);
-      this.setState({
-        items: items
-      });
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.stopTrackMouse();
-    }
-  }, {
-    key: "getPathById",
-    value: function getPathById$1(id) {
-      var items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
-      return getPathById.call(this, id, items);
-    }
-  }, {
-    key: "getItemByPath",
-    value: function getItemByPath$1(path) {
-      var items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
-      return getItemByPath.call(this, path, items);
-    }
-  }, {
-    key: "getSplicePath",
-    value: function getSplicePath$1(path) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      return getSplicePath.call(this, path, options);
-    }
-  }, {
-    key: "getRealNextPath",
-    value: function getRealNextPath$1(prevPath, nextPath) {
-      return getRealNextPath.call(this, prevPath, nextPath);
-    }
-  }, {
-    key: "getItemOptions",
-    value: function getItemOptions$1() {
-      return getItemOptions.call(this);
-    }
-  }, {
-    key: "dragApply",
-    value: function dragApply() {
-      var onChange = this.props.onChange;
-      var _this$state = this.state,
-          items = _this$state.items,
-          isDirty = _this$state.isDirty,
-          dragItem = _this$state.dragItem;
-      this.setState({
-        itemsOld: null,
-        dragItem: null,
-        isDirty: false
-      });
-      if (onChange && isDirty) onChange(items, dragItem);
-    }
-  }, {
-    key: "tryIncreaseDepth",
-    value: function tryIncreaseDepth$1(dragItem) {
-      tryIncreaseDepth.call(this, dragItem);
-    }
-  }, {
-    key: "tryDecreaseDepth",
-    value: function tryDecreaseDepth$1(dragItem) {
-      tryDecreaseDepth.call(this, dragItem);
-    }
-  }, {
-    key: "moveItem",
-    value: function moveItem$1(_ref) {
-      var dragItem = _ref.dragItem,
-          pathFrom = _ref.pathFrom,
-          pathTo = _ref.pathTo;
-      var extraProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-      moveItem.call(this, {
-        dragItem: dragItem,
-        pathFrom: pathFrom,
-        pathTo: pathTo
-      }, extraProps);
-    }
-  }, {
-    key: "renderDragLayer",
-    value: function renderDragLayer() {
-      var group = this.props.group;
-      var dragItem = this.state.dragItem;
-      var el = document.querySelector(".nestable-".concat(group, " .nestable-item-").concat(dragItem.id));
-      var listStyles = {};
-
-      if (el) {
-        listStyles.width = el.clientWidth;
-      }
+  componentWillUnmount() {
+    this.stopTrackMouse();
+  }
 
-      if (this.elCopyStyles) {
-        listStyles = _objectSpread(_objectSpread({}, listStyles), this.elCopyStyles);
+  static getDerivedStateFromProps(props, state) {
+    const {
+      items: itemsNew,
+      childrenProp
+    } = props;
+    const {
+      stopTrackingMouse,
+      oldProps
+    } = state;
+
+    if (shallowCompare({
+      props: oldProps,
+      state: {}
+    }, props, {})) {
+      stopTrackingMouse();
+      const extra = {};
+
+      if (oldProps.collapsed !== props.collapsed) {
+        extra.collapsedGroups = [];
       }
 
-      var options = this.getItemOptions();
-      return /*#__PURE__*/React.createElement("div", {
-        className: "nestable-drag-layer"
-      }, /*#__PURE__*/React.createElement("ol", {
-        className: "nestable-list",
-        style: listStyles
-      }, /*#__PURE__*/React.createElement(NestableItem, {
-        isCopy: true,
-        item: dragItem,
-        options: options
-      })));
+      return _objectSpread({
+        items: listWithChildren(itemsNew, childrenProp),
+        dragItem: null,
+        isDirty: false,
+        oldProps: props
+      }, extra);
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$state2 = this.state,
-          items = _this$state2.items,
-          dragItem = _this$state2.dragItem;
-      var _this$props = this.props,
-          group = _this$props.group,
-          isAndItem = _this$props.isAndItem,
-          isOrItem = _this$props.isOrItem,
-          isDraggableItem = _this$props.isDraggableItem,
-          setDraggableItems = _this$props.setDraggableItems,
-          singleRow = _this$props.singleRow;
-      var options = this.getItemOptions();
-      var childLength = items.length;
-      var childClass = 'single';
-      if (childLength === 0) childClass = 'empty';else if (childLength > 1) childClass = 'multiple';
-      return /*#__PURE__*/React.createElement("div", {
-        className: cn('nestable', "nestable-".concat(group), {
-          'is-drag-active': dragItem
-        })
-      }, /*#__PURE__*/React.createElement("ol", {
-        className: "nestable-list nestable-group nestable-child-count-".concat(childClass)
-      }, items.map(function (item, i) {
-        return /*#__PURE__*/React.createElement(NestableItem, {
-          key: item.id,
-          index: i,
-          isAndItem: isAndItem,
-          isDraggableItem: isDraggableItem,
-          isOrItem: isOrItem,
-          item: item,
-          options: options,
-          setDraggableItems: setDraggableItems,
-          singleRow: singleRow
-        });
-      })), dragItem && this.renderDragLayer());
+
+    return null;
+  }
+
+  getPathById(id) {
+    let items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
+    return getPathById.call(this, id, items);
+  }
+
+  getItemByPath(path) {
+    let items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
+    return getItemByPath.call(this, path, items);
+  }
+
+  getSplicePath(path) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return getSplicePath.call(this, path, options);
+  }
+
+  getRealNextPath(prevPath, nextPath) {
+    return getRealNextPath.call(this, prevPath, nextPath);
+  }
+
+  getItemOptions() {
+    return getItemOptions.call(this);
+  }
+
+  dragApply() {
+    const {
+      onChange
+    } = this.props;
+    const {
+      items,
+      isDirty,
+      dragItem
+    } = this.state;
+    this.setState({
+      itemsOld: null,
+      dragItem: null,
+      isDirty: false
+    });
+    if (onChange && isDirty) onChange(items, dragItem);
+  }
+
+  tryIncreaseDepth(dragItem) {
+    tryIncreaseDepth.call(this, dragItem);
+  }
+
+  tryDecreaseDepth(dragItem) {
+    tryDecreaseDepth.call(this, dragItem);
+  }
+
+  moveItem(_ref) {
+    let {
+      dragItem,
+      pathFrom,
+      pathTo
+    } = _ref;
+    let extraProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    moveItem.call(this, {
+      dragItem,
+      pathFrom,
+      pathTo
+    }, extraProps);
+  }
+
+  renderDragLayer() {
+    const {
+      group
+    } = this.props;
+    const {
+      dragItem
+    } = this.state;
+    const el = document.querySelector(".nestable-".concat(group, " .nestable-item-").concat(dragItem.id));
+    let listStyles = {};
+
+    if (el) {
+      listStyles.width = el.clientWidth;
     }
-  }], [{
-    key: "getDerivedStateFromProps",
-    value: function getDerivedStateFromProps(props, state) {
-      var itemsNew = props.items,
-          childrenProp = props.childrenProp;
-      var stopTrackingMouse = state.stopTrackingMouse,
-          oldProps = state.oldProps;
-
-      if (shallowCompare({
-        props: oldProps,
-        state: {}
-      }, props, {})) {
-        stopTrackingMouse();
-        var extra = {};
-
-        if (oldProps.collapsed !== props.collapsed) {
-          extra.collapsedGroups = [];
-        }
-
-        return _objectSpread({
-          items: listWithChildren(itemsNew, childrenProp),
-          dragItem: null,
-          isDirty: false,
-          oldProps: props
-        }, extra);
-      }
 
-      return null;
+    if (this.elCopyStyles) {
+      listStyles = _objectSpread(_objectSpread({}, listStyles), this.elCopyStyles);
     }
-  }]);
 
-  return Nestable;
-}(Component);
+    const options = this.getItemOptions();
+    return /*#__PURE__*/_jsx("div", {
+      className: "nestable-drag-layer"
+    }, void 0, /*#__PURE__*/_jsx("ol", {
+      className: "nestable-list",
+      style: listStyles
+    }, void 0, /*#__PURE__*/_jsx(NestableItem, {
+      isCopy: true,
+      item: dragItem,
+      options: options
+    })));
+  }
+
+  render() {
+    const {
+      items,
+      dragItem
+    } = this.state;
+    const {
+      group,
+      isAndItem,
+      isOrItem,
+      isDraggableItem,
+      setDraggableItems,
+      singleRow
+    } = this.props;
+    const options = this.getItemOptions();
+    const childLength = items.length;
+    let childClass = 'single';
+    if (childLength === 0) childClass = 'empty';else if (childLength > 1) childClass = 'multiple';
+    return /*#__PURE__*/_jsx("div", {
+      className: cn('nestable', "nestable-".concat(group), {
+        'is-drag-active': dragItem
+      })
+    }, void 0, /*#__PURE__*/_jsx("ol", {
+      className: "nestable-list nestable-group nestable-child-count-".concat(childClass)
+    }, void 0, items.map((item, i) => /*#__PURE__*/_jsx(NestableItem, {
+      index: i,
+      isAndItem: isAndItem,
+      isDraggableItem: isDraggableItem,
+      isOrItem: isOrItem,
+      item: item,
+      options: options,
+      setDraggableItems: setDraggableItems,
+      singleRow: singleRow
+    }, item.id))), dragItem && this.renderDragLayer());
+  }
+
+}
 
 Nestable.defaultProps = {
   items: [],
   collapsed: false,
   group: Math.random().toString(36).slice(2),
   childrenProp: 'children',
-  onChange: function onChange() {}
-};
-Nestable.propTypes = {
-  childrenProp: PropTypes.string,
-  group: PropTypes.string,
-  items: PropTypes.arrayOf(PropTypes.shape({})),
-  collapsed: PropTypes.bool,
-  onChange: PropTypes.func,
-  isAndItem: PropTypes.bool,
-  isOrItem: PropTypes.bool,
-  isDraggableItem: PropTypes.bool,
-  setDraggableItems: PropTypes.func,
-  singleRow: PropTypes.bool
+  onChange: () => {}
 };
 
 export { Nestable as default };
-//# sourceMappingURL=Nestable.js.map