maycur-business/lib/utils/associationSort.js

maycur business react components of web

"use strict";

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

var _lodash = _interopRequireDefault(require("lodash"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

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

var AssociationSort = function AssociationSort() {
  var _this = this;

  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  _classCallCheck(this, AssociationSort);

  this.buildGraph = function (associationFields) {
    var associationFieldsIdentifier = _lodash["default"].map(associationFields, 'identifier');

    _lodash["default"].each(associationFields, function (field) {
      var _cascadeDataRelations = _lodash["default"].remove(field.cascadeDataRelations, function (item) {
        return associationFieldsIdentifier.includes(item.value);
      });

      var cascadeFieldsLength = _cascadeDataRelations.length || 0;
      var _cascadeFields = [];

      for (var i = 0; i < cascadeFieldsLength; i++) {
        // 若数据互联依赖了数据互联之外的其他组件，则不考虑在内
        if (associationFieldsIdentifier.includes(_cascadeDataRelations[i].value)) {
          _cascadeFields.push(_cascadeDataRelations[i]);
        }
      }

      field.cascadeDataRelations = _cascadeDataRelations;

      if (_cascadeFields.length) {
        _this.surplusArr.push(field);
      } else {
        _this.noDependArr.push(field);
      }
    });

    _this.sortCascade();
  };

  this.sortCascade = function () {
    var _loop = function _loop() {
      var identifiers = _lodash["default"].map(_this.noDependArr, 'identifier');

      if (_this.noDependArr.length) {
        // 将无依赖的数组放入 sortedList 中
        _this.sortedList.push(_this.noDependArr);

        _this.noDependArr = [];
      } // 对于入度不为0的顶点，将n从他们的依赖中删除，如果删除后入度为0，则将其添加到noDependArr中


      for (var i = 0; i < _this.surplusArr.length; i++) {
        var cascadeDataRelations = _this.surplusArr[i].cascadeDataRelations; // 在 cascadeDataRelations 中删除依赖了 noDependArr 的 item

        _lodash["default"].remove(cascadeDataRelations, function (item) {
          return identifiers.includes(item.value);
        }); // 删除后若无依赖，则放入 noDependArr 中


        if (!cascadeDataRelations.length) {
          _this.noDependArr.push(_this.surplusArr[i]);

          _this.surplusArr.splice(i, 1);

          i--;
        }
      }
    };

    while (_this.noDependArr.length) {
      _loop();
    }
  };

  this.traversalSortedList =
  /*#__PURE__*/
  function () {
    var _ref = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee(getAssociationFieldDefaultValue) {
      var i;
      return regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              i = 0;

            case 1:
              if (!(_this.sortedList && i < _this.sortedList.length)) {
                _context.next = 7;
                break;
              }

              _context.next = 4;
              return _this.callApi(_this.sortedList[i], getAssociationFieldDefaultValue);

            case 4:
              i++;
              _context.next = 1;
              break;

            case 7:
              return _context.abrupt("return", true);

            case 8:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));

    return function (_x) {
      return _ref.apply(this, arguments);
    };
  }();

  this.callApi = function (sortedList, getAssociationFieldDefaultValue) {
    if (!(sortedList instanceof Array)) {
      sortedList = [sortedList];
    }

    return Promise.all(_lodash["default"].map(sortedList, function (field) {
      return getAssociationFieldDefaultValue(field);
    }));
  };

  this.noDependArr = [];
  this.surplusArr = [];
  this.sortedList = [];
} // 构建数据
;

var _default = AssociationSort;
exports["default"] = _default;