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

package/esm/components/Nestable/NestableItem.js

@@ -1,32 +1,44 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.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 React from 'react';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'react';
 import cn from 'classnames';
+import { jsx, jsxs } from 'react/jsx-runtime';
 
 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; }
 
-var NestableItem = function NestableItem(_ref) {
-  var item = _ref.item,
-      isCopy = _ref.isCopy,
-      options = _ref.options,
-      index = _ref.index,
-      isAndItem = _ref.isAndItem,
-      isOrItem = _ref.isOrItem,
-      isDraggableItem = _ref.isDraggableItem,
-      singleRow = _ref.singleRow;
-  var dragItem = options.dragItem,
-      renderItem = options.renderItem,
-      handler = options.handler,
-      childrenProp = options.childrenProp;
-  var isCollapsed = options.isCollapsed(item);
-  var isDragging = !isCopy && dragItem && dragItem.id === item.id;
-  var hasChildren = item[childrenProp] && item[childrenProp].length > 0;
-  var Handler;
-  var isOrGroup = item.element.type === 'group' && (item.element.condition === '' || item.element.condition === false);
-  var isAndGroup = item.element.type === 'group' && !(item.element.condition === '' || item.element.condition === false);
-  var itemProps = {
+const NestableItem = _ref => {
+  let {
+    item,
+    isCopy,
+    options,
+    index,
+    isAndItem,
+    isOrItem,
+    isDraggableItem,
+    singleRow
+  } = _ref;
+  const {
+    dragItem,
+    renderItem,
+    handler,
+    childrenProp
+  } = options;
+  const isCollapsed = options.isCollapsed(item);
+  const isDragging = !isCopy && dragItem && dragItem.id === item.id;
+  const hasChildren = item[childrenProp] && item[childrenProp].length > 0;
+  let Handler;
+  const isOrGroup = item.element.type === 'group' && (item.element.condition === '' || item.element.condition === false);
+  const isAndGroup = item.element.type === 'group' && !(item.element.condition === '' || item.element.condition === false);
+  const itemProps = {
     className: cn("nestable-item".concat(isCopy ? '-copy' : ''), "nestable-item".concat(isCopy ? '-copy' : '', "-").concat(item.id), "nestable-item-type-".concat(item.element.type), {
       'is-or-group': isOrGroup,
       'is-and-group': isAndGroup,
@@ -36,48 +48,47 @@ var NestableItem = function NestableItem(_ref) {
       'is-dragging': isDragging
     })
   };
-  var rowProps = {};
-  var handlerProps = {};
+  let rowProps = {};
+  let handlerProps = {};
 
   if (!isCopy) {
     if (dragItem) {
       rowProps = _objectSpread(_objectSpread({}, rowProps), {}, {
-        onMouseEnter: function onMouseEnter(e) {
-          return options.onMouseEnter(e, item);
-        }
+        onMouseEnter: e => options.onMouseEnter(e, item)
       });
     } else {
       handlerProps = _objectSpread(_objectSpread({}, handlerProps), {}, {
         draggable: isDraggableItem !== false,
-        onDragStart: function onDragStart(e) {
-          return options.onDragStart(e, item);
-        }
+        onDragStart: e => options.onDragStart(e, item)
       });
     }
   }
 
   if (handler) {
-    Handler = /*#__PURE__*/React.createElement("span", _extends({
+    Handler = /*#__PURE__*/jsx("span", _objectSpread(_objectSpread({
       className: "nestable-item-handler"
-    }, handlerProps), handler); // Handler = React.cloneElement(handler, handlerProps);
+    }, handlerProps), {}, {
+      children: handler
+    })); // Handler = React.cloneElement(handler, handlerProps);
   } else {
     rowProps = _objectSpread(_objectSpread({}, rowProps), handlerProps);
   }
 
-  var childLength = item[childrenProp].length;
-  var childClass = 'single';
+  const childLength = item[childrenProp].length;
+  let childClass = 'single';
   if (childLength === 0) childClass = 'empty';else if (childLength > 1) childClass = 'multiple';
-  return /*#__PURE__*/React.createElement("li", itemProps, /*#__PURE__*/React.createElement("div", _extends({
-    className: "nestable-item-name nestable-item-name--".concat(item.element.type, " ")
-  }, rowProps), renderItem({
-    item: item,
-    handler: Handler,
-    index: index
-  })), hasChildren && item.element.type === 'group' && !isCollapsed && /*#__PURE__*/React.createElement("ol", {
-    className: "nestable-list nestable-child-count-".concat(childClass, " ")
-  }, item[childrenProp].map(function (currentitem, i) {
-    return /*#__PURE__*/React.createElement(NestableItem, {
-      key: i,
+  return /*#__PURE__*/jsxs("li", _objectSpread(_objectSpread({}, itemProps), {}, {
+    children: [/*#__PURE__*/jsx("div", _objectSpread(_objectSpread({
+      className: "nestable-item-name nestable-item-name--".concat(item.element.type, " ")
+    }, rowProps), {}, {
+      children: renderItem({
+        item,
+        handler: Handler,
+        index
+      })
+    })), hasChildren && item.element.type === 'group' && !isCollapsed && /*#__PURE__*/_jsx("ol", {
+      className: "nestable-list nestable-child-count-".concat(childClass, " ")
+    }, void 0, item[childrenProp].map((currentitem, i) => /*#__PURE__*/_jsx(NestableItem, {
       index: i,
       isAndItem: isAndGroup,
       isCopy: isCopy,
@@ -85,9 +96,8 @@ var NestableItem = function NestableItem(_ref) {
       item: currentitem,
       options: options,
       singleRow: singleRow
-    });
-  })));
+    }, i)))]
+  }));
 };
 
 export { NestableItem as default };
-//# sourceMappingURL=NestableItem.js.map

package/esm/components/Nestable/actions/events.js

@@ -1,4 +1,9 @@
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
 import { closest, getTransformProps, getOffsetRect, getTotalScroll } from '@elliemae/ds-shared/utils';
 
 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; }
@@ -13,7 +18,9 @@ function onDragStart(e, item) {
   this.el = closest(e.target, '.nestable-item');
   this.startTrackMouse();
   this.onMouseMove(e);
-  var items = this.state.items;
+  const {
+    items
+  } = this.state;
   this.setState({
     dragItem: item,
     itemsOld: items
@@ -24,24 +31,31 @@ function onDragEnd(e, isCancel) {
   this.stopTrackMouse();
   this.el = null; // check if filter has children
 
-  var items = this.state.items;
-  var nestedInFilter = this.checkFilterChildren(items);
+  const {
+    items
+  } = this.state;
+  const nestedInFilter = this.checkFilterChildren(items);
   if (nestedInFilter) return this.dragRevert();
   return isCancel ? this.dragRevert() : this.dragApply();
 }
 function onMouseMove(e) {
-  var _this$props = this.props,
-      group = _this$props.group,
-      threshold = _this$props.threshold;
-  var dragItem = this.state.dragItem;
-  var clientX = e.clientX,
-      clientY = e.clientY;
-  var transformProps = getTransformProps(clientX, clientY);
-  var elCopy = document.querySelector(".nestable-".concat(group, " .nestable-drag-layer > .nestable-list"));
+  const {
+    group,
+    threshold
+  } = this.props;
+  const {
+    dragItem
+  } = this.state;
+  const {
+    clientX,
+    clientY
+  } = e;
+  const transformProps = getTransformProps(clientX, clientY);
+  const elCopy = document.querySelector(".nestable-".concat(group, " .nestable-drag-layer > .nestable-list"));
 
   if (!this.elCopyStyles) {
-    var offset = getOffsetRect(this.el);
-    var scroll = getTotalScroll(this.el);
+    const offset = getOffsetRect(this.el);
+    const scroll = getTotalScroll(this.el);
     this.elCopyStyles = _objectSpread({
       marginTop: offset.top - clientY - scroll.top,
       marginLeft: offset.left - clientX - scroll.left
@@ -49,13 +63,13 @@ function onMouseMove(e) {
   } else {
     this.elCopyStyles = _objectSpread(_objectSpread({}, this.elCopyStyles), transformProps);
 
-    for (var key in transformProps) {
+    for (const key in transformProps) {
       if (transformProps.hasOwnProperty(key)) {
         elCopy.style[key] = transformProps[key];
       }
     }
 
-    var diffX = clientX - this.mouse.last.x;
+    const diffX = clientX - this.mouse.last.x;
 
     if (diffX >= 0 && this.mouse.shift.x >= 0 || diffX <= 0 && this.mouse.shift.x <= 0) {
       this.mouse.shift.x += diffX;
@@ -82,20 +96,23 @@ function onMouseEnter(e, item) {
     e.stopPropagation();
   }
 
-  var _this$props2 = this.props,
-      collapsed = _this$props2.collapsed,
-      childrenProp = _this$props2.childrenProp;
-  var dragItem = this.state.dragItem;
+  const {
+    collapsed,
+    childrenProp
+  } = this.props;
+  const {
+    dragItem
+  } = this.state;
   if (dragItem.id === item.id) return;
-  var pathFrom = this.getPathById(dragItem.id);
-  var pathTo = this.getPathById(item.id); // if collapsed by default
+  const pathFrom = this.getPathById(dragItem.id);
+  const pathTo = this.getPathById(item.id); // if collapsed by default
   // and move last (by count) child
   // remove parent node from list of open nodes
 
-  var collapseProps = {};
+  let collapseProps = {};
 
   if (collapsed && pathFrom.length > 1) {
-    var parent = this.getItemByPath(pathFrom.slice(0, -1));
+    const parent = this.getItemByPath(pathFrom.slice(0, -1));
 
     if (parent[childrenProp].length === 1) {
       collapseProps = this.onToggleCollapse(parent, true);
@@ -103,19 +120,21 @@ function onMouseEnter(e, item) {
   }
 
   this.moveItem({
-    dragItem: dragItem,
-    pathFrom: pathFrom,
-    pathTo: pathTo
+    dragItem,
+    pathFrom,
+    pathTo
   }, collapseProps);
 }
 function onToggleCollapse(item, isGetter) {
-  var collapsed = this.props.collapsed;
-  var collapsedGroups = this.state.collapsedGroups;
-  var isCollapsed = this.isCollapsed(item);
-  var newState = {
-    collapsedGroups: isCollapsed ^ collapsed ? collapsedGroups.filter(function (id) {
-      return id !== item.id;
-    }) : collapsedGroups.concat(item.id)
+  const {
+    collapsed
+  } = this.props;
+  const {
+    collapsedGroups
+  } = this.state;
+  const isCollapsed = this.isCollapsed(item);
+  const newState = {
+    collapsedGroups: isCollapsed ^ collapsed ? collapsedGroups.filter(id => id !== item.id) : collapsedGroups.concat(item.id)
   };
 
   if (isGetter) {
@@ -132,4 +151,3 @@ function onKeyDown(e) {
 }
 
 export { onDragEnd, onDragStart, onKeyDown, onMouseEnter, onMouseMove, onToggleCollapse };
-//# sourceMappingURL=events.js.map

package/esm/components/Nestable/actions/getItemOptions.js

@@ -1,16 +1,19 @@
 function getItemOptions() {
-  var _this$props = this.props,
-      renderItem = _this$props.renderItem,
-      renderCollapseIcon = _this$props.renderCollapseIcon,
-      handler = _this$props.handler,
-      childrenProp = _this$props.childrenProp;
-  var dragItem = this.state.dragItem;
+  const {
+    renderItem,
+    renderCollapseIcon,
+    handler,
+    childrenProp
+  } = this.props;
+  const {
+    dragItem
+  } = this.state;
   return {
-    dragItem: dragItem,
-    childrenProp: childrenProp,
-    renderItem: renderItem,
-    renderCollapseIcon: renderCollapseIcon,
-    handler: handler,
+    dragItem,
+    childrenProp,
+    renderItem,
+    renderCollapseIcon,
+    handler,
     onDragStart: this.onDragStart,
     onMouseEnter: this.onMouseEnter,
     isCollapsed: this.isCollapsed,
@@ -19,4 +22,3 @@ function getItemOptions() {
 }
 
 export { getItemOptions };
-//# sourceMappingURL=getItemOptions.js.map

package/esm/components/Nestable/actions/getPaths.js

@@ -1,15 +1,23 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/esnext.async-iterator.every.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.every.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 
 function getRealNextPath(prevPath, nextPath) {
-  var childrenProp = this.props.childrenProp;
-  var ppLastIndex = prevPath.length - 1;
-  var npLastIndex = nextPath.length - 1;
+  const {
+    childrenProp
+  } = this.props;
+  const ppLastIndex = prevPath.length - 1;
+  const npLastIndex = nextPath.length - 1;
 
   if (prevPath.length < nextPath.length) {
     // move into deep
-    var wasShifted = false;
-    return nextPath.map(function (nextIndex, i) {
+    let wasShifted = false;
+    return nextPath.map((nextIndex, i) => {
       if (wasShifted) {
         return i === npLastIndex ? nextIndex + 1 : nextIndex;
       }
@@ -30,7 +38,7 @@ function getRealNextPath(prevPath, nextPath) {
   if (prevPath.length === nextPath.length) {
     // if move bottom + move to item with children => make it a first child instead of swap
     if (nextPath[npLastIndex] > prevPath[npLastIndex]) {
-      var target = this.getItemByPath(nextPath);
+      const target = this.getItemByPath(nextPath);
 
       if (target[childrenProp] && target[childrenProp].length && !this.isCollapsed(target)) {
         return nextPath.slice(0, -1).concat(nextPath[npLastIndex] - 1).concat(0);
@@ -41,15 +49,15 @@ function getRealNextPath(prevPath, nextPath) {
   return nextPath;
 }
 function getPathById(id, items) {
-  var _this = this;
-
-  var childrenProp = this.props.childrenProp;
-  var path = [];
-  items.every(function (item, i) {
+  const {
+    childrenProp
+  } = this.props;
+  let path = [];
+  items.every((item, i) => {
     if (item.id === id) {
       path.push(i);
     } else if (item[childrenProp]) {
-      var childrenPath = _this.getPathById(id, item[childrenProp]);
+      const childrenPath = this.getPathById(id, item[childrenProp]);
 
       if (childrenPath.length) {
         path = path.concat(i).concat(childrenPath);
@@ -61,38 +69,44 @@ function getPathById(id, items) {
   return path;
 }
 function getItemByPath(path, items) {
-  var childrenProp = this.props.childrenProp;
-  var item = null;
-  path.forEach(function (index) {
-    var list = item ? item[childrenProp] : items;
+  const {
+    childrenProp
+  } = this.props;
+  let item = null;
+  path.forEach(index => {
+    const list = item ? item[childrenProp] : items;
     item = list[index];
   });
   return item;
 }
 function getItemDepth(item) {
-  var childrenProp = this.props.childrenProp;
-  var level = 1;
+  const {
+    childrenProp
+  } = this.props;
+  let level = 1;
 
   if (item[childrenProp].length > 0) {
-    var childrenDepths = item[childrenProp].map(this.getItemDepth);
-    level += Math.max.apply(Math, _toConsumableArray(childrenDepths));
+    const childrenDepths = item[childrenProp].map(this.getItemDepth);
+    level += Math.max(...childrenDepths);
   }
 
   return level;
 }
 function getSplicePath(path) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var splicePath = {};
-  var numToRemove = options.numToRemove || 0;
-  var itemsToInsert = options.itemsToInsert || [];
-  var lastIndex = path.length - 1;
-  var currentPath = splicePath;
-  path.forEach(function (index, i) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const splicePath = {};
+  const numToRemove = options.numToRemove || 0;
+  const itemsToInsert = options.itemsToInsert || [];
+  const lastIndex = path.length - 1;
+  let currentPath = splicePath;
+  path.forEach((index, i) => {
     if (i === lastIndex) {
-      currentPath.$splice = [[index, numToRemove].concat(_toConsumableArray(itemsToInsert))];
+      currentPath.$splice = [[index, numToRemove, ...itemsToInsert]];
     } else {
-      var nextPath = {};
-      currentPath[index] = _defineProperty({}, options.childrenProp, nextPath);
+      const nextPath = {};
+      currentPath[index] = {
+        [options.childrenProp]: nextPath
+      };
       currentPath = nextPath;
     }
   });
@@ -100,4 +114,3 @@ function getSplicePath(path) {
 }
 
 export { getItemByPath, getItemDepth, getPathById, getRealNextPath, getSplicePath };
-//# sourceMappingURL=getPaths.js.map

package/esm/components/Nestable/actions/index.js

@@ -4,8 +4,3 @@ export { moveItem } from './moveItem.js';
 export { getItemByPath, getItemDepth, getPathById, getRealNextPath, getSplicePath } from './paths.js';
 export { onDragEnd, onDragStart, onKeyDown, onMouseEnter, onMouseMove, onToggleCollapse } from './events.js';
 export { getItemOptions } from './getItemOptions.js';
-import '@babel/runtime/helpers/esm/defineProperty';
-import 'react-addons-update';
-import '@babel/runtime/helpers/esm/toConsumableArray';
-import '@elliemae/ds-shared/utils';
-//# sourceMappingURL=index.js.map

package/esm/components/Nestable/actions/moveItem.js

@@ -1,3 +1,8 @@
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.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 _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import update from 'react-addons-update';
 
@@ -5,31 +10,36 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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 moveItem(_ref) {
-  var dragItem = _ref.dragItem,
-      pathFrom = _ref.pathFrom,
-      pathTo = _ref.pathTo;
-  var extraProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var childrenProp = this.props.childrenProp;
-  var items = this.state.items; // the remove action might affect the next position,
+  let {
+    dragItem,
+    pathFrom,
+    pathTo
+  } = _ref;
+  let extraProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const {
+    childrenProp
+  } = this.props;
+  let {
+    items
+  } = this.state; // the remove action might affect the next position,
   // so update next coordinates accordingly
 
-  var realPathTo = this.getRealNextPath(pathFrom, pathTo);
-  var removePath = this.getSplicePath(pathFrom, {
+  const realPathTo = this.getRealNextPath(pathFrom, pathTo);
+  const removePath = this.getSplicePath(pathFrom, {
     numToRemove: 1,
-    childrenProp: childrenProp
+    childrenProp
   });
-  var insertPath = this.getSplicePath(realPathTo, {
+  const insertPath = this.getSplicePath(realPathTo, {
     numToRemove: 0,
     itemsToInsert: [dragItem],
-    childrenProp: childrenProp
+    childrenProp
   });
   items = update(items, removePath);
   items = update(items, insertPath);
   this.setState(_objectSpread({
-    items: items,
+    items,
     isDirty: true
   }, extraProps));
 }
 
 export { moveItem };
-//# sourceMappingURL=moveItem.js.map