hyperformula-dc
Version:
HyperFormula is a JavaScript engine for efficient processing of spreadsheet-like data and formulas
238 lines (217 loc) • 8.05 kB
JavaScript
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
import "core-js/modules/es.regexp.constructor.js";
import "core-js/modules/es.regexp.exec.js";
import "core-js/modules/es.regexp.to-string.js";
import "core-js/modules/es.array.concat.js";
import "core-js/modules/es.symbol.js";
import "core-js/modules/es.symbol.description.js";
import "core-js/modules/es.object.to-string.js";
import "core-js/modules/es.symbol.iterator.js";
import "core-js/modules/es.array.iterator.js";
import "core-js/modules/es.string.iterator.js";
import "core-js/modules/web.dom-collections.iterator.js";
import "core-js/modules/es.array.from.js";
import "core-js/modules/es.array.slice.js";
import "core-js/modules/es.function.name.js";
/**
* @license
* Copyright (c) 2021 Handsoncode. All rights reserved.
*/
import { createToken, Lexer } from 'chevrotain';
export var RANGE_OPERATOR = ':';
export var ABSOLUTE_OPERATOR = '$';
/* arithmetic */
// abstract for + -
export var AdditionOp = createToken({
name: 'AdditionOp',
pattern: Lexer.NA
});
export var PlusOp = createToken({
name: 'PlusOp',
pattern: /\+/,
categories: AdditionOp
});
export var MinusOp = createToken({
name: 'MinusOp',
pattern: /-/,
categories: AdditionOp
}); // abstract for * /
export var MultiplicationOp = createToken({
name: 'MultiplicationOp',
pattern: Lexer.NA
});
export var TimesOp = createToken({
name: 'TimesOp',
pattern: /\*/,
categories: MultiplicationOp
});
export var DivOp = createToken({
name: 'DivOp',
pattern: /\//,
categories: MultiplicationOp
});
export var PowerOp = createToken({
name: 'PowerOp',
pattern: /\^/
});
export var PercentOp = createToken({
name: 'PercentOp',
pattern: /%/
});
export var BooleanOp = createToken({
name: 'BooleanOp',
pattern: Lexer.NA
});
export var EqualsOp = createToken({
name: 'EqualsOp',
pattern: /=/,
categories: BooleanOp
});
export var NotEqualOp = createToken({
name: 'NotEqualOp',
pattern: /<>/,
categories: BooleanOp
});
export var GreaterThanOp = createToken({
name: 'GreaterThanOp',
pattern: />/,
categories: BooleanOp
});
export var LessThanOp = createToken({
name: 'LessThanOp',
pattern: /</,
categories: BooleanOp
});
export var GreaterThanOrEqualOp = createToken({
name: 'GreaterThanOrEqualOp',
pattern: />=/,
categories: BooleanOp
});
export var LessThanOrEqualOp = createToken({
name: 'LessThanOrEqualOp',
pattern: /<=/,
categories: BooleanOp
});
export var ConcatenateOp = createToken({
name: 'ConcatenateOp',
pattern: /&/
});
/* addresses */
export var simpleSheetName = "[A-Za-z0-9_\xC0-\u02AF]+";
export var quotedSheetName = "'(((?!').|'')*)'";
export var sheetNameRegexp = "(".concat(simpleSheetName, "|").concat(quotedSheetName, ")!");
export var CellReference = createToken({
name: 'CellReference',
pattern: new RegExp("(".concat(sheetNameRegexp, ")?\\").concat(ABSOLUTE_OPERATOR, "?[A-Za-z]+\\").concat(ABSOLUTE_OPERATOR, "?[0-9]+"))
});
export var ColumnRange = createToken({
name: 'ColumnRange',
pattern: new RegExp("(".concat(sheetNameRegexp, ")?\\").concat(ABSOLUTE_OPERATOR, "?[A-Za-z]+").concat(RANGE_OPERATOR, "(").concat(sheetNameRegexp, ")?\\").concat(ABSOLUTE_OPERATOR, "?[A-Za-z]+"))
});
export var RowRange = createToken({
name: 'RowRange',
pattern: new RegExp("(".concat(sheetNameRegexp, ")?\\").concat(ABSOLUTE_OPERATOR, "?[0-9]+").concat(RANGE_OPERATOR, "(").concat(sheetNameRegexp, ")?\\").concat(ABSOLUTE_OPERATOR, "?[0-9]+"))
});
export var RangeSeparator = createToken({
name: 'RangeSeparator',
pattern: "".concat(RANGE_OPERATOR)
});
/* parenthesis */
export var LParen = createToken({
name: 'LParen',
pattern: /\(/
});
export var RParen = createToken({
name: 'RParen',
pattern: /\)/
});
/* array parenthesis */
export var ArrayLParen = createToken({
name: 'ArrayLParen',
pattern: /{/
});
export var ArrayRParen = createToken({
name: 'ArrayRParen',
pattern: /}/
});
/* procedures */
export var ProcedureName = createToken({
name: 'ProcedureName',
pattern: /([A-Za-z\u00C0-\u02AF][A-Za-z0-9\u00C0-\u02AF._]*)\(/
});
/* named expressions */
export var NamedExpression = createToken({
name: 'NamedExpression',
pattern: /[A-Za-z\u00C0-\u02AF_][A-Za-z0-9\u00C0-\u02AF._]*/
});
/* string literal */
export var StringLiteral = createToken({
name: 'StringLiteral',
pattern: /"([^"\\]*(\\.[^"\\]*)*)"/
});
/* error literal */
export var ErrorLiteral = createToken({
name: 'ErrorLiteral',
pattern: /#[A-Za-z0-9\/]+[?!]?/
});
/* skipping whitespaces */
export var WhiteSpace = createToken({
name: 'WhiteSpace',
pattern: /[ \t\n\r]+/
});
export var buildLexerConfig = function buildLexerConfig(config) {
var offsetProcedureNameLiteral = config.translationPackage.getFunctionTranslation('OFFSET');
var errorMapping = config.errorMapping;
var functionMapping = config.translationPackage.buildFunctionMapping();
var ArrayRowSeparator = createToken({
name: 'ArrayRowSep',
pattern: config.arrayRowSeparator
});
var ArrayColSeparator = createToken({
name: 'ArrayColSep',
pattern: config.arrayColumnSeparator
});
/* configurable tokens */
var ArgSeparator, inject;
if (config.functionArgSeparator === config.arrayColumnSeparator) {
ArgSeparator = ArrayColSeparator;
inject = [];
} else if (config.functionArgSeparator === config.arrayRowSeparator) {
ArgSeparator = ArrayRowSeparator;
inject = [];
} else {
ArgSeparator = createToken({
name: 'ArgSeparator',
pattern: config.functionArgSeparator
});
inject = [ArgSeparator];
}
var NumberLiteral = createToken({
name: 'NumberLiteral',
pattern: new RegExp("(([".concat(config.decimalSeparator, "]\\d+)|(\\d+([").concat(config.decimalSeparator, "]\\d*)?))(e[+-]?\\d+)?"))
});
var OffsetProcedureName = createToken({
name: 'OffsetProcedureName',
pattern: new RegExp(offsetProcedureNameLiteral, 'i')
});
/* order is important, first pattern is used */
var allTokens = [WhiteSpace, PlusOp, MinusOp, TimesOp, DivOp, PowerOp, EqualsOp, NotEqualOp, PercentOp, GreaterThanOrEqualOp, LessThanOrEqualOp, GreaterThanOp, LessThanOp, LParen, RParen, ArrayLParen, ArrayRParen, OffsetProcedureName, ProcedureName, RangeSeparator].concat(_toConsumableArray(inject), [ColumnRange, RowRange, NumberLiteral, StringLiteral, ErrorLiteral, ConcatenateOp, BooleanOp, AdditionOp, MultiplicationOp, CellReference, NamedExpression, ArrayRowSeparator, ArrayColSeparator]);
return {
ArgSeparator: ArgSeparator,
NumberLiteral: NumberLiteral,
OffsetProcedureName: OffsetProcedureName,
ArrayRowSeparator: ArrayRowSeparator,
ArrayColSeparator: ArrayColSeparator,
allTokens: allTokens,
errorMapping: errorMapping,
functionMapping: functionMapping,
decimalSeparator: config.decimalSeparator,
maxColumns: config.maxColumns,
maxRows: config.maxRows
};
};