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

package/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

@@ -1,22 +1,31 @@
-import * as React from "react";
 function tryDecreaseDepth(dragItem) {
-  const { childrenProp, collapsed } = this.props;
+  const {
+    childrenProp,
+    collapsed
+  } = this.props;
   const pathFrom = this.getPathById(dragItem.id);
-  const itemIndex = pathFrom[pathFrom.length - 1];
+  const itemIndex = pathFrom[pathFrom.length - 1]; // has parent
+
   if (pathFrom.length > 1) {
-    const parent = this.getItemByPath(pathFrom.slice(0, -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;
+      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);
+
+      this.moveItem({
+        dragItem,
+        pathFrom,
+        pathTo
+      }, collapseProps);
     }
   }
 }
-export {
-  tryDecreaseDepth
-};
-//# sourceMappingURL=tryDecreaseDepth.js.map
+
+export { tryDecreaseDepth };

package/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

@@ -1,7 +1,2 @@
-import * as React from "react";
-import Nestable from "./Nestable";
-var Nestable_default = Nestable;
-export {
-  Nestable_default as default
-};
-//# sourceMappingURL=index.js.map
+import Nestable from './Nestable.js';
+export { default } from './Nestable.js';

package/esm/components/QueryBuilderContext/QueryBuilderContext.js

@@ -1,7 +1,5 @@
-import * as React from "react";
-import React2 from "react";
-const QueryBuilderContext = React2.createContext({});
-export {
-  QueryBuilderContext
-};
-//# sourceMappingURL=QueryBuilderContext.js.map
+import React from 'react';
+
+const QueryBuilderContext = /*#__PURE__*/React.createContext({});
+
+export { QueryBuilderContext };

package/esm/components/QueryBuilderImpl.js

@@ -1,127 +1,231 @@
-import * as React from "react";
-import React2, { Component } from "react";
-import Nestable from "./Nestable";
-import { QueryBuilderContext } from "./QueryBuilderContext/QueryBuilderContext";
-import { QB_DRAG_TYPES, QB_ADD_FILTER_METHOD_TYPES, QB_GROUP_FILTER_METHOD_TYPES } from "./helpers/types";
-import QueryBuilderStore from "./helpers/store";
-import AndOrController from "./AndOrController/AndOrController";
-import QueryBuilderItem from "./QueryBuilderItem/QueryBuilderItem";
-import DisplayOutput from "./DisplayOutput/DisplayOutput";
+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 _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { Component } from 'react';
+import Nestable from './Nestable/Nestable.js';
+import { QueryBuilderContext } from './QueryBuilderContext/QueryBuilderContext.js';
+import { QB_ADD_FILTER_METHOD_TYPES, QB_GROUP_FILTER_METHOD_TYPES, QB_DRAG_TYPES } from './helpers/types.js';
+import QueryBuilderStore from './helpers/store.js';
+import AndOrController from './AndOrController/AndOrController.js';
+import QueryBuilderItem from './QueryBuilderItem/QueryBuilderItem.js';
+import DisplayOutput from './DisplayOutput/DisplayOutput.js';
+import { jsxs } from 'react/jsx-runtime';
+
+const _excluded = ["format"];
+
+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; }
+
 class QueryBuilderImpl extends Component {
   constructor(props) {
     super(props);
     this.isDraggableItem = true;
+
     this.onOrderDragAndDrop = (items, item) => {
       const newFilters = this.store.onOrderDragAndDrop(items, item);
-      this.sendCall("reOrderOnDragAndDrop", { items });
+      this.sendCall('reOrderOnDragAndDrop', {
+        items
+      });
       this.sendChange(newFilters);
     };
-    this.onAddFilterToGroup = (idGroup) => {
+
+    this.onAddFilterToGroup = idGroup => {
       const newFilters = this.store.addFilter(idGroup);
-      this.sendCall("onAddFilterToGroup", { idGroup });
+      this.sendCall('onAddFilterToGroup', {
+        idGroup
+      });
       this.sendChange(newFilters);
     };
+
     this.onAddFilter = (idGroup, idFilter) => {
-      const { addFilterMethod } = this.props;
+      const {
+        addFilterMethod
+      } = this.props;
       const newFilters = addFilterMethod === QB_ADD_FILTER_METHOD_TYPES.IN_PLACE ? this.store.addFilterNextToFilterId(idGroup, idFilter) : this.onAddFilterToGroup(idGroup);
-      this.sendCall("onAddFilter", { idGroup, idFilter });
+      this.sendCall('onAddFilter', {
+        idGroup,
+        idFilter
+      });
       this.sendChange(newFilters);
     };
+
     this.onAddRuleContainer = (idGroup, idFilter) => {
-      const { groupFilterMethod } = this.props;
+      const {
+        groupFilterMethod
+      } = this.props;
       const newFilters = groupFilterMethod === QB_GROUP_FILTER_METHOD_TYPES.IN_PLACE ? this.store.addRuleContainerInPlace(idGroup, idFilter) : this.store.addRuleContainer(idGroup, idFilter);
-      this.sendCall("onAddRuleContainer", { idGroup, idFilter });
+      this.sendCall('onAddRuleContainer', {
+        idGroup,
+        idFilter
+      });
       this.sendChange(newFilters);
     };
-    this.onRemoveFilter = (idFilter) => {
+
+    this.onRemoveFilter = idFilter => {
       const newFilters = this.store.onRemoveFilter(idFilter);
-      this.sendCall("onRemoveFilter", { idFilter });
+      this.sendCall('onRemoveFilter', {
+        idFilter
+      });
       this.sendChange(newFilters);
     };
-    this.handleFieldChange = (data) => {
-      const { fieldsSharedActions } = this.props;
-      const newFilters = this.store.changeFilter({
-        ...data,
+
+    this.handleFieldChange = data => {
+      const {
+        fieldsSharedActions
+      } = this.props;
+      const newFilters = this.store.changeFilter(_objectSpread(_objectSpread({}, data), {}, {
         fieldsSharedActions
+      }));
+      this.sendCall('handleFieldChange', {
+        data
       });
-      this.sendCall("handleFieldChange", { data });
       this.sendChange(newFilters);
     };
+
     this.handleRuleContainerOperator = (idGroup, value) => {
       const newFilters = this.store.changeGroupOperator(idGroup, value);
-      this.sendCall("handleRuleContainerOperator", { idGroup, value });
+      this.sendCall('handleRuleContainerOperator', {
+        idGroup,
+        value
+      });
       this.sendChange(newFilters);
     };
-    this.handleRuleContainerUnGroup = (idGroup) => {
+
+    this.handleRuleContainerUnGroup = idGroup => {
       const newFilters = this.store.unGroup(idGroup);
-      this.sendCall("handleRuleContainerUnGroup", { idGroup });
+      this.sendCall('handleRuleContainerUnGroup', {
+        idGroup
+      });
       this.sendChange(newFilters);
     };
+
     this.handleDropFilter = (filter, dragTo) => {
-      const { position: oldPosition, idGroup, idFilter } = filter;
-      const { position: newPosition, targetIdGroup } = dragTo;
+      const {
+        position: oldPosition,
+        idGroup,
+        idFilter
+      } = filter;
+      const {
+        position: newPosition,
+        targetIdGroup
+      } = dragTo;
       const newFilters = this.store.reOrderFilter(idFilter, idGroup, oldPosition, newPosition, targetIdGroup);
-      this.sendCall("handleDropFilter", { filter, dragTo });
+      this.sendCall('handleDropFilter', {
+        filter,
+        dragTo
+      });
       this.sendChange(newFilters);
     };
+
     this.handleDropGroup = (group, dragTo) => {
-      const { position: oldPosition, idFilter, idGroup } = group;
-      const { position: newPosition, targetIdGroup } = dragTo;
+      const {
+        position: oldPosition,
+        idFilter,
+        idGroup
+      } = group;
+      const {
+        position: newPosition,
+        targetIdGroup
+      } = dragTo;
       const newFilters = this.store.reOrderFilter(idFilter, idGroup, oldPosition, newPosition, targetIdGroup);
-      this.sendCall("handleDropGroup", { group, dragTo });
+      this.sendCall('handleDropGroup', {
+        group,
+        dragTo
+      });
       this.sendChange(newFilters);
     };
+
     this.handleDrop = (dragElement, dragTo) => {
-      const { type } = dragElement;
-      if (type === QB_DRAG_TYPES.FILTER)
-        return this.handleDropFilter(dragElement, dragTo);
+      const {
+        type
+      } = dragElement;
+      if (type === QB_DRAG_TYPES.FILTER) return this.handleDropFilter(dragElement, dragTo);
       return this.handleDropGroup(dragElement, dragTo);
     };
-    this.sendChange = ({ format, ...newFilters }) => {
-      this.setState({ format, ...newFilters });
-      const { onChange } = this.props;
+
+    this.sendChange = _ref => {
+      let {
+        format
+      } = _ref,
+          newFilters = _objectWithoutProperties(_ref, _excluded);
+
+      this.setState(_objectSpread({
+        format
+      }, newFilters));
+      const {
+        onChange
+      } = this.props;
       onChange(format, newFilters);
     };
+
     this.sendCall = (action, data) => {
-      const { [action]: callback } = this.props;
-      if (callback)
-        callback(data);
+      const {
+        [action]: callback
+      } = this.props;
+      if (callback) callback(data);
     };
-    this.setDraggableItems = (drag) => {
+
+    this.setDraggableItems = drag => {
       this.isDraggableItem = true;
+
       try {
         const ua = window.navigator.userAgent;
-        const msie = ua.indexOf("MSIE ");
+        const msie = ua.indexOf('MSIE '); // eslint-disable-next-line no-useless-escape
+
         if (msie > 0 || !!navigator.userAgent.match(/Trident.*rv\:11\./)) {
-          const { isDraggableItem } = this.state;
+          const {
+            isDraggableItem
+          } = this.state;
+
           if (drag !== isDraggableItem) {
-            this.setState({ isDraggableItem: drag });
+            this.setState({
+              isDraggableItem: drag
+            });
           }
+
           this.isDraggableItem = drag;
         }
       } catch (error) {
         this.isDraggableItem = true;
       }
     };
+
     this.store = new QueryBuilderStore(props.init, props.format);
     this.state = this.store.getInitialState();
   }
+
   static getDerivedStateFromProps(props, state) {
-    if (props.init && props.init.step !== void 0 && Number.isInteger(props.init.step) && props.init.step !== state.step) {
+    if (props.init && props.init.step !== undefined && Number.isInteger(props.init.step) && props.init.step !== state.step) {
       const store = new QueryBuilderStore(props.init, props.format);
       QueryBuilderImpl.recalculateStore = store;
       return store.getInitialState();
     }
+
     return null;
   }
+
   componentDidUpdate() {
     if (QueryBuilderImpl.recalculateStore) {
       this.store = QueryBuilderImpl.recalculateStore;
       QueryBuilderImpl.recalculateStore = null;
     }
   }
+
   render() {
-    const { mapGroups, main, mapFilters, step, items, format } = this.state;
+    const {
+      mapGroups,
+      main,
+      mapFilters,
+      step,
+      items,
+      format
+    } = this.state;
     const {
       containerProps,
       ruleContainerClassName,
@@ -131,9 +235,12 @@ class QueryBuilderImpl extends Component {
       displayOutputLabel,
       singleRow,
       toolTipZIndex
-    } = this.props;
-    const { condition } = mapGroups[main];
-    return /* @__PURE__ */ React2.createElement(QueryBuilderContext.Provider, {
+    } = this.props; // const { children } = items[0]
+
+    const {
+      condition
+    } = mapGroups[main];
+    return /*#__PURE__*/_jsx(QueryBuilderContext.Provider, {
       value: {
         toolTipZIndex,
         fields,
@@ -156,41 +263,39 @@ class QueryBuilderImpl extends Component {
         setDraggableItems: this.setDraggableItems,
         singleRow
       }
-    }, /* @__PURE__ */ React2.createElement("div", {
-      ...containerProps,
-      className: `nested-main-group ${condition !== true ? "is-or-group" : "is-and-groupL"} ${singleRow ? "query-main-single-row" : "query-main-multiple-row"}`
-    }, /* @__PURE__ */ React2.createElement(Nestable, {
-      isAndItem: condition === true,
-      isDraggableItem: this.isDraggableItem,
-      isOrItem: condition !== true,
-      items,
-      onChange: this.onOrderDragAndDrop,
-      renderItem: QueryBuilderItem,
-      setDraggableItems: this.setDraggableItems,
-      step,
-      singleRow
-    }), !singleRow && /* @__PURE__ */ React2.createElement("div", {
-      className: "rule-container-options"
-    }, /* @__PURE__ */ React2.createElement(AndOrController, {
-      allowUnGroup: false,
-      condition,
-      handleRuleContainerOperator: (value) => this.handleRuleContainerOperator(main, value),
-      handleRuleContainerUnGroup: () => this.handleRuleContainerUnGroup(main),
-      isMain: true,
-      onAddFilter: () => this.onAddFilterToGroup(main),
-      showDragController: false,
-      step,
-      toolTipZIndex
-    }))), (displayOutput || displayFixedOutput) && /* @__PURE__ */ React2.createElement(DisplayOutput, {
-      displayFixedOutput,
+    }, void 0, /*#__PURE__*/jsxs("div", _objectSpread(_objectSpread({}, containerProps), {}, {
+      className: "nested-main-group ".concat(condition !== true ? 'is-or-group' : 'is-and-groupL', " ").concat(singleRow ? 'query-main-single-row' : 'query-main-multiple-row'),
+      children: [/*#__PURE__*/_jsx(Nestable, {
+        isAndItem: condition === true,
+        isDraggableItem: this.isDraggableItem,
+        isOrItem: condition !== true,
+        items: items,
+        onChange: this.onOrderDragAndDrop,
+        renderItem: QueryBuilderItem,
+        setDraggableItems: this.setDraggableItems,
+        step: step,
+        singleRow: singleRow
+      }), !singleRow && /*#__PURE__*/_jsx("div", {
+        className: "rule-container-options"
+      }, void 0, /*#__PURE__*/_jsx(AndOrController, {
+        allowUnGroup: false,
+        condition: condition,
+        handleRuleContainerOperator: value => this.handleRuleContainerOperator(main, value),
+        handleRuleContainerUnGroup: () => this.handleRuleContainerUnGroup(main),
+        isMain: true,
+        onAddFilter: () => this.onAddFilterToGroup(main),
+        showDragController: false,
+        step: step,
+        toolTipZIndex: toolTipZIndex
+      }))]
+    })), (displayOutput || displayFixedOutput) && /*#__PURE__*/_jsx(DisplayOutput, {
+      displayFixedOutput: displayFixedOutput,
       hideLabel: displayOutputLabel.hide,
       showLabel: displayOutputLabel.show,
       show: displayOutputLabel.open
     }));
   }
+
 }
-var QueryBuilderImpl_default = QueryBuilderImpl;
-export {
-  QueryBuilderImpl_default as default
-};
-//# sourceMappingURL=QueryBuilderImpl.js.map
+
+export { QueryBuilderImpl as default };