hyperformula-dc/commonjs/BuildEngineFactory.js

HyperFormula is a JavaScript engine for efficient processing of spreadsheet-like data and formulas

"use strict";

exports.__esModule = true;
exports.BuildEngineFactory = void 0;

require("core-js/modules/web.dom-collections.for-each.js");

require("core-js/modules/es.function.name.js");

var _ArraySize = require("./ArraySize");

var _CellContentParser = require("./CellContentParser");

var _ClipboardOperations = require("./ClipboardOperations");

var _Config = require("./Config");

var _CrudOperations = require("./CrudOperations");

var _DateTimeHelper = require("./DateTimeHelper");

var _DependencyGraph = require("./DependencyGraph");

var _errors = require("./errors");

var _Evaluator = require("./Evaluator");

var _Exporter = require("./Exporter");

var _GraphBuilder = require("./GraphBuilder");

var _i18n = require("./i18n");

var _ArithmeticHelper = require("./interpreter/ArithmeticHelper");

var _FunctionRegistry = require("./interpreter/FunctionRegistry");

var _Interpreter = require("./interpreter/Interpreter");

var _LazilyTransformingAstService = require("./LazilyTransformingAstService");

var _SearchStrategy = require("./Lookup/SearchStrategy");

var _NamedExpressions = require("./NamedExpressions");

var _NumberLiteralHelper = require("./NumberLiteralHelper");

var _Operations = require("./Operations");

var _parser = require("./parser");

var _Serialization = require("./Serialization");

var _Sheet = require("./Sheet");

var _statistics = require("./statistics");

var _UndoRedo = require("./UndoRedo");

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 _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 BuildEngineFactory = /*#__PURE__*/function () {
  function BuildEngineFactory() {
    _classCallCheck(this, BuildEngineFactory);
  }

  _createClass(BuildEngineFactory, null, [{
    key: "buildEngine",
    value: function buildEngine(config) {
      var sheets = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var inputNamedExpressions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
      var stats = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : config.useStats ? new _statistics.Statistics() : new _statistics.EmptyStatistics();
      stats.start(_statistics.StatType.BUILD_ENGINE_TOTAL);
      var namedExpressions = new _NamedExpressions.NamedExpressions();
      var functionRegistry = new _FunctionRegistry.FunctionRegistry(config);
      var lazilyTransformingAstService = new _LazilyTransformingAstService.LazilyTransformingAstService(stats);

      var dependencyGraph = _DependencyGraph.DependencyGraph.buildEmpty(lazilyTransformingAstService, config, functionRegistry, namedExpressions, stats);

      var columnSearch = (0, _SearchStrategy.buildColumnSearchStrategy)(dependencyGraph, config, stats);
      var sheetMapping = dependencyGraph.sheetMapping;
      var addressMapping = dependencyGraph.addressMapping;

      for (var sheetName in sheets) {
        if (Object.prototype.hasOwnProperty.call(sheets, sheetName)) {
          var sheet = sheets[sheetName];
          (0, _Sheet.validateAsSheet)(sheet);
          var boundaries = (0, _Sheet.findBoundaries)(sheet);

          if (boundaries.height > config.maxRows || boundaries.width > config.maxColumns) {
            throw new _errors.SheetSizeLimitExceededError();
          }

          var sheetId = sheetMapping.addSheet(sheetName);
          addressMapping.autoAddSheet(sheetId, sheet, boundaries);
        }
      }

      var parser = new _parser.ParserWithCaching(config, functionRegistry, sheetMapping.get);
      lazilyTransformingAstService.parser = parser;
      var unparser = new _parser.Unparser(config, (0, _parser.buildLexerConfig)(config), sheetMapping.fetchDisplayName, namedExpressions);
      var dateTimeHelper = new _DateTimeHelper.DateTimeHelper(config);
      var numberLiteralHelper = new _NumberLiteralHelper.NumberLiteralHelper(config);
      var arithmeticHelper = new _ArithmeticHelper.ArithmeticHelper(config, dateTimeHelper, numberLiteralHelper);
      var cellContentParser = new _CellContentParser.CellContentParser(config, dateTimeHelper, numberLiteralHelper);
      var arraySizePredictor = new _ArraySize.ArraySizePredictor(config, functionRegistry);
      var operations = new _Operations.Operations(config, dependencyGraph, columnSearch, cellContentParser, parser, stats, lazilyTransformingAstService, namedExpressions, arraySizePredictor);
      var undoRedo = new _UndoRedo.UndoRedo(config, operations);
      lazilyTransformingAstService.undoRedo = undoRedo;
      var clipboardOperations = new _ClipboardOperations.ClipboardOperations(config, dependencyGraph, operations);
      var crudOperations = new _CrudOperations.CrudOperations(config, operations, undoRedo, clipboardOperations, dependencyGraph, columnSearch, parser, cellContentParser, lazilyTransformingAstService, namedExpressions);
      inputNamedExpressions.forEach(function (entry) {
        crudOperations.ensureItIsPossibleToAddNamedExpression(entry.name, entry.expression, entry.scope);
        crudOperations.operations.addNamedExpression(entry.name, entry.expression, entry.scope, entry.options);
      });
      var exporter = new _Exporter.Exporter(config, namedExpressions, sheetMapping.fetchDisplayName, lazilyTransformingAstService);
      var serialization = new _Serialization.Serialization(dependencyGraph, unparser, exporter);
      var interpreter = new _Interpreter.Interpreter(config, dependencyGraph, columnSearch, stats, arithmeticHelper, functionRegistry, namedExpressions, serialization, arraySizePredictor, dateTimeHelper);
      stats.measure(_statistics.StatType.GRAPH_BUILD, function () {
        var graphBuilder = new _GraphBuilder.GraphBuilder(dependencyGraph, columnSearch, parser, cellContentParser, stats, arraySizePredictor);
        graphBuilder.buildGraph(sheets, stats);
      });
      var evaluator = new _Evaluator.Evaluator(config, stats, interpreter, lazilyTransformingAstService, dependencyGraph, columnSearch);
      evaluator.run();
      stats.end(_statistics.StatType.BUILD_ENGINE_TOTAL);
      return {
        config: config,
        stats: stats,
        dependencyGraph: dependencyGraph,
        columnSearch: columnSearch,
        parser: parser,
        unparser: unparser,
        cellContentParser: cellContentParser,
        evaluator: evaluator,
        lazilyTransformingAstService: lazilyTransformingAstService,
        crudOperations: crudOperations,
        exporter: exporter,
        namedExpressions: namedExpressions,
        serialization: serialization,
        functionRegistry: functionRegistry
      };
    }
  }, {
    key: "buildFromSheets",
    value: function buildFromSheets(sheets) {
      var configInput = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var namedExpressions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
      var config = new _Config.Config(configInput);
      return this.buildEngine(config, sheets, namedExpressions);
    }
  }, {
    key: "buildFromSheet",
    value: function buildFromSheet(sheet) {
      var configInput = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var namedExpressions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
      var config = new _Config.Config(configInput);
      var newsheetprefix = config.translationPackage.getUITranslation(_i18n.UIElement.NEW_SHEET_PREFIX) + '1';
      return this.buildEngine(config, _defineProperty({}, newsheetprefix, sheet), namedExpressions);
    }
  }, {
    key: "buildEmpty",
    value: function buildEmpty() {
      var configInput = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var namedExpressions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
      return this.buildEngine(new _Config.Config(configInput), {}, namedExpressions);
    }
  }, {
    key: "rebuildWithConfig",
    value: function rebuildWithConfig(config, sheets, namedExpressions, stats) {
      return this.buildEngine(config, sheets, namedExpressions, stats);
    }
  }]);

  return BuildEngineFactory;
}();

exports.BuildEngineFactory = BuildEngineFactory;