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

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

@@ -0,0 +1,124 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.async-iterator.every.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.every.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+
+function getRealNextPath(prevPath, nextPath) {
+  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') {
+        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;
+  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;
+  let item = null;
+  path.forEach(index => {
+    const list = item ? item[childrenProp] : items;
+    item = list[index];
+  });
+  return item;
+}
+function getItemDepth(item) {
+  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) {
+  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, ...itemsToInsert]];
+    } else {
+      const nextPath = {};
+      currentPath[index] = {
+        [options.childrenProp]: nextPath
+      };
+      currentPath = nextPath;
+    }
+  });
+  return splicePath;
+}
+
+exports.getItemByPath = getItemByPath;
+exports.getItemDepth = getItemDepth;
+exports.getPathById = getPathById;
+exports.getRealNextPath = getRealNextPath;
+exports.getSplicePath = getSplicePath;

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

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tryIncreaseDepth = require('./tryIncreaseDepth.js');
+var tryDecreaseDepth = require('./tryDecreaseDepth.js');
+var moveItem = require('./moveItem.js');
+var paths = require('./paths.js');
+var events = require('./events.js');
+var getItemOptions = require('./getItemOptions.js');
+
+
+
+exports.tryIncreaseDepth = tryIncreaseDepth.tryIncreaseDepth;
+exports.tryDecreaseDepth = tryDecreaseDepth.tryDecreaseDepth;
+exports.moveItem = moveItem.moveItem;
+exports.getItemByPath = paths.getItemByPath;
+exports.getItemDepth = paths.getItemDepth;
+exports.getPathById = paths.getPathById;
+exports.getRealNextPath = paths.getRealNextPath;
+exports.getSplicePath = paths.getSplicePath;
+exports.onDragEnd = events.onDragEnd;
+exports.onDragStart = events.onDragStart;
+exports.onKeyDown = events.onKeyDown;
+exports.onMouseEnter = events.onMouseEnter;
+exports.onMouseMove = events.onMouseMove;
+exports.onToggleCollapse = events.onToggleCollapse;
+exports.getItemOptions = getItemOptions.getItemOptions;

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

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.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 _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var update = require('react-addons-update');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var update__default = /*#__PURE__*/_interopDefaultLegacy(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__default["default"](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__default["default"](items, removePath);
+  items = update__default["default"](items, insertPath);
+  this.setState(_objectSpread({
+    items,
+    isDirty: true
+  }, extraProps));
+}
+
+exports.moveItem = moveItem;

package/cjs/components/Nestable/actions/paths.js

@@ -0,0 +1,126 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.async-iterator.every.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.every.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+
+function getRealNextPath(prevPath, nextPath) {
+  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') {
+        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) {
+  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) {
+  let items = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getDefaultItems();
+  const {
+    childrenProp
+  } = this.props;
+  let item = null;
+  path.forEach(index => {
+    const list = item ? item[childrenProp] : items;
+    item = list[index];
+  });
+  return item;
+}
+function getItemDepth(item) {
+  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) {
+  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, ...itemsToInsert]];
+    } else {
+      const nextPath = {};
+      currentPath[index] = {
+        [options.childrenProp]: nextPath
+      };
+      currentPath = nextPath;
+    }
+  });
+  return splicePath;
+}
+
+exports.getItemByPath = getItemByPath;
+exports.getItemDepth = getItemDepth;
+exports.getPathById = getPathById;
+exports.getRealNextPath = getRealNextPath;
+exports.getSplicePath = getSplicePath;

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

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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);
+    }
+  }
+}
+
+exports.tryDecreaseDepth = tryDecreaseDepth;

package/cjs/components/Nestable/actions/tryIncreaseDepth.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function tryIncreaseDepth(dragItem) {
+  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); // 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)); // 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); // 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);
+    }
+  }
+}
+
+exports.tryIncreaseDepth = tryIncreaseDepth;

package/cjs/components/Nestable/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var Nestable = require('./Nestable.js');
+
+
+
+module.exports = Nestable;

package/cjs/components/QueryBuilderContext/QueryBuilderContext.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const QueryBuilderContext = /*#__PURE__*/React__default["default"].createContext({});
+
+exports.QueryBuilderContext = QueryBuilderContext;