@elliemae/ds-query-builder 2.2.0-alpha.4 → 3.0.0-next.2

package/esm/components/Nestable/NestableItem.js

@@ -1,90 +1,103 @@
-import * as React from "react";
-import React2 from "react";
-import cn from "classnames";
-const NestableItem = ({
-  item,
-  isCopy,
-  options,
-  index,
-  isAndItem,
-  isOrItem,
-  isDraggableItem,
-  singleRow
-}) => {
-  const { dragItem, renderItem, handler, childrenProp } = options;
+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 '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); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+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 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${isCopy ? "-copy" : ""}`, `nestable-item${isCopy ? "-copy" : ""}-${item.id}`, `nestable-item-type-${item.element.type}`, {
-      "is-or-group": isOrGroup,
-      "is-and-group": isAndGroup,
-      "is-and-filter": item.element.type === "filter" && isAndItem,
-      "is-or-filter": item.element.type === "filter" && isOrItem
+    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,
+      'is-and-filter': item.element.type === 'filter' && isAndItem,
+      'is-or-filter': item.element.type === 'filter' && isOrItem
     }, {
-      "is-dragging": isDragging
+      'is-dragging': isDragging
     })
   };
   let rowProps = {};
   let handlerProps = {};
+
   if (!isCopy) {
     if (dragItem) {
-      rowProps = {
-        ...rowProps,
-        onMouseEnter: (e) => options.onMouseEnter(e, item)
-      };
+      rowProps = _objectSpread(_objectSpread({}, rowProps), {}, {
+        onMouseEnter: e => options.onMouseEnter(e, item)
+      });
     } else {
-      handlerProps = {
-        ...handlerProps,
+      handlerProps = _objectSpread(_objectSpread({}, handlerProps), {}, {
         draggable: isDraggableItem !== false,
-        onDragStart: (e) => options.onDragStart(e, item)
-      };
+        onDragStart: e => options.onDragStart(e, item)
+      });
     }
   }
+
   if (handler) {
-    Handler = /* @__PURE__ */ React2.createElement("span", {
-      className: "nestable-item-handler",
-      ...handlerProps
-    }, handler);
+    Handler = /*#__PURE__*/jsx("span", _objectSpread(_objectSpread({
+      className: "nestable-item-handler"
+    }, handlerProps), {}, {
+      children: handler
+    })); // Handler = React.cloneElement(handler, handlerProps);
   } else {
-    rowProps = {
-      ...rowProps,
-      ...handlerProps
-    };
+    rowProps = _objectSpread(_objectSpread({}, rowProps), handlerProps);
   }
+
   const childLength = item[childrenProp].length;
-  let childClass = "single";
-  if (childLength === 0)
-    childClass = "empty";
-  else if (childLength > 1)
-    childClass = "multiple";
-  return /* @__PURE__ */ React2.createElement("li", {
-    ...itemProps
-  }, /* @__PURE__ */ React2.createElement("div", {
-    className: `nestable-item-name nestable-item-name--${item.element.type} `,
-    ...rowProps
-  }, renderItem({
-    item,
-    handler: Handler,
-    index
-  })), hasChildren && item.element.type === "group" && !isCollapsed && /* @__PURE__ */ React2.createElement("ol", {
-    className: `nestable-list nestable-child-count-${childClass} `
-  }, item[childrenProp].map((currentitem, i) => /* @__PURE__ */ React2.createElement(NestableItem, {
-    key: i,
-    index: i,
-    isAndItem: isAndGroup,
-    isCopy,
-    isOrItem: isOrGroup,
-    item: currentitem,
-    options,
-    singleRow
-  }))));
-};
-var NestableItem_default = NestableItem;
-export {
-  NestableItem_default as default
+  let childClass = 'single';
+  if (childLength === 0) childClass = 'empty';else if (childLength > 1) childClass = 'multiple';
+  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,
+      isOrItem: isOrGroup,
+      item: currentitem,
+      options: options,
+      singleRow: singleRow
+    }, i)))]
+  }));
 };
-//# sourceMappingURL=NestableItem.js.map
+
+export { NestableItem as default };

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

@@ -1,72 +1,91 @@
-import * as React from "react";
-import {
-  closest,
-  getOffsetRect,
-  getTotalScroll,
-  getTransformProps
-} from "@elliemae/ds-shared/utils";
+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); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function onDragStart(e, item) {
   if (e) {
     e.preventDefault();
     e.stopPropagation();
   }
-  this.el = closest(e.target, ".nestable-item");
+
+  this.el = closest(e.target, '.nestable-item');
   this.startTrackMouse();
   this.onMouseMove(e);
-  const { items } = this.state;
+  const {
+    items
+  } = this.state;
   this.setState({
     dragItem: item,
     itemsOld: items
   });
 }
 function onDragEnd(e, isCancel) {
-  if (e && e.preventDefault)
-    e.preventDefault();
+  if (e && e.preventDefault) e.preventDefault();
   this.stopTrackMouse();
-  this.el = null;
-  const { items } = this.state;
+  this.el = null; // check if filter has children
+
+  const {
+    items
+  } = this.state;
   const nestedInFilter = this.checkFilterChildren(items);
-  if (nestedInFilter)
-    return this.dragRevert();
+  if (nestedInFilter) return this.dragRevert();
   return isCancel ? this.dragRevert() : this.dragApply();
 }
 function onMouseMove(e) {
-  const { group, threshold } = this.props;
-  const { dragItem } = this.state;
-  const { clientX, clientY } = e;
+  const {
+    group,
+    threshold
+  } = this.props;
+  const {
+    dragItem
+  } = this.state;
+  const {
+    clientX,
+    clientY
+  } = e;
   const transformProps = getTransformProps(clientX, clientY);
-  const elCopy = document.querySelector(`.nestable-${group} .nestable-drag-layer > .nestable-list`);
+  const elCopy = document.querySelector(".nestable-".concat(group, " .nestable-drag-layer > .nestable-list"));
+
   if (!this.elCopyStyles) {
     const offset = getOffsetRect(this.el);
     const scroll = getTotalScroll(this.el);
-    this.elCopyStyles = {
+    this.elCopyStyles = _objectSpread({
       marginTop: offset.top - clientY - scroll.top,
-      marginLeft: offset.left - clientX - scroll.left,
-      ...transformProps
-    };
+      marginLeft: offset.left - clientX - scroll.left
+    }, transformProps);
   } else {
-    this.elCopyStyles = {
-      ...this.elCopyStyles,
-      ...transformProps
-    };
+    this.elCopyStyles = _objectSpread(_objectSpread({}, this.elCopyStyles), transformProps);
+
     for (const key in transformProps) {
       if (transformProps.hasOwnProperty(key)) {
         elCopy.style[key] = transformProps[key];
       }
     }
+
     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;
     } else {
       this.mouse.shift.x = 0;
     }
+
     this.mouse.last.x = clientX;
+
     if (Math.abs(this.mouse.shift.x) > threshold) {
       if (this.mouse.shift.x > 0) {
         this.tryIncreaseDepth(dragItem);
       } else {
         this.tryDecreaseDepth(dragItem);
       }
+
       this.mouse.shift.x = 0;
     }
   }
@@ -76,44 +95,59 @@ function onMouseEnter(e, item) {
     e.preventDefault();
     e.stopPropagation();
   }
-  const { collapsed, childrenProp } = this.props;
-  const { dragItem } = this.state;
-  if (dragItem.id === item.id)
-    return;
+
+  const {
+    collapsed,
+    childrenProp
+  } = this.props;
+  const {
+    dragItem
+  } = this.state;
+  if (dragItem.id === item.id) return;
   const pathFrom = this.getPathById(dragItem.id);
-  const pathTo = this.getPathById(item.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
+
   let collapseProps = {};
+
   if (collapsed && pathFrom.length > 1) {
     const parent = this.getItemByPath(pathFrom.slice(0, -1));
+
     if (parent[childrenProp].length === 1) {
       collapseProps = this.onToggleCollapse(parent, true);
     }
   }
-  this.moveItem({ dragItem, pathFrom, pathTo }, collapseProps);
+
+  this.moveItem({
+    dragItem,
+    pathFrom,
+    pathTo
+  }, collapseProps);
 }
 function onToggleCollapse(item, isGetter) {
-  const { collapsed } = this.props;
-  const { collapsedGroups } = this.state;
+  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)
+    collapsedGroups: isCollapsed ^ collapsed ? collapsedGroups.filter(id => id !== item.id) : collapsedGroups.concat(item.id)
   };
+
   if (isGetter) {
     return newState;
   }
+
   return this.setState(newState);
 }
 function onKeyDown(e) {
   if (e.which === 27) {
+    // ESC
     this.onDragEnd(null, true);
   }
 }
-export {
-  onDragEnd,
-  onDragStart,
-  onKeyDown,
-  onMouseEnter,
-  onMouseMove,
-  onToggleCollapse
-};
-//# sourceMappingURL=events.js.map
+
+export { onDragEnd, onDragStart, onKeyDown, onMouseEnter, onMouseMove, onToggleCollapse };

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

@@ -1,7 +1,13 @@
-import * as React from "react";
 function getItemOptions() {
-  const { renderItem, renderCollapseIcon, handler, childrenProp } = this.props;
-  const { dragItem } = this.state;
+  const {
+    renderItem,
+    renderCollapseIcon,
+    handler,
+    childrenProp
+  } = this.props;
+  const {
+    dragItem
+  } = this.state;
   return {
     dragItem,
     childrenProp,
@@ -14,7 +20,5 @@ function getItemOptions() {
     onToggleCollapse: this.onToggleCollapse
   };
 }
-export {
-  getItemOptions
-};
-//# sourceMappingURL=getItemOptions.js.map
+
+export { getItemOptions };

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

@@ -1,69 +1,99 @@
-import * as React from "react";
+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) {
-  const { childrenProp } = this.props;
+  const {
+    childrenProp
+  } = this.props;
   const ppLastIndex = prevPath.length - 1;
   const npLastIndex = nextPath.length - 1;
+
   if (prevPath.length < nextPath.length) {
+    // move into deep
     let wasShifted = false;
     return nextPath.map((nextIndex, i) => {
       if (wasShifted) {
         return i === npLastIndex ? nextIndex + 1 : nextIndex;
       }
-      if (typeof prevPath[i] !== "number") {
+
+      if (typeof prevPath[i] !== 'number') {
         return nextIndex;
       }
+
       if (nextPath[i] > prevPath[i] && i === ppLastIndex) {
         wasShifted = true;
         return nextIndex - 1;
       }
+
       return nextIndex;
     });
   }
+
   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]) {
       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);
       }
     }
   }
+
   return nextPath;
 }
 function getPathById(id, items) {
-  const { childrenProp } = this.props;
+  const {
+    childrenProp
+  } = this.props;
   let path = [];
   items.every((item, i) => {
     if (item.id === id) {
       path.push(i);
     } else if (item[childrenProp]) {
       const childrenPath = this.getPathById(id, item[childrenProp]);
+
       if (childrenPath.length) {
         path = path.concat(i).concat(childrenPath);
       }
     }
+
     return path.length === 0;
   });
   return path;
 }
 function getItemByPath(path, items) {
-  const { childrenProp } = this.props;
+  const {
+    childrenProp
+  } = this.props;
   let item = null;
-  path.forEach((index) => {
+  path.forEach(index => {
     const list = item ? item[childrenProp] : items;
     item = list[index];
   });
   return item;
 }
 function getItemDepth(item) {
-  const { childrenProp } = this.props;
+  const {
+    childrenProp
+  } = this.props;
   let level = 1;
+
   if (item[childrenProp].length > 0) {
     const childrenDepths = item[childrenProp].map(this.getItemDepth);
     level += Math.max(...childrenDepths);
   }
+
   return level;
 }
-function getSplicePath(path, options = {}) {
+function getSplicePath(path) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   const splicePath = {};
   const numToRemove = options.numToRemove || 0;
   const itemsToInsert = options.itemsToInsert || [];
@@ -74,17 +104,13 @@ function getSplicePath(path, options = {}) {
       currentPath.$splice = [[index, numToRemove, ...itemsToInsert]];
     } else {
       const nextPath = {};
-      currentPath[index] = { [options.childrenProp]: nextPath };
+      currentPath[index] = {
+        [options.childrenProp]: nextPath
+      };
       currentPath = nextPath;
     }
   });
   return splicePath;
 }
-export {
-  getItemByPath,
-  getItemDepth,
-  getPathById,
-  getRealNextPath,
-  getSplicePath
-};
-//# sourceMappingURL=getPaths.js.map
+
+export { getItemByPath, getItemDepth, getPathById, getRealNextPath, getSplicePath };

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

@@ -1,13 +1,6 @@
-import * as React from "react";
-import { tryIncreaseDepth } from "./tryIncreaseDepth";
-import { tryDecreaseDepth } from "./tryDecreaseDepth";
-import { moveItem } from "./moveItem";
-export * from "./paths";
-export * from "./events";
-export * from "./getItemOptions";
-export {
-  moveItem,
-  tryDecreaseDepth,
-  tryIncreaseDepth
-};
-//# sourceMappingURL=index.js.map
+export { tryIncreaseDepth } from './tryIncreaseDepth.js';
+export { tryDecreaseDepth } from './tryDecreaseDepth.js';
+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';

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

@@ -1,8 +1,29 @@
-import * as React from "react";
-import update from "react-addons-update";
-function moveItem({ dragItem, pathFrom, pathTo }, extraProps = {}) {
-  const { childrenProp } = this.props;
-  let { items } = this.state;
+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';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function moveItem(_ref) {
+  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
+
   const realPathTo = this.getRealNextPath(pathFrom, pathTo);
   const removePath = this.getSplicePath(pathFrom, {
     numToRemove: 1,
@@ -15,13 +36,10 @@ function moveItem({ dragItem, pathFrom, pathTo }, extraProps = {}) {
   });
   items = update(items, removePath);
   items = update(items, insertPath);
-  this.setState({
+  this.setState(_objectSpread({
     items,
-    isDirty: true,
-    ...extraProps
-  });
+    isDirty: true
+  }, extraProps));
 }
-export {
-  moveItem
-};
-//# sourceMappingURL=moveItem.js.map
+
+export { moveItem };