@elliemae/ds-query-builder 2.3.0-alpha.9 → 2.3.0-next.11

package/{dist/esm → 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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,45 @@
+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,
+    childrenProp
+  });
+  const insertPath = this.getSplicePath(realPathTo, {
+    numToRemove: 0,
+    itemsToInsert: [dragItem],
+    childrenProp
+  });
+  items = update(items, removePath);
+  items = update(items, insertPath);
+  this.setState(_objectSpread({
+    items,
+    isDirty: true
+  }, extraProps));
+}
+
+export { moveItem };

package/{dist/esm → esm}/components/Nestable/actions/paths.js

@@ -1,69 +1,101 @@
-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 = this.getDefaultItems()) {
-  const { childrenProp } = this.props;
+function getPathById(id) {
+  let items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
+  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 = this.getDefaultItems()) {
-  const { childrenProp } = this.props;
+function getItemByPath(path) {
+  let items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
+  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 +106,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=paths.js.map
+
+export { getItemByPath, getItemDepth, getPathById, getRealNextPath, getSplicePath };

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

@@ -0,0 +1,31 @@
+function tryDecreaseDepth(dragItem) {
+  const {
+    childrenProp,
+    collapsed
+  } = this.props;
+  const pathFrom = this.getPathById(dragItem.id);
+  const itemIndex = pathFrom[pathFrom.length - 1]; // has parent
+
+  if (pathFrom.length > 1) {
+    const parent = this.getItemByPath(pathFrom.slice(0, -1)); // is last (by order) item in array
+
+    if (itemIndex + 1 === parent[childrenProp].length) {
+      const pathTo = pathFrom.slice(0, -1);
+      pathTo[pathTo.length - 1] += 1; // if collapsed by default and is last (by count) item in array remove this node from list of open nodes
+
+      let collapseProps = {};
+
+      if (collapsed && parent[childrenProp].length === 1) {
+        collapseProps = this.onToggleCollapse(parent, true);
+      }
+
+      this.moveItem({
+        dragItem,
+        pathFrom,
+        pathTo
+      }, collapseProps);
+    }
+  }
+}
+
+export { tryDecreaseDepth };

package/{dist/esm → esm}/components/Nestable/actions/tryIncreaseDepth.js

@@ -1,22 +1,34 @@
-import * as React from "react";
 function tryIncreaseDepth(dragItem) {
-  const { maxDepth, childrenProp, collapsed } = this.props;
+  const {
+    maxDepth,
+    childrenProp,
+    collapsed
+  } = this.props;
   const pathFrom = this.getPathById(dragItem.id);
   const itemIndex = pathFrom[pathFrom.length - 1];
-  const newDepth = pathFrom.length + this.getItemDepth(dragItem);
+  const newDepth = pathFrom.length + this.getItemDepth(dragItem); // has previous sibling and isn't at max depth
+
   if (itemIndex > 0 && newDepth <= maxDepth) {
-    const prevSibling = this.getItemByPath(pathFrom.slice(0, -1).concat(itemIndex - 1));
+    const prevSibling = this.getItemByPath(pathFrom.slice(0, -1).concat(itemIndex - 1)); // previous sibling is not collapsed
+
     if (!prevSibling[childrenProp].length || !this.isCollapsed(prevSibling)) {
-      const pathTo = pathFrom.slice(0, -1).concat(itemIndex - 1).concat(prevSibling[childrenProp].length);
+      const pathTo = pathFrom.slice(0, -1).concat(itemIndex - 1).concat(prevSibling[childrenProp].length); // if collapsed by default
+      // and was no children here
+      // open this node
+
       let collapseProps = {};
+
       if (collapsed && !prevSibling[childrenProp].length) {
         collapseProps = this.onToggleCollapse(prevSibling, true);
       }
-      this.moveItem({ dragItem, pathFrom, pathTo }, collapseProps);
+
+      this.moveItem({
+        dragItem,
+        pathFrom,
+        pathTo
+      }, collapseProps);
     }
   }
 }
-export {
-  tryIncreaseDepth
-};
-//# sourceMappingURL=tryIncreaseDepth.js.map
+
+export { tryIncreaseDepth };

package/esm/components/Nestable/index.js

@@ -0,0 +1,2 @@
+import Nestable from './Nestable.js';
+export { default } from './Nestable.js';

package/esm/components/QueryBuilderContext/QueryBuilderContext.js

@@ -0,0 +1,5 @@
+import React from 'react';
+
+const QueryBuilderContext = /*#__PURE__*/React.createContext({});
+
+export { QueryBuilderContext };