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

package/cjs/components/Nestable/Nestable.js

@@ -1,130 +1,106 @@
 'use strict';
 
+var _jsx = require('@babel/runtime/helpers/jsx');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _createClass = require('@babel/runtime/helpers/createClass');
-var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
-var _inherits = require('@babel/runtime/helpers/inherits');
-var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
-var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
+require('core-js/modules/esnext.async-iterator.find.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.find.js');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
 var React = require('react');
-var PropTypes = require('prop-types');
 var cn = require('classnames');
 var utils = require('@elliemae/ds-shared/utils');
 var dsUtilities = require('@elliemae/ds-utilities');
-var components_Nestable_actions_tryIncreaseDepth = require('./actions/tryIncreaseDepth.js');
-var components_Nestable_actions_tryDecreaseDepth = require('./actions/tryDecreaseDepth.js');
-var components_Nestable_actions_moveItem = require('./actions/moveItem.js');
-var components_Nestable_actions_paths = require('./actions/paths.js');
-var components_Nestable_actions_events = require('./actions/events.js');
-var components_Nestable_actions_getItemOptions = require('./actions/getItemOptions.js');
-var components_Nestable_NestableItem = require('./NestableItem.js');
-require('react-addons-update');
-require('@babel/runtime/helpers/toConsumableArray');
-require('@babel/runtime/helpers/extends');
+var tryIncreaseDepth = require('./actions/tryIncreaseDepth.js');
+var tryDecreaseDepth = require('./actions/tryDecreaseDepth.js');
+var moveItem = require('./actions/moveItem.js');
+var paths = require('./actions/paths.js');
+var events = require('./actions/events.js');
+var getItemOptions = require('./actions/getItemOptions.js');
+var NestableItem = require('./NestableItem.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
 var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _assertThisInitialized__default = /*#__PURE__*/_interopDefaultLegacy(_assertThisInitialized);
-var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
-var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
-var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
 var cn__default = /*#__PURE__*/_interopDefaultLegacy(cn);
 
 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__default['default'](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 _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__default["default"](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__default['default'](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default['default'](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default['default'](this, result); }; }
+const shallowCompare = (instance, nextProps, nextState) => !dsUtilities.isEqualWith(instance.props, nextProps) || !dsUtilities.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 React.Component {
+  constructor(props) {
+    super(props);
 
-var shallowCompare = function shallowCompare(instance, nextProps, nextState) {
-  return !dsUtilities.isEqualWith(instance.props, nextProps) || !dsUtilities.isEqualWith(instance.state, nextState);
-};
-
-var Nestable = /*#__PURE__*/function (_Component) {
-  _inherits__default['default'](Nestable, _Component);
-
-  var _super = _createSuper(Nestable);
-
-  function Nestable(props) {
-    var _this;
-
-    _classCallCheck__default['default'](this, Nestable);
-
-    _this = _super.call(this, props);
-
-    _this.onDragStart = function (e, item) {
-      components_Nestable_actions_events.onDragStart.call(_assertThisInitialized__default['default'](_this), e, item);
+    this.onDragStart = (e, item) => {
+      events.onDragStart.call(this, e, item);
     };
 
-    _this.onDragEnd = function (e, isCancel) {
-      return components_Nestable_actions_events.onDragEnd.call(_assertThisInitialized__default['default'](_this), e, isCancel);
-    };
+    this.onDragEnd = (e, isCancel) => events.onDragEnd.call(this, e, isCancel);
 
-    _this.onMouseMove = function (e) {
-      return components_Nestable_actions_events.onMouseMove.call(_assertThisInitialized__default['default'](_this), e);
-    };
+    this.onMouseMove = e => events.onMouseMove.call(this, e);
 
-    _this.onMouseEnter = function (e, item) {
-      return components_Nestable_actions_events.onMouseEnter.call(_assertThisInitialized__default['default'](_this), e, item);
-    };
+    this.onMouseEnter = (e, item) => events.onMouseEnter.call(this, e, item);
 
-    _this.onToggleCollapse = function (item, isGetter) {
-      return components_Nestable_actions_events.onToggleCollapse.call(_assertThisInitialized__default['default'](_this), item, isGetter);
-    };
+    this.onToggleCollapse = (item, isGetter) => events.onToggleCollapse.call(this, item, isGetter);
 
-    _this.onKeyDown = function (e) {
-      return components_Nestable_actions_events.onKeyDown.call(_assertThisInitialized__default['default'](_this), e);
-    };
+    this.onKeyDown = e => events.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 components_Nestable_actions_paths.getItemDepth.call(_assertThisInitialized__default['default'](_this), item);
-    };
+    this.getItemDepth = item => paths.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,
@@ -132,18 +108,18 @@ var Nestable = /*#__PURE__*/function (_Component) {
       });
     };
 
-    _this.state = {
+    this.state = {
       items: [],
       itemsOld: null,
       dragItem: null,
       isDirty: false,
       collapsedGroups: [],
-      stopTrackingMouse: _this.stopTrackMouse.bind(_assertThisInitialized__default['default'](_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
       },
@@ -151,210 +127,194 @@ var Nestable = /*#__PURE__*/function (_Component) {
         x: 0
       }
     };
-    return _this;
   }
 
-  _createClass__default['default'](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 = utils.listWithChildren(items, childrenProp);
+    this.setState({
+      items
+    });
+  }
 
-      items = utils.listWithChildren(items, childrenProp);
-      this.setState({
-        items: items
-      });
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.stopTrackMouse();
-    }
-  }, {
-    key: "getPathById",
-    value: function getPathById(id) {
-      var items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
-      return components_Nestable_actions_paths.getPathById.call(this, id, items);
-    }
-  }, {
-    key: "getItemByPath",
-    value: function getItemByPath(path) {
-      var items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
-      return components_Nestable_actions_paths.getItemByPath.call(this, path, items);
-    }
-  }, {
-    key: "getSplicePath",
-    value: function getSplicePath(path) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      return components_Nestable_actions_paths.getSplicePath.call(this, path, options);
-    }
-  }, {
-    key: "getRealNextPath",
-    value: function getRealNextPath(prevPath, nextPath) {
-      return components_Nestable_actions_paths.getRealNextPath.call(this, prevPath, nextPath);
-    }
-  }, {
-    key: "getItemOptions",
-    value: function getItemOptions() {
-      return components_Nestable_actions_getItemOptions.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(dragItem) {
-      components_Nestable_actions_tryIncreaseDepth.tryIncreaseDepth.call(this, dragItem);
-    }
-  }, {
-    key: "tryDecreaseDepth",
-    value: function tryDecreaseDepth(dragItem) {
-      components_Nestable_actions_tryDecreaseDepth.tryDecreaseDepth.call(this, dragItem);
-    }
-  }, {
-    key: "moveItem",
-    value: function moveItem(_ref) {
-      var dragItem = _ref.dragItem,
-          pathFrom = _ref.pathFrom,
-          pathTo = _ref.pathTo;
-      var extraProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
-      components_Nestable_actions_moveItem.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__default['default'].createElement("div", {
-        className: "nestable-drag-layer"
-      }, /*#__PURE__*/React__default['default'].createElement("ol", {
-        className: "nestable-list",
-        style: listStyles
-      }, /*#__PURE__*/React__default['default'].createElement(components_Nestable_NestableItem, {
-        isCopy: true,
-        item: dragItem,
-        options: options
-      })));
+      return _objectSpread({
+        items: utils.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__default['default'].createElement("div", {
-        className: cn__default['default']('nestable', "nestable-".concat(group), {
-          'is-drag-active': dragItem
-        })
-      }, /*#__PURE__*/React__default['default'].createElement("ol", {
-        className: "nestable-list nestable-group nestable-child-count-".concat(childClass)
-      }, items.map(function (item, i) {
-        return /*#__PURE__*/React__default['default'].createElement(components_Nestable_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 paths.getPathById.call(this, id, items);
+  }
+
+  getItemByPath(path) {
+    let items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
+    return paths.getItemByPath.call(this, path, items);
+  }
+
+  getSplicePath(path) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return paths.getSplicePath.call(this, path, options);
+  }
+
+  getRealNextPath(prevPath, nextPath) {
+    return paths.getRealNextPath.call(this, prevPath, nextPath);
+  }
+
+  getItemOptions() {
+    return getItemOptions.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.tryIncreaseDepth.call(this, dragItem);
+  }
+
+  tryDecreaseDepth(dragItem) {
+    tryDecreaseDepth.tryDecreaseDepth.call(this, dragItem);
+  }
+
+  moveItem(_ref) {
+    let {
+      dragItem,
+      pathFrom,
+      pathTo
+    } = _ref;
+    let extraProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    moveItem.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: utils.listWithChildren(itemsNew, childrenProp),
-          dragItem: null,
-          isDirty: false,
-          oldProps: props
-        }, extra);
-      }
 
-      return null;
+    if (this.elCopyStyles) {
+      listStyles = _objectSpread(_objectSpread({}, listStyles), this.elCopyStyles);
     }
-  }]);
 
-  return Nestable;
-}(React.Component);
+    const options = this.getItemOptions();
+    return /*#__PURE__*/_jsx__default["default"]("div", {
+      className: "nestable-drag-layer"
+    }, void 0, /*#__PURE__*/_jsx__default["default"]("ol", {
+      className: "nestable-list",
+      style: listStyles
+    }, void 0, /*#__PURE__*/_jsx__default["default"](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__default["default"]("div", {
+      className: cn__default["default"]('nestable', "nestable-".concat(group), {
+        'is-drag-active': dragItem
+      })
+    }, void 0, /*#__PURE__*/_jsx__default["default"]("ol", {
+      className: "nestable-list nestable-group nestable-child-count-".concat(childClass)
+    }, void 0, items.map((item, i) => /*#__PURE__*/_jsx__default["default"](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__default['default'].string,
-  group: PropTypes__default['default'].string,
-  items: PropTypes__default['default'].arrayOf(PropTypes__default['default'].shape({})),
-  collapsed: PropTypes__default['default'].bool,
-  onChange: PropTypes__default['default'].func,
-  isAndItem: PropTypes__default['default'].bool,
-  isOrItem: PropTypes__default['default'].bool,
-  isDraggableItem: PropTypes__default['default'].bool,
-  setDraggableItems: PropTypes__default['default'].func,
-  singleRow: PropTypes__default['default'].bool
+  onChange: () => {}
 };
 
 module.exports = Nestable;
-//# sourceMappingURL=Nestable.js.map