function-tree/es/executeTree.js

When a function is not enough

import { FunctionTreeExecutionError } from './errors';
function isPrimitive(primitive, type) {
  return (primitive === null || primitive === void 0 ? void 0 : primitive._functionTreePrimitive) && primitive.type === type;
}

/*
  Runs through the tree providing a "next" callback to process next step
  of execution
*/
export default function executeTree(execution, initialPayload, executeBranchWrapper, branchStart, branchEnd, parallelStart, parallelProgress, parallelEnd, end) {
  function runBranch(branch, index, payload, prevPayload, nextBranch) {
    executeBranchWrapper(function () {
      function runNextItem(result) {
        runBranch(branch, index + 1, result, payload, nextBranch);
      }
      function processFunctionOutput(funcDetails, outputResult) {
        return function (result) {
          var newPayload = Object.assign({}, payload, result ? result.payload : {});
          if (result && funcDetails.outputs) {
            var outputs = Object.keys(funcDetails.outputs);
            if (~outputs.indexOf(result.path)) {
              branchStart(funcDetails, result.path, newPayload);
              var outputBranch = funcDetails.outputs[result.path];

              // Check if the output branch itself is a parallel primitive
              if (isPrimitive(outputBranch, 'parallel')) {
                runBranch([outputBranch], 0, newPayload, payload, outputResult);
              } else {
                runBranch(outputBranch.items, 0, newPayload, payload, outputResult);
              }
            } else {
              throw new FunctionTreeExecutionError(execution, funcDetails, payload, "function ".concat(funcDetails.name, " must use one of its possible outputs: ").concat(outputs.join(', '), "."));
            }
          } else {
            outputResult(newPayload);
          }
        };
      }
      var currentItem = branch[index];
      if (!currentItem) {
        if (branch !== execution.staticTree) {
          branchEnd(payload);
        }
        nextBranch(payload);
      } else if (isPrimitive(currentItem, 'sequence')) {
        runBranch(currentItem.items, 0, payload, prevPayload, runNextItem);
      } else if (isPrimitive(currentItem, 'parallel')) {
        var itemLength = currentItem.items.length;
        var payloads = [];
        parallelStart(payload, itemLength);
        currentItem.items.forEach(function (func) {
          if (func["function"]) {
            execution.runFunction(func, payload, prevPayload, processFunctionOutput(func, function (payload) {
              payloads.push(payload);
              if (payloads.length === itemLength) {
                parallelEnd(payload, itemLength);
                runNextItem(Object.assign.apply(Object, [{}].concat(payloads)));
              } else {
                parallelProgress(payload, itemLength - payloads.length);
              }
            }));
          } else {
            runBranch(func.items, 0, payload, prevPayload, function (payload) {
              payloads.push(payload);
              if (payloads.length === itemLength) {
                parallelEnd(payload, itemLength);
                runNextItem(Object.assign.apply(Object, [{}].concat(payloads)));
              } else {
                parallelProgress(payload, itemLength - payloads.length);
              }
            });
          }
          return payloads;
        });
      } else {
        execution.runFunction(currentItem, payload, prevPayload, processFunctionOutput(currentItem, runNextItem));
      }
    });
  }
  runBranch([execution.staticTree], 0, initialPayload, null, end);
}
//# sourceMappingURL=executeTree.js.map