@kineticdata/react 5.1.2 → 6.0.1

package/lib/components/task/builder/helpers.js

@@ -1,92 +1,107 @@
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import { isImmutable, List, Map, OrderedMap } from 'immutable';
-import { isObject } from 'lodash-es';
-import { Intersection, ShapeInfo } from 'kld-intersections';
-import * as constants from './constants';
-import { dispatch } from '../../../store';
-import { processErbTemplate, processRuby } from '../../common/code_input/languageHelpers';
-import { Node, Connector, NodeParameter, NodeResultDependency, NodeMessage, Point } from './models';
-import { NEW_TASK_DX, NEW_TASK_DY, NEW_TASK_GAP_REQUIED } from './constants';
-export var isIE11 = document.documentMode === 11;
-export var getRectIntersections = function getRectIntersections(_ref) {
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.treeReturnTask = exports.searchNodeResultDependencies = exports.replace = exports.renameDependencies = exports.parseNodeResultDependencies = exports.normalizeParameter = exports.isPointInNode = exports.isIE11 = exports.getRectIntersections = exports.getNodeType = exports.getNodeShape = exports.getNodeDependencies = exports.getNodeCenter = exports.getNewNodePosition = exports.getConnectorDependencies = exports.getAncestors = exports.buildBindings = exports.addNewTask = void 0;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectWithoutProperties"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _immutable = require("immutable");
+var _lodashEs = require("lodash-es");
+var _kldIntersections = require("kld-intersections");
+var constants = _interopRequireWildcard(require("./constants"));
+var _store = require("../../../store");
+var _languageHelpers = require("../../common/code_input/languageHelpers");
+var _models = require("./models");
+var _excluded = ["name", "id", "defaultValue"];
+var isIE11 = document.documentMode === 11;
+exports.isIE11 = isIE11;
+var getRectIntersections = function getRectIntersections(_ref) {
   var dragging = _ref.dragging,
-      head = _ref.head,
-      headType = _ref.headType,
-      tail = _ref.tail,
-      tailType = _ref.tailType;
+    head = _ref.head,
+    headType = _ref.headType,
+    tail = _ref.tail,
+    tailType = _ref.tailType;
   // Compute the points that make up the full path of the connector before
   // accounting for intersections. This will either be between the center of two
   // rects or from a dragging point to the center of a rect.
   var headCenter = dragging === 'head' ? head : getNodeCenter(headType, head);
-  var tailCenter = dragging === 'tail' ? tail : getNodeCenter(tailType, tail); // Loop connectors are special in that we just draw them from the center of
+  var tailCenter = dragging === 'tail' ? tail : getNodeCenter(tailType, tail);
+  // Loop connectors are special in that we just draw them from the center of
   // the two nodes rather than calculating the intersections and drawing from
   // there.
-
   if (tailType === 'loop-head' && headType === 'loop-tail') {
     return [tailCenter, headCenter];
-  } // Use kld-intersections to define the node shapes and connector lines used
+  }
+  // Use kld-intersections to define the node shapes and connector lines used
   // to determine the intersections
-
-
-  var line = ShapeInfo.line(tailCenter, headCenter);
+  var line = _kldIntersections.ShapeInfo.line(tailCenter, headCenter);
   var headShape = getNodeShape(headType, head);
   var tailShape = getNodeShape(tailType, tail);
-  var headIntersection = Intersection.intersect(headShape, line).points[0];
-  var tailIntersection = Intersection.intersect(tailShape, line).points[0];
+  var headIntersection = _kldIntersections.Intersection.intersect(headShape, line).points[0];
+  var tailIntersection = _kldIntersections.Intersection.intersect(tailShape, line).points[0];
   return [dragging === 'tail' ? tail : tailIntersection || tailCenter, dragging === 'head' ? head : headIntersection || headCenter];
 };
-export var isPointInNode = function isPointInNode(point) {
+exports.getRectIntersections = getRectIntersections;
+var isPointInNode = function isPointInNode(point) {
   return function (node) {
     return point && node && point.x >= node.position.x && point.x <= node.position.x + constants.NODE_WIDTH && point.y >= node.position.y && point.y <= node.position.y + constants.NODE_HEIGHT;
   };
 };
-export var getNodeType = function getNodeType(node) {
+exports.isPointInNode = isPointInNode;
+var getNodeType = function getNodeType(node) {
   return node ? node.definitionId.startsWith('system_join_v') ? 'join' : node.definitionId.startsWith('system_junction_v') ? 'junction' : node.definitionId.startsWith('system_loop_head_v') ? 'loop-head' : node.definitionId.startsWith('system_loop_tail_v') ? 'loop-tail' : node.definitionId.startsWith('system_start_v') ? 'start' : null : null;
 };
-export var getNodeShape = function getNodeShape(type, _ref2) {
+exports.getNodeType = getNodeType;
+var getNodeShape = function getNodeShape(type, _ref2) {
   var x = _ref2.x,
-      y = _ref2.y;
-  return type === 'start' ? ShapeInfo.circle(x + constants.NODE_START_RADIUS, y + constants.NODE_START_RADIUS, constants.NODE_START_RADIUS + constants.NODE_PADDING) : ShapeInfo.rectangle(x - constants.NODE_PADDING, y - constants.NODE_PADDING, constants.NODE_WIDTH + 2 * constants.NODE_PADDING, (type === 'join' || type === 'junction' ? constants.NODE_JOIN_JUNCTION_HEIGHT : constants.NODE_HEIGHT) + 2 * constants.NODE_PADDING);
+    y = _ref2.y;
+  return type === 'start' ? _kldIntersections.ShapeInfo.circle(x + constants.NODE_START_RADIUS, y + constants.NODE_START_RADIUS, constants.NODE_START_RADIUS + constants.NODE_PADDING) : _kldIntersections.ShapeInfo.rectangle(x - constants.NODE_PADDING, y - constants.NODE_PADDING, constants.NODE_WIDTH + 2 * constants.NODE_PADDING, (type === 'join' || type === 'junction' ? constants.NODE_JOIN_JUNCTION_HEIGHT : constants.NODE_HEIGHT) + 2 * constants.NODE_PADDING);
 };
-export var getNodeCenter = function getNodeCenter(type, _ref3) {
+exports.getNodeShape = getNodeShape;
+var getNodeCenter = function getNodeCenter(type, _ref3) {
   var x = _ref3.x,
-      y = _ref3.y;
+    y = _ref3.y;
   return {
     x: x + (type === 'start' ? constants.NODE_START_RADIUS : constants.NODE_CENTER_X),
     y: y + (type === 'start' ? constants.NODE_START_RADIUS : type === 'join' || type === 'junction' ? constants.NODE_JOIN_JUNCTION_CENTER_Y : constants.NODE_CENTER_Y)
   };
 };
-
+exports.getNodeCenter = getNodeCenter;
 var concatMap = function concatMap(map1, map2) {
   return map2.reduce(function (reduction, value, key) {
     return reduction.set(key, value);
   }, map1);
-}; // gets the parents for the given node by searching through the tree's
+};
+
+// gets the parents for the given node by searching through the tree's
 // connectors by `headId` then retrieving the parent nodes from the tree's node
 // map
-
-
 var getParents = function getParents(tree, node) {
   return tree.connectors.toList().filter(function (connector) {
     return connector.headId === node.id;
   }).map(function (connector) {
     return tree.nodes.get(connector.tailId);
   });
-}; // gets the ancestors for the given node by recursively traversing the parent
+};
+
+// gets the ancestors for the given node by recursively traversing the parent
 // nodes, as a map, the result should not contain duplicates and this processes
 // in depth-first order
-
-
-export var getAncestors = function getAncestors(tree, node) {
-  var result = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Map();
-  return (// get the direct parents of the node, adding them to the result and making
+var getAncestors = function getAncestors(tree, node) {
+  var result = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : (0, _immutable.Map)();
+  return (
+    // get the direct parents of the node, adding them to the result and making
     // recursive call from the parent if necessary
     getParents(tree, node).reduce(function (reduction, parent) {
-      return (// if the parent is already inside the result we do not want to re-add and
+      return (
+        // if the parent is already inside the result we do not want to re-add and
         // definitely do not want to make a recursive call
-        reduction.has(parent.id) ? reduction : // make the recursive call for ancestors from the parent node (making
+        reduction.has(parent.id) ? reduction :
+        // make the recursive call for ancestors from the parent node (making
         // sure to add it to the result map passed forward), then concat the
         // result of the recursive call with the our current reduction value (so
         // sibling recursive calls will not reprocess nodes already present)
@@ -94,66 +109,76 @@ export var getAncestors = function getAncestors(tree, node) {
       );
     }, result)
   );
-}; // recursive helper that calls bindify if the current raw value is an object
+};
+
+// recursive helper that calls bindify if the current raw value is an object
 // or returns the leaf value object if not (removing the erb tags at the same
 // time)
-
+exports.getAncestors = getAncestors;
 var bindify = function bindify(raw) {
-  return Map(raw).sortBy(function (_, key) {
+  return (0, _immutable.Map)(raw).sortBy(function (_, key) {
     return key;
   }).map(function (value) {
-    return isImmutable(value) ? value : isObject(value) ? Map({
+    return (0, _immutable.isImmutable)(value) ? value : (0, _lodashEs.isObject)(value) ? (0, _immutable.Map)({
       children: bindify(value)
-    }) : Map({
+    }) : (0, _immutable.Map)({
       value: value.replace(/^<%=(.*)%>$/, '$1')
     });
   });
 };
-
-export var buildBindings = function buildBindings(tree, tasks, node) {
-  var Results = Map({
-    children: tree.nodes // convert the node map to use the name as the key
+var buildBindings = function buildBindings(tree, tasks, node) {
+  var Results = (0, _immutable.Map)({
+    children: tree.nodes
+    // convert the node map to use the name as the key
     .mapKeys(function (_, node) {
       return node.name;
     }).sortBy(function (value, key) {
       return key;
-    }) // normalize the outputs / results property (routine / handler
+    })
+    // normalize the outputs / results property (routine / handler
     // respectively)
     .map(function (node) {
       var task = tasks.get(node.definitionId);
       return task && (task.results || task.outputs) || [];
-    }) // filter out any nodes that have no outputs / results
+    })
+    // filter out any nodes that have no outputs / results
     .filter(function (results) {
       return results.length > 0;
-    }) // convert the results list to the bindings map using the name property
+    })
+    // convert the results list to the bindings map using the name property
     // of each result object
     .map(function (results, nodeNode) {
-      return Map({
-        children: OrderedMap(results.map(function (result) {
-          return [result.name, Map({
+      return (0, _immutable.Map)({
+        children: (0, _immutable.OrderedMap)(results.map(function (result) {
+          return [result.name, (0, _immutable.Map)({
             value: "@results['".concat(nodeNode, "']['").concat(result.name, "']")
           })];
         }))
       });
     })
   });
-  return bindify(Results.get('children').isEmpty() ? tree.bindings : _objectSpread(_objectSpread({}, tree.bindings), {}, {
+  return bindify(Results.get('children').isEmpty() ? tree.bindings : (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, tree.bindings), {}, {
     Results: Results
   }));
-}; // implements the process of adding a new task node and connector to the tree,
+};
+
+// implements the process of adding a new task node and connector to the tree,
 // it curries some parameters that should be applied by the click event in the
 // parent node, then returns a function called selectTaskDefinition which the
 // should be called with a task definition, then it stubs out a node and
 // connector and passes a complete function which should be called with the
 // fully configured node and connector
-
-export var addNewTask = function addNewTask(treeKey, tree, parent, position) {
+exports.buildBindings = buildBindings;
+var addNewTask = function addNewTask(treeKey, tree, parent, position, reset) {
   return {
+    cancel: reset,
     tree: tree,
     selectCloneNode: function selectCloneNode(cloneNode) {
       return addNewTaskNext({
         cloneNode: cloneNode,
+        position: position,
         parent: parent,
+        reset: reset,
         tree: tree,
         treeKey: treeKey
       });
@@ -162,6 +187,7 @@ export var addNewTask = function addNewTask(treeKey, tree, parent, position) {
       return addNewTaskNext({
         parent: parent,
         position: position,
+        reset: reset,
         task: task,
         tree: tree,
         treeKey: treeKey
@@ -169,118 +195,121 @@ export var addNewTask = function addNewTask(treeKey, tree, parent, position) {
     }
   };
 };
-
+exports.addNewTask = addNewTask;
 var addNewTaskNext = function addNewTaskNext(_ref4) {
   var cloneNode = _ref4.cloneNode,
-      parent = _ref4.parent,
-      position = _ref4.position,
-      task = _ref4.task,
-      tree = _ref4.tree,
-      treeKey = _ref4.treeKey;
+    parent = _ref4.parent,
+    position = _ref4.position,
+    reset = _ref4.reset,
+    task = _ref4.task,
+    tree = _ref4.tree,
+    treeKey = _ref4.treeKey;
   var connectors = tree.connectors,
-      nextConnectorId = tree.nextConnectorId,
-      nextNodeId = tree.nextNodeId,
-      nodes = tree.nodes;
-  var definitionId = task ? task.definitionId : cloneNode.definitionId; // stub out the new connector and node, these will be provided via return and
+    nextConnectorId = tree.nextConnectorId,
+    nextNodeId = tree.nextNodeId,
+    nodes = tree.nodes;
+  var definitionId = task ? task.definitionId : cloneNode.definitionId;
+  // stub out the new connector and node, these will be provided via return and
   // are meant to be passed to <ConnectorForm> and <NodeForm> respectively to be
   // further configured by the consumer of the <TreeBuilder>
-
-  var connector = Connector({
+  var connector = (0, _models.Connector)({
     id: nextConnectorId,
     headId: nextNodeId,
     tailId: parent.id
   });
-  var node = Node({
+  var node = (0, _models.Node)({
     id: nextNodeId,
     position: position,
     deferrable: task ? task.deferrable : cloneNode.deferrable,
     defers: task ? task.deferrable : cloneNode.defers,
     definitionId: definitionId,
     visible: task ? task.visible : cloneNode.visible,
-    parameters: cloneNode ? cloneNode.parameters : List(task.parameters || task.inputs || []).map(normalizeParameter).map(NodeParameter),
-    messages: cloneNode ? cloneNode.messages : List(task.deferrable ? ['Create', 'Update', 'Complete'] : ['Complete']).map(function (type) {
-      return NodeMessage({
+    parameters: cloneNode ? cloneNode.parameters : (0, _immutable.List)(task.parameters || task.inputs || []).map(normalizeParameter).map(_models.NodeParameter),
+    messages: cloneNode ? cloneNode.messages : (0, _immutable.List)(task.deferrable ? ['Create', 'Update', 'Complete'] : ['Complete']).map(function (type) {
+      return (0, _models.NodeMessage)({
         type: type,
         value: ''
       });
     })
-  }); // add the stubbed connector and node to the current tree, this is done to
+  });
+  // add the stubbed connector and node to the current tree, this is done to
   // accommodate the <CodeInput> bindings helper in <ConnectorForm> and
   // <NodeForm>
-
   var stagedTree = tree.merge({
     connectors: connectors.set(connector.id, connector),
     nextConnectorId: nextConnectorId + 1,
     nextNodeId: nextNodeId + 1,
     nodes: nodes.set(node.id, node)
-  }); // return the pieces of data that will be passed to <ConnectorForm> and
+  });
+  // return the pieces of data that will be passed to <ConnectorForm> and
   // <NodeForm> instances and also pass a `complete` function that should be
   // called with the final connector and node records that are to be added to
   // the tree and persisted
-
   return {
+    cancel: reset,
     connector: connector,
     node: node,
     stagedTree: stagedTree,
     complete: function complete(_ref5) {
       var connector = _ref5.connector,
-          node = _ref5.node;
-      return dispatch('TREE_UPDATE', {
+        node = _ref5.node;
+      reset();
+      return (0, _store.dispatch)('TREE_UPDATE', {
         treeKey: treeKey,
         tree: stagedTree.setIn(['connectors', connector.id], connector).setIn(['nodes', node.id], node)
       });
     }
   };
-}; // regular expression that extracts the content from a string token which will
-// be wrapped with the various delimiters
+};
 
+// regular expression that extracts the content from a string token which will
+// be wrapped with the various delimiters
+var STRING_CONTENT_REGEX = /((?:%[qQiIwWxs]?)?.)(.*)(.)/;
 
-var STRING_CONTENT_REGEX = /((?:%[qQiIwWxs]?)?.)(.*)(.)/; // takes a erb / ruby strings and checks for references to @results['Node name']
+// takes a erb / ruby strings and checks for references to @results['Node name']
 // using the language helpers,
-
-export var parseNodeResultDependencies = function parseNodeResultDependencies(context, value, erb) {
-  return (erb ? processErbTemplate : processRuby)(value).reduce(function (_ref6, token) {
-    var _ref7 = _slicedToArray(_ref6, 4),
-        reduction = _ref7[0],
-        index = _ref7[1],
-        last1 = _ref7[2],
-        last2 = _ref7[3];
-
-    var _token = _slicedToArray(token, 2),
-        content = _token[0],
-        type = _token[1]; // if the current token is just whitespace we do not want to
+var parseNodeResultDependencies = function parseNodeResultDependencies(context, value, erb) {
+  return (erb ? _languageHelpers.processErbTemplate : _languageHelpers.processRuby)(value).reduce(function (_ref6, token) {
+    var _ref7 = (0, _slicedToArray2["default"])(_ref6, 4),
+      reduction = _ref7[0],
+      index = _ref7[1],
+      last1 = _ref7[2],
+      last2 = _ref7[3];
+    var _token = (0, _slicedToArray2["default"])(token, 2),
+      content = _token[0],
+      type = _token[1];
+    // if the current token is just whitespace we do not want to
     // change the last1, last2 values, just increment the index
-
-
     if ((type === undefined || type === 'erb') && content.match(/\s+/)) {
       return [reduction, index + content.length, last1, last2];
-    } // check to see if this token represents a node name dependency,
+    }
+    // check to see if this token represents a node name dependency,
     // if it is a string preceded by the [ punctuation preceded by the
     // @results variable
-
-
-    var match = type === 'string' && last1 && last1[0] === '[' && last1[1] === 'punctuation' && last2 && last2[0] === '@results' && last2[1] === 'variable' ? content.match(STRING_CONTENT_REGEX) : null; // if it matched then we add the string's contents to the reduction along
+    var match = type === 'string' && last1 && last1[0] === '[' && last1[1] === 'punctuation' && last2 && last2[0] === '@results' && last2[1] === 'variable' ? content.match(STRING_CONTENT_REGEX) : null;
+    // if it matched then we add the string's contents to the reduction along
     // with the index of the contents (using the first part of the match to
     // because there are different lengths of delimiters ", %^, %Q(, etc.)
-
-    var newReduction = match ? reduction.push(NodeResultDependency({
-      context: List(context),
+    var newReduction = match ? reduction.push((0, _models.NodeResultDependency)({
+      context: (0, _immutable.List)(context),
       name: match[2],
       index: index + match[1].length
     })) : reduction;
     return [newReduction, index + content.length, token, last1];
-  }, [List(), 0, null, null])[0];
+  }, [(0, _immutable.List)(), 0, null, null])[0];
 };
-export var getConnectorDependencies = function getConnectorDependencies(_ref8) {
+exports.parseNodeResultDependencies = parseNodeResultDependencies;
+var getConnectorDependencies = function getConnectorDependencies(_ref8) {
   var condition = _ref8.condition,
-      id = _ref8.id;
+    id = _ref8.id;
   return parseNodeResultDependencies(['connectors', id, 'condition'], condition);
 };
-export var getNodeDependencies = function getNodeDependencies(_ref9) {
+exports.getConnectorDependencies = getConnectorDependencies;
+var getNodeDependencies = function getNodeDependencies(_ref9) {
   var id = _ref9.id,
-      messages = _ref9.messages,
-      parameters = _ref9.parameters;
-  return List().concat(messages.flatMap(function (_ref10, i) {
+    messages = _ref9.messages,
+    parameters = _ref9.parameters;
+  return (0, _immutable.List)().concat(messages.flatMap(function (_ref10, i) {
     var value = _ref10.value;
     return parseNodeResultDependencies(['nodes', id, 'messages', i, 'value'], value, true);
   }), parameters.flatMap(function (_ref11, i) {
@@ -288,25 +317,30 @@ export var getNodeDependencies = function getNodeDependencies(_ref9) {
     return parseNodeResultDependencies(['nodes', id, 'parameters', i, 'value'], value, true);
   }));
 };
-export var searchNodeResultDependencies = function searchNodeResultDependencies(tree, nodeName) {
-  return List().concat(tree.connectors.toList().flatMap(getConnectorDependencies), tree.nodes.toList().flatMap(getNodeDependencies)).filter(function (dependency) {
+exports.getNodeDependencies = getNodeDependencies;
+var searchNodeResultDependencies = function searchNodeResultDependencies(tree, nodeName) {
+  return (0, _immutable.List)().concat(tree.connectors.toList().flatMap(getConnectorDependencies), tree.nodes.toList().flatMap(getNodeDependencies)).filter(function (dependency) {
     return dependency.name === nodeName;
   });
-}; // helper function that curries the dependency record and the new node name and
+};
+
+// helper function that curries the dependency record and the new node name and
 // then it takes the value and it splices the new node name into the value at
 // the index defined in the dependency record also using the length of the old
 // name in the dependency record
-
-export var replace = function replace(dependency, newName) {
+exports.searchNodeResultDependencies = searchNodeResultDependencies;
+var replace = function replace(dependency, newName) {
   return function (value) {
     return value.slice(0, dependency.index) + newName + value.slice(dependency.index + dependency.name.length);
   };
 };
-export var renameDependencies = function renameDependencies() {
-  var dependencies = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : List();
+exports.replace = replace;
+var renameDependencies = function renameDependencies() {
+  var dependencies = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _immutable.List)();
   var newName = arguments.length > 1 ? arguments[1] : undefined;
   return function (tree) {
-    return dependencies // sort the dependencies by index and reverse so that replacements made in
+    return dependencies
+    // sort the dependencies by index and reverse so that replacements made in
     // the same value will not affect each other (renaming Fooo to Foo would
     // change the index of following dependencies)
     .sortBy(function (dep) {
@@ -315,23 +349,25 @@ export var renameDependencies = function renameDependencies() {
       return tree.updateIn(dependency.context, replace(dependency, newName));
     }, tree);
   };
-}; // routines have `inputs` and handlers have `parameters` with slightly different
+};
+
+// routines have `inputs` and handlers have `parameters` with slightly different
 // properties so this is a helper function to take one or the other and return
 // a consistent object
-
-export var normalizeParameter = function normalizeParameter(_ref12) {
+exports.renameDependencies = renameDependencies;
+var normalizeParameter = function normalizeParameter(_ref12) {
   var name = _ref12.name,
-      id = _ref12.id,
-      defaultValue = _ref12.defaultValue,
-      rest = _objectWithoutProperties(_ref12, ["name", "id", "defaultValue"]);
-
-  return _objectSpread({
+    id = _ref12.id,
+    defaultValue = _ref12.defaultValue,
+    rest = (0, _objectWithoutProperties2["default"])(_ref12, _excluded);
+  return (0, _objectSpread2["default"])({
     id: id || name,
     label: name,
     value: defaultValue
   }, rest);
 };
-var defaultOutputs = List([{
+exports.normalizeParameter = normalizeParameter;
+var defaultOutputs = (0, _immutable.List)([{
   id: 'content',
   name: 'Content'
 }, {
@@ -346,8 +382,8 @@ var defaultOutputs = List([{
   id: 'response_code',
   name: 'Response Code',
   defaultValue: '200'
-}]).map(Map);
-export var treeReturnTask = function treeReturnTask(tree) {
+}]).map(_immutable.Map);
+var treeReturnTask = function treeReturnTask(tree) {
   return {
     deferrable: false,
     definitionId: 'system_tree_return_v1',
@@ -375,46 +411,21 @@ export var treeReturnTask = function treeReturnTask(tree) {
     results: []
   };
 };
-export var getNewNodePosition = function getNewNodePosition(node, childNodes) {
+exports.treeReturnTask = treeReturnTask;
+var getNewNodePosition = function getNewNodePosition(node, childNodes) {
   if (childNodes.length === 0) {
-    return node.position.update('y', function (y) {
-      return y + NEW_TASK_DY;
-    });
-  } else if (childNodes.length === 1) {
-    return childNodes[0].position.update('x', function (x) {
-      return x + NEW_TASK_DX;
+    return node.position.update('x', function (x) {
+      return x + constants.NEW_TASK_DX;
     });
   } else {
-    var sortedChildren = List(childNodes).sortBy(function (node) {
-      return node.position.x;
+    var maxChild = (0, _immutable.List)(childNodes).sortBy(function (node) {
+      return node.position.y;
+    }).maxBy(function (node) {
+      return node.position.y;
+    });
+    return maxChild.position.update('y', function (y) {
+      return y + constants.NEW_TASK_DY;
     });
-    var betweenNodes = sortedChildren.skip(2) // build a list of adjacent pairs of nodes
-    .reduce(function (reduction, child) {
-      return reduction.push([reduction.last()[1], child]);
-    }, List.of([sortedChildren.first(), sortedChildren.get(1)])) // filter out pairs of nodes that don't have enough space between them
-    // for a new node
-    .filter(function (_ref13) {
-      var _ref14 = _slicedToArray(_ref13, 2),
-          left = _ref14[0],
-          right = _ref14[1];
-
-      return right.position.x - left.position.x >= NEW_TASK_GAP_REQUIED;
-    }) // use the first pair of nodes with a large enough space between them
-    .first();
-
-    if (betweenNodes) {
-      var _betweenNodes = _slicedToArray(betweenNodes, 2),
-          left = _betweenNodes[0],
-          right = _betweenNodes[1];
-
-      return Point({
-        x: (left.position.x + right.position.x) / 2,
-        y: (left.position.y + right.position.y) / 2
-      });
-    } else {
-      return sortedChildren.last().position.update('x', function (x) {
-        return x + NEW_TASK_DX;
-      });
-    }
   }
-};
+};
+exports.getNewNodePosition = getNewNodePosition;