react-dataflow/dist/Sequences/Classical.js

A dataflow execution format for React.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var Classical =
/*#__PURE__*/
function () {
  function Classical(signals, elements) {
    _classCallCheck(this, Classical);

    // TODO: Should *not* rely on stringifying; should instead use immutable's builtin.
    this.signals = Object.freeze(JSON.parse(JSON.stringify(signals)));
    this.elements = Object.freeze(JSON.parse(JSON.stringify(elements)));
  }

  _createClass(Classical, [{
    key: "executeSequence",
    value: function executeSequence(pendingWires, pendingNodes) {
      var completedWires = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
      var completedNodes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
      var phases = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];

      if (Object.keys(pendingWires).length === 0 && pendingNodes.length === 0) {
        return phases;
      }

      var phase = this.getNextPhase(completedWires, completedNodes, pendingWires, pendingNodes);
      var elements = phase.elements,
          wires = phase.wires;
      return this.executeSequence(Object.entries(pendingWires).filter(function (_ref) {
        var _ref2 = _slicedToArray(_ref, 2),
            k = _ref2[0],
            v = _ref2[1];

        return Object.keys(wires).indexOf(k) < 0;
      }).reduce(function (obj, _ref3) {
        var _ref4 = _slicedToArray(_ref3, 2),
            k = _ref4[0],
            v = _ref4[1];

        return _objectSpread({}, obj, _defineProperty({}, k, v));
      }, {}), pendingNodes.filter(function (k) {
        return elements.indexOf(k) < 0;
      }), _objectSpread({}, completedWires, {}, wires), [].concat(_toConsumableArray(completedNodes), _toConsumableArray(elements)), [].concat(_toConsumableArray(phases), [phase]));
    }
  }, {
    key: "getNextPhase",
    value: function getNextPhase(completedWires, completedNodes, pendingWires, pendingNodes) {
      var nextNodes = pendingNodes.filter(function (node) {
        var wireDependencies = Object.entries(pendingWires).filter(function (_ref5) {
          var _ref6 = _slicedToArray(_ref5, 2),
              k = _ref6[0],
              signalOut = _ref6[1].signalOut;

          return Object.keys(signalOut).indexOf(node) >= 0;
        });
        return wireDependencies.length <= 0;
      });
      var nextCompletedNodes = [].concat(_toConsumableArray(completedNodes), _toConsumableArray(nextNodes));
      var nextWires = Object.entries(pendingWires).filter(function (_ref7) {
        var _ref8 = _slicedToArray(_ref7, 2),
            k = _ref8[0],
            signalIn = _ref8[1].signalIn;

        return Object.keys(signalIn).filter(function (nodeId) {
          return nextCompletedNodes.indexOf(nodeId) < 0;
        }).length === 0;
      }).reduce(function (obj, _ref9) {
        var _ref10 = _slicedToArray(_ref9, 2),
            k = _ref10[0],
            v = _ref10[1];

        return _objectSpread({}, obj, _defineProperty({}, k, v));
      }, {});
      return {
        elements: nextNodes,
        wires: nextWires
      };
    }
  }, {
    key: "getPhases",
    value: function getPhases() {
      return this.executeSequence(this.__getSignals(), this.__getElements());
    }
  }, {
    key: "__getSignals",
    value: function __getSignals() {
      return this.signals;
    }
  }, {
    key: "__getElements",
    value: function __getElements() {
      return this.elements;
    }
  }]);

  return Classical;
}();

exports["default"] = Classical;