@syncfusion/ej2-calculate 35.1.37

package/src/formulas/array.js

@@ -0,0 +1,718 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { FormulasErrorsStrings, CommonErrors } from '../common/index';
+import { getAlphalabel } from '../base/index';
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { isNumber } from '../common/number-date';
+import { sortCollection } from '../common/sort';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Array formula helpers for dynamic spill-style range operations.
+ *
+ * Registered functions: UNIQUE, SORT.
+ *
+ * @hidden
+ */
+var ArrayFormulas = /** @class */ (function (_super) {
+    __extends(ArrayFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function ArrayFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'UNIQUE', category: 'Lookup & Reference', description: 'Returns a unique values from a range or array.' },
+            { formulaName: 'SORT', category: 'Lookup & Reference', description: 'Sorts a range of an array.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns a unique values from a range or array.
+     *
+     * Excel: `UNIQUE(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=UNIQUE(1)');
+     * ```
+     */
+    ArrayFormulas.prototype.ComputeUNIQUE = function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var result;
+        var isComputeExp;
+        var errCollection = this.parent.getErrorStrings();
+        if (args[args.length - 1] === 'isComputeExp') {
+            isComputeExp = true;
+            args.pop();
+        }
+        if (isNullOrUndefined(args) || (args[0] === '' && args.length === 1)) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args.length > 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var processArgs = function (actualValue) {
+            if (isNullOrUndefined(actualValue)) {
+                return _this.parent.falseValue;
+            }
+            var value = _this.parent.getValueFromArg(actualValue);
+            if (errCollection.indexOf(value) > -1) {
+                return value;
+            }
+            if (Number(value) === 0) {
+                return _this.parent.falseValue;
+            }
+            else if (Number(value) < 0 || Number(value) > 0) {
+                return _this.parent.trueValue;
+            }
+            if (!_this.parent.isCellReference(actualValue)) {
+                value = _this.parent.removeTics(value);
+            }
+            if (value.toUpperCase() === _this.parent.trueValue || value.toUpperCase() === _this.parent.falseValue) {
+                return value.toUpperCase();
+            }
+            else if (value.indexOf(_this.parent.tic) > -1 || actualValue.indexOf(_this.parent.tic) > -1) {
+                return errCollection[CommonErrors.Value];
+            }
+            else {
+                return errCollection[CommonErrors.Name];
+            }
+        };
+        var byColumn = processArgs(args[1]);
+        if (errCollection.indexOf(byColumn) > -1) {
+            return byColumn;
+        }
+        var exactlyOne = processArgs(args[2]);
+        if (errCollection.indexOf(exactlyOne) > -1) {
+            return exactlyOne;
+        }
+        var valueCollection = [];
+        if (args[0].indexOf(':') > -1) {
+            if (isNullOrUndefined(args[0].match(/[0-9]/))) {
+                var splitArray = args[0].split(':');
+                args[0] = splitArray[0] + '1' + ':' + splitArray[1] + (this.parent.spreadSheetUsedRange[0] + 1);
+            }
+            else if (isNullOrUndefined(args[0].toUpperCase().match(/[A-Z]/))) {
+                var splitArray = args[0].split(':');
+                args[0] = 'A' + splitArray[0] + ':' + getAlphalabel(this.parent.spreadSheetUsedRange[1] + 1) + splitArray[1];
+            }
+            var rangeSplit = args[0].split(':');
+            if (this.parent.isCellReference(rangeSplit[0]) && this.parent.isCellReference(rangeSplit[1])) {
+                var collection = this.parent.dependencyCollection;
+                for (var i = 0; i < collection.length && !isComputeExp; i++) {
+                    if (collection[i].split(':')[0] === args[0].split(':')[0]) {
+                        this.clearDependency(collection[i]);
+                    }
+                }
+                if (this.parent.dependencyCollection.indexOf(args[0]) === -1) {
+                    if (!isComputeExp) {
+                        this.parent.dependencyCollection.push(args[0]);
+                    }
+                }
+                else {
+                    this.clearDependency(args[0]);
+                }
+                var j = args[0].indexOf(':');
+                var swap = void 0;
+                var rowIdx = this.parent.rowIndex(this.parent.substring(args[0], 0, j));
+                var colIdx = this.parent.colIndex(this.parent.substring(args[0], 0, j));
+                var endRowIdx = this.parent.rowIndex(this.parent.substring(args[0], j + 1, j + args[0].length - j - 1));
+                var endColIdx = this.parent.colIndex(this.parent.substring(args[0], j + 1, j + args[0].length - j - 1));
+                if (rowIdx > endRowIdx) {
+                    swap = endRowIdx;
+                    endRowIdx = rowIdx;
+                    rowIdx = swap;
+                }
+                if (colIdx > endColIdx) {
+                    swap = endColIdx;
+                    endColIdx = colIdx;
+                    colIdx = swap;
+                }
+                var sheetIndex = '';
+                if (args[0].indexOf('!') === 0) {
+                    sheetIndex = args[0].substring(0, args[0].replace('!', '').indexOf('!') + 2);
+                }
+                args[0] = sheetIndex + getAlphalabel(colIdx) + rowIdx + ':' + getAlphalabel(endColIdx) + endRowIdx;
+                var colDiff = endColIdx - colIdx;
+                var cellValues = this.parent.getCellCollection(args[0]);
+                var actCell = void 0;
+                var uniqueActCell = void 0;
+                actCell = uniqueActCell = this.parent.actCell;
+                if (byColumn === this.parent.falseValue) {
+                    if (colDiff === 0) {
+                        for (var i = 0; i < cellValues.length; i++) {
+                            var val = this.parent.getValueFromArg(cellValues[i]);
+                            val = val === '' ? '0' : val;
+                            valueCollection.push(val);
+                        }
+                    }
+                    else {
+                        var temp = '';
+                        var diff = colDiff;
+                        for (var i = 0; i < cellValues.length; i++) {
+                            if (i === cellValues.length - 1) {
+                                var val = this.parent.getValueFromArg(cellValues[i]);
+                                val = val === '' ? '0' : val;
+                                temp = temp + val + '++';
+                                valueCollection.push(temp.substring(0, temp.length - 2));
+                            }
+                            if (i <= diff) {
+                                var val = this.parent.getValueFromArg(cellValues[i]);
+                                val = val === '' ? '0' : val;
+                                temp = temp + val + '++';
+                            }
+                            else {
+                                valueCollection.push(temp.substring(0, temp.length - 2));
+                                diff = colDiff + i;
+                                var val = this.parent.getValueFromArg(cellValues[i]);
+                                val = val === '' ? '0' : val;
+                                temp = val + '++';
+                            }
+                        }
+                    }
+                }
+                else {
+                    var temp = '';
+                    var diff = colDiff + 1;
+                    var rowDiff = endRowIdx - rowIdx;
+                    for (var i = 0; i < diff; i++) {
+                        for (var j_1 = 0; j_1 <= rowDiff; j_1++) {
+                            var val = this.parent.getValueFromArg(cellValues[j_1 * diff + i]);
+                            val = val === '' ? '0' : val;
+                            temp = temp + val + '++';
+                        }
+                        valueCollection.push(temp.substring(0, temp.length - 2));
+                        temp = '';
+                    }
+                }
+                var uniqueCollection = [];
+                var duplicateCollection = [];
+                var tmp = [];
+                var tmp2 = [];
+                for (var i = 0; i < valueCollection.length; i++) {
+                    if (uniqueCollection.indexOf(valueCollection[i].toLowerCase()) === -1) {
+                        uniqueCollection.push(valueCollection[i].toLowerCase());
+                        tmp.push(valueCollection[i]);
+                    }
+                    else {
+                        if (duplicateCollection.indexOf(valueCollection[i].toLowerCase()) === -1) {
+                            duplicateCollection.push(valueCollection[i].toLowerCase());
+                        }
+                        tmp2.push(valueCollection[i]);
+                    }
+                }
+                if (exactlyOne === this.parent.trueValue) {
+                    var exactOne = [];
+                    for (var i = 0; i < tmp.length; i++) {
+                        if (duplicateCollection.indexOf(tmp[i].toLowerCase()) === -1) {
+                            exactOne.push(tmp[i]);
+                        }
+                    }
+                    tmp = exactOne;
+                    if (tmp.length === 0) {
+                        return errCollection[CommonErrors.Calc];
+                    }
+                }
+                if (isComputeExp) {
+                    var computeExpResult_1;
+                    if (colDiff !== 0) {
+                        computeExpResult_1 = [];
+                        (tmp).forEach(function (item) {
+                            computeExpResult_1 = computeExpResult_1.concat(item.split('++'));
+                        });
+                    }
+                    else {
+                        computeExpResult_1 = byColumn === this.parent.falseValue ? tmp : tmp[0].split('++');
+                    }
+                    return computeExpResult_1;
+                }
+                if (actCell.indexOf('!') > -1) {
+                    actCell = actCell.substring(actCell.lastIndexOf('!') + 1);
+                }
+                var actRowIdx = this.parent.rowIndex(actCell);
+                var actColIdx = this.parent.colIndex(actCell);
+                if (this.parent.dependencyLevel === 0) {
+                    var isSpill = false;
+                    if (byColumn === this.parent.falseValue) {
+                        for (var i = actRowIdx, diff = tmp.length + actRowIdx; i < diff; i++) {
+                            var splitValue = tmp[0].split('++');
+                            for (var j_2 = actColIdx, diff2 = splitValue.length + actColIdx; j_2 < diff2; j_2++) {
+                                if (i === diff - 1 && j_2 === diff2 - 1 &&
+                                    this.parent.uniqueRange.indexOf(uniqueActCell + ':' + getAlphalabel(j_2) + i) === -1) {
+                                    this.parent.uniqueRange.push(uniqueActCell + ':' + getAlphalabel(j_2) + i);
+                                }
+                                if (this.checkSpill(j_2, i)) {
+                                    isSpill = true;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        for (var i = actColIdx, diff = tmp.length + actColIdx; i < diff; i++) {
+                            var splitValue = tmp[0].split('++');
+                            for (var j_3 = actRowIdx, diff2 = splitValue.length + actRowIdx; j_3 < diff2; j_3++) {
+                                if (i === diff - 1 && j_3 === diff2 - 1 &&
+                                    this.parent.uniqueRange.indexOf(this.parent.actCell + ':' + getAlphalabel(i) + j_3) === -1) {
+                                    this.parent.uniqueRange.push(this.parent.actCell + ':' + getAlphalabel(i) + j_3);
+                                }
+                                if (this.checkSpill(i, j_3)) {
+                                    isSpill = true;
+                                }
+                            }
+                        }
+                    }
+                    if (isSpill) {
+                        return this.parent.formulaErrorStrings[FormulasErrorsStrings.Spill];
+                    }
+                }
+                else if (this.parent.dependencyLevel > 0 &&
+                    this.parent.getValueFromArg(getAlphalabel(actColIdx) + actRowIdx, true).indexOf('#SPILL!') > -1) {
+                    return this.parent.formulaErrorStrings[FormulasErrorsStrings.Spill];
+                }
+                if (byColumn === this.parent.falseValue) {
+                    var calcFamily = this.parent.getSheetFamilyItem(this.parent.grid);
+                    var token = '';
+                    var cellTxt = void 0;
+                    if (calcFamily.sheetNameToParentObject !== null && calcFamily.sheetNameToParentObject.size > 0) {
+                        token = calcFamily.parentObjectToToken.get(this.parent.grid);
+                        cellTxt = token + actCell;
+                    }
+                    for (var i = 0; i < tmp.length; i++) {
+                        var splitValue = tmp[i].split('++');
+                        if (i > 0) {
+                            actRowIdx++;
+                            actColIdx = this.parent.colIndex(actCell);
+                        }
+                        for (var j_4 = 0; j_4 < splitValue.length; j_4++) {
+                            this.setValueRefresh(splitValue[j_4], actRowIdx, actColIdx);
+                            if (i > 0 || j_4 > 0) {
+                                this.parent.refreshDependentCells(token + getAlphalabel(actColIdx) + actRowIdx.toString(), cellTxt);
+                            }
+                            if (splitValue[j_4 + 1]) {
+                                actColIdx++;
+                            }
+                        }
+                    }
+                    result = tmp[0].split('++')[0];
+                }
+                else {
+                    for (var i = 0; i < tmp.length; i++) {
+                        var splitValue = tmp[i].split('++');
+                        for (var i_1 = 0; i_1 < splitValue.length; i_1++) {
+                            this.setValueRefresh(splitValue[i_1], actRowIdx, actColIdx);
+                            if (splitValue[i_1 + 1]) {
+                                actRowIdx++;
+                            }
+                            else {
+                                actColIdx++;
+                                actRowIdx = this.parent.rowIndex(actCell);
+                            }
+                        }
+                    }
+                    result = tmp[0].split('++')[0];
+                }
+            }
+        }
+        else if (this.parent.isCellReference(args[0])) {
+            if (this.parent.dependencyCollection.indexOf(args[0]) === -1) {
+                if (!isComputeExp) {
+                    this.parent.dependencyCollection.push(args[0]);
+                }
+            }
+            else {
+                this.clearDependency(args[0]);
+            }
+            result = this.parent.getValueFromArg(args[0]);
+        }
+        else {
+            result = this.parent.getValueFromArg(args[0].trim());
+            if (errCollection.indexOf(result) > -1) {
+                return result;
+            }
+            result = this.parent.removeTics(result);
+        }
+        return result;
+    };
+    ArrayFormulas.prototype.setValueRefresh = function (splitValue, rowIdx, colIdx) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.parent.parentObject.setValueRowCol(this.parent.getSheetId(this.parent.grid), splitValue, rowIdx, colIdx);
+    };
+    ArrayFormulas.prototype.checkSpill = function (i, j) {
+        var spill = false;
+        var value = this.parent.getValueFromArg(getAlphalabel(i) + j, true);
+        var formulaAddress = '!' + this.parent.getSheetID(this.parent.grid) + '!' + getAlphalabel(i) + j;
+        var formulaString;
+        if (this.parent.getFormulaInfoTable().get(formulaAddress)) {
+            formulaString = this.parent.getFormulaInfoTable().get(formulaAddress).formulaText;
+        }
+        if (value && (value.toUpperCase().indexOf('UNIQUE') < 0 ||
+            (formulaString && !formulaString.toUpperCase().includes('UNIQUE'))) &&
+            (value.toUpperCase().indexOf('SORT') < 0 ||
+                (formulaString && !formulaString.toUpperCase().includes('SORT'))) &&
+            value !== this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments]) {
+            spill = true;
+        }
+        return spill;
+    };
+    ArrayFormulas.prototype.clearDependency = function (value) {
+        var actCell = this.parent.actCell;
+        var actCellSheetName = '';
+        if (actCell.lastIndexOf('!') > -1) {
+            var actCellAddr = actCell;
+            actCell = actCellAddr.substring(actCellAddr.lastIndexOf('!') + 1);
+            actCellSheetName = actCellAddr.substring(0, actCellAddr.lastIndexOf('!')) + '!';
+        }
+        var actRowIdx = this.parent.rowIndex(actCell);
+        var actColIdx = this.parent.colIndex(actCell);
+        var j = value.indexOf(':');
+        var rowIndex = this.parent.rowIndex(this.parent.substring(value, 0, j));
+        var colIndex = this.parent.colIndex(this.parent.substring(value, 0, j));
+        var eRowIdx = this.parent.rowIndex(this.parent.substring(value, j + 1, j + value.length - j - 1));
+        var eColIdx = this.parent.colIndex(this.parent.substring(value, j + 1, j + value.length - j - 1));
+        var rowDiff = eRowIdx - rowIndex + actRowIdx;
+        var colDiff = eColIdx - colIndex + actColIdx;
+        var formulaText = this.parent.getFormulaInfoTable().get('!' + this.parent.getSheetID(this.parent.grid) + '!' + actCell) ?
+            this.parent.getFormulaInfoTable().get('!' + this.parent.getSheetID(this.parent.grid) + '!' + actCell).getFormulaText() : '';
+        for (var i = actRowIdx; i <= rowDiff; i++) {
+            for (var j_5 = actColIdx; j_5 <= colDiff; j_5++) {
+                if (this.parent.dependencyLevel > 0 || formulaText.indexOf('UNIQUE') > -1
+                    || formulaText.indexOf('SORT') > -1) {
+                    if (this.parent.getValueFromArg('!' + this.parent.getSheetID(this.parent.grid) + '!' +
+                        getAlphalabel(actColIdx) + actRowIdx, true).indexOf('#SPILL!') > -1) {
+                        return;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    this.parent.parentObject.setValueRowCol(this.parent.getSheetID(this.parent.grid) + 1, '', i, j_5);
+                    this.parent.refreshDependentCells('!' + this.parent.getSheetID(this.parent.grid) + '!' + getAlphalabel(j_5) + i, actCell);
+                    this.parent.actCell = actCellSheetName + actCell;
+                }
+            }
+        }
+    };
+    /**
+     * Sorts a range of an array.
+     *
+     * Excel: `SORT(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    ArrayFormulas.prototype.ComputeSORT = function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var nestedFormula;
+        var isStringVal;
+        if (args.length && args[args.length - 1] === 'nestedFormulaTrue') {
+            nestedFormula = true;
+            args.pop();
+        }
+        var argArr = args;
+        var result;
+        var values = [];
+        if (isNullOrUndefined(args) || args[0] === '' || argArr.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        argArr[1] = argArr[1] ? argArr[1] : '1';
+        argArr[2] = argArr[2] ? argArr[2] : '1'; // 1 = Ascending, -1 = Descending. Default is ascending order.
+        argArr[3] = argArr[3] ? argArr[3] : 'FALSE'; // Default is FALSE = sort by column or row
+        argArr[0] = argArr[0].split('$').join('');
+        var cellCollection;
+        var valueCollection = [];
+        if (argArr[0].indexOf(':') > -1) {
+            if (isNullOrUndefined(argArr[0].match(/[0-9]/))) {
+                var splitArray = argArr[0].split(':');
+                argArr[0] = splitArray[0] + '1' + ':' + splitArray[1] + (this.parent.spreadSheetUsedRange[0] + 1);
+            }
+            else if (isNullOrUndefined(argArr[0].toUpperCase().match(/[A-Z]/))) {
+                var splitArray = argArr[0].split(':');
+                argArr[0] = 'A' + splitArray[0] + ':' + getAlphalabel(this.parent.spreadSheetUsedRange[1] + 1) + splitArray[1];
+            }
+            var rangeSplit = argArr[0].split(':');
+            if (this.parent.isCellReference(rangeSplit[0]) && this.parent.isCellReference(rangeSplit[1])) {
+                var collection = this.parent.dependencyCollection;
+                for (var i = 0; i < collection.length && !nestedFormula; i++) {
+                    if (collection[i].split(':')[0] === argArr[0].split(':')[0]) {
+                        this.clearDependency(collection[i]);
+                    }
+                }
+                if (this.parent.dependencyCollection.indexOf(argArr[0]) === -1) {
+                    if (!nestedFormula) {
+                        this.parent.dependencyCollection.push(argArr[0]);
+                    }
+                }
+                else {
+                    this.clearDependency(argArr[0]);
+                }
+                var j = argArr[0].indexOf(':');
+                var swap = void 0;
+                var rowIdx = this.parent.rowIndex(this.parent.substring(argArr[0], 0, j));
+                var colIdx = this.parent.colIndex(this.parent.substring(argArr[0], 0, j));
+                var eRowIdx = this.parent.rowIndex(this.parent.substring(argArr[0], j + 1, j + argArr[0].length - j - 1));
+                var eColIdx = this.parent.colIndex(this.parent.substring(argArr[0], j + 1, j + argArr[0].length - j - 1));
+                if (rowIdx > eRowIdx) {
+                    swap = eRowIdx;
+                    eRowIdx = rowIdx;
+                    rowIdx = swap;
+                }
+                if (colIdx > eColIdx) {
+                    swap = eColIdx;
+                    eColIdx = colIdx;
+                    colIdx = swap;
+                }
+                if (this.parent.isCellReference(argArr[3])) {
+                    argArr[3] = this.parent.getValueFromArg(argArr[3]).toUpperCase();
+                    if (argArr[3] !== this.parent.trueValue && argArr[3] !== this.parent.falseValue) {
+                        if (isNumber(argArr[3])) {
+                            argArr[3] = Number(argArr[3]) === 0 ? this.parent.falseValue : this.parent.trueValue;
+                        }
+                        else if (argArr[3] === '') {
+                            argArr[3] = this.parent.falseValue;
+                        }
+                        else {
+                            return this.parent.getErrorStrings()[CommonErrors.Value];
+                        }
+                    }
+                }
+                else {
+                    isStringVal = argArr[3].startsWith(this.parent.tic) && argArr[3].endsWith(this.parent.tic);
+                    argArr[3] = this.parent.getValueFromArg(argArr[3]);
+                    argArr[3] = isNumber(argArr[3]) ? (Number(argArr[3]) === 0 ? this.parent.falseValue : this.parent.trueValue) :
+                        argArr[3].split(this.parent.tic).join('').toUpperCase();
+                    if (argArr[3] !== this.parent.trueValue && argArr[3] !== this.parent.falseValue) {
+                        return this.parent.getErrorStrings()[isStringVal ? CommonErrors.Value : CommonErrors.Name];
+                    }
+                }
+                if (this.parent.isCellReference(argArr[2])) {
+                    argArr[2] = this.parent.getValueFromArg(argArr[2]);
+                    argArr[2] = argArr[2] === this.parent.trueValue ? '1' : argArr[2];
+                }
+                else {
+                    argArr[2] = this.parent.getValueFromArg(argArr[2]);
+                    argArr[2] = argArr[2] === this.parent.trueValue ? '1' : argArr[2].split(this.parent.tic).join('');
+                }
+                argArr[2] = isNumber(argArr[2]) ? Math.floor(Number(argArr[2])).toString() : argArr[2];
+                if (argArr[2] !== '1' && argArr[2] !== '-1') {
+                    return this.parent.getErrorStrings().indexOf(argArr[2]) > -1 ? this.parent.getErrorStrings()[CommonErrors.Name] :
+                        this.parent.getErrorStrings()[CommonErrors.Value];
+                }
+                var order = argArr[2] === '1' ? 'Ascending' : 'Descending';
+                if (this.parent.isCellReference(argArr[1])) {
+                    argArr[1] = this.parent.getValueFromArg(argArr[1]);
+                    argArr[1] = isNumber(argArr[1]) ? Math.floor(Number(argArr[1])).toString() : (argArr[1] === this.parent.trueValue ? '1'
+                        : (argArr[1] === this.parent.falseValue ? '0' : argArr[1]));
+                    if (!isNaN(this.parseDouble(argArr[1])) ? (this.parseDouble(argArr[1]) < 1 || (argArr[3] === this.parent.trueValue ?
+                        (eRowIdx - rowIdx) + 1 < this.parseDouble(argArr[1]) : (eColIdx - colIdx) + 1 < this.parseDouble(argArr[1])))
+                        : true) {
+                        return this.parent.getErrorStrings()[CommonErrors.Value];
+                    }
+                }
+                else {
+                    isStringVal = argArr[1].startsWith(this.parent.tic) && argArr[1].endsWith(this.parent.tic);
+                    argArr[1] = this.parent.getValueFromArg(argArr[1]);
+                    argArr[1] = isNumber(argArr[1]) ? Math.floor(Number(argArr[1])).toString() : (argArr[1] === this.parent.trueValue ?
+                        '1' : (argArr[1] === this.parent.falseValue ? '0' : argArr[1].split(this.parent.tic).join('')));
+                    if (!isNaN(this.parseDouble(argArr[1])) ? (this.parseDouble(argArr[1]) < 1 || (argArr[3] === this.parent.trueValue ?
+                        (eRowIdx - rowIdx) + 1 < this.parseDouble(argArr[1]) : (eColIdx - colIdx) + 1 < this.parseDouble(argArr[1])))
+                        : isStringVal) {
+                        return this.parent.getErrorStrings()[CommonErrors.Value];
+                    }
+                }
+                var sheetIdx = '';
+                if (argArr[0].indexOf('!') === 0) {
+                    sheetIdx = argArr[0];
+                    sheetIdx = sheetIdx.replace('!', '');
+                    sheetIdx = sheetIdx.indexOf('!');
+                    sheetIdx = argArr[0].substring(0, sheetIdx + 2);
+                }
+                argArr[0] = sheetIdx + getAlphalabel(colIdx) + rowIdx + ':' + getAlphalabel(eColIdx) + eRowIdx;
+                cellCollection = this.parent.getCellCollection(argArr[0]);
+                for (var i = 0; i < cellCollection.length; i++) {
+                    valueCollection.push(this.parent.getValueFromArg(cellCollection[i]));
+                }
+                var colSort_1 = [];
+                var numColl_1 = [];
+                var strColl_1 = [];
+                var booleanColl_1 = [];
+                var emptyCellColl_1 = [];
+                var totalColumn = eColIdx - colIdx + 1;
+                var sortRangeValuesHandler = function (value) {
+                    if (value) {
+                        if (value.toUpperCase() === 'TRUE' || value.toUpperCase() === 'FALSE') {
+                            booleanColl_1.push(value);
+                            colSort_1.push(value);
+                        }
+                        else if (isNaN(_this.parseDouble(value))) {
+                            strColl_1.push(value);
+                            colSort_1.push(value);
+                        }
+                        else {
+                            numColl_1.push(_this.parseDouble(value));
+                            colSort_1.push(_this.parseDouble(value));
+                        }
+                    }
+                    else if (value === '') {
+                        emptyCellColl_1.push(_this.parseDouble(value).toString());
+                        colSort_1.push(_this.parseDouble(value).toString());
+                    }
+                };
+                if (argArr[3] === 'TRUE') {
+                    for (var i = 0; i < totalColumn; i++) {
+                        sortRangeValuesHandler(valueCollection[i + ((this.parseDouble(argArr[1]) - 1) * totalColumn)]);
+                    }
+                }
+                if (argArr[3] === 'FALSE') {
+                    for (var i = 0; i < valueCollection.length; i++) {
+                        sortRangeValuesHandler(valueCollection[i * totalColumn + this.parseDouble(argArr[1]) - 1]);
+                    }
+                }
+                /* eslint-disable @typescript-eslint/no-explicit-any */
+                var sortedNumColl = numColl_1.length > 0 ? sortCollection(numColl_1, order) : [];
+                var sortedStrColl = strColl_1.length > 0 ? sortCollection(strColl_1, order) : [];
+                var sortedBooleanColl = booleanColl_1.length > 0 ? sortCollection(booleanColl_1, order) : [];
+                var sortedVal = order === 'Ascending' ?
+                    sortedNumColl.concat(sortedStrColl, sortedBooleanColl, emptyCellColl_1) :
+                    sortedBooleanColl.concat(sortedStrColl, sortedNumColl, emptyCellColl_1);
+                /* eslint-enable @typescript-eslint/no-explicit-any */
+                var id = [];
+                for (var a = 0; a < sortedVal.length; a++) {
+                    for (var b = 0; b < colSort_1.length; b++) {
+                        if (JSON.stringify(sortedVal[a]) === JSON.stringify(colSort_1[b])) {
+                            if (id.indexOf(b) === -1) {
+                                id.push(b);
+                            }
+                        }
+                    }
+                }
+                var activeCell = void 0;
+                var sortActCell = void 0;
+                activeCell = sortActCell = this.parent.actCell;
+                if (activeCell) {
+                    activeCell = activeCell.indexOf('!') > -1 ? activeCell.substring(activeCell.lastIndexOf('!') + 1) : activeCell;
+                }
+                else {
+                    activeCell = this.parent.actCell;
+                }
+                var actRowIdx = this.parent.rowIndex(activeCell);
+                var actColIdx = this.parent.colIndex(activeCell);
+                if (this.parent.dependencyLevel === 0) {
+                    var isSpill = false;
+                    var resultRows = (argArr[3] === 'TRUE') ? (eRowIdx - rowIdx + 1) : id.length;
+                    var resultCols = (argArr[3] === 'TRUE') ? id.length : (eColIdx - colIdx + 1);
+                    for (var rowOffset = 0; rowOffset < resultRows; rowOffset++) {
+                        for (var colOffset = 0; colOffset < resultCols; colOffset++) {
+                            if (this.checkSpill(actColIdx + colOffset, actRowIdx + rowOffset)) {
+                                isSpill = true;
+                            }
+                            if (rowOffset === resultRows - 1 && colOffset === resultCols - 1) {
+                                var endCell = getAlphalabel(actColIdx + colOffset) + (actRowIdx + rowOffset);
+                                if (this.parent.sortRange.indexOf(sortActCell + ':' + endCell) === -1) {
+                                    this.parent.sortRange.push(sortActCell + ':' + endCell);
+                                }
+                            }
+                        }
+                    }
+                    if (isSpill) {
+                        return this.parent.formulaErrorStrings[FormulasErrorsStrings.Spill];
+                    }
+                }
+                else if (this.parent.dependencyLevel > 0 &&
+                    this.parent.getValueFromArg(getAlphalabel(actColIdx) + actRowIdx, true).indexOf('#SPILL!') > -1) {
+                    return this.parent.formulaErrorStrings[FormulasErrorsStrings.Spill];
+                }
+                if (argArr[3] === 'TRUE') {
+                    for (var startRow = rowIdx, rowInc = 0; startRow <= eRowIdx; startRow++, rowInc++) {
+                        for (var a = 0, colInc = 0; a < id.length; a++, colInc++) {
+                            var cellValue = this.parent.getValueFromArg(sheetIdx + getAlphalabel(id[a] + colIdx) + startRow);
+                            if (nestedFormula && cellValue !== '') {
+                                values.push(cellValue);
+                                continue;
+                            }
+                            cellValue = cellValue === '' ? '0' : cellValue;
+                            var activeCell_1 = this.parent.cell;
+                            if (activeCell_1) {
+                                activeCell_1 = activeCell_1.indexOf('!') > -1 ? activeCell_1.substring(activeCell_1.lastIndexOf('!') + 1) :
+                                    activeCell_1;
+                                var actRowIdx_1 = this.parent.rowIndex(activeCell_1);
+                                var actColIdx_1 = this.parent.colIndex(activeCell_1);
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                this.parent.parentObject.setValueRowCol(this.parent.getSheetID(this.parent.grid) + 1, cellValue, actRowIdx_1 + rowInc, actColIdx_1 + colInc);
+                            }
+                        }
+                    }
+                    result = this.parent.getValueFromArg(sheetIdx + getAlphalabel(id[0] + colIdx) + rowIdx);
+                }
+                if (argArr[3] === 'FALSE') {
+                    for (var a = 0, rowInc = 0; a < id.length; a++, rowInc++) {
+                        for (var startCol = colIdx, colInc = 0; startCol <= eColIdx; startCol++, colInc++) {
+                            var value = this.parent.getValueFromArg(sheetIdx + getAlphalabel(startCol) + (id[a] + rowIdx));
+                            if (nestedFormula && value !== '') {
+                                values.push(value);
+                                continue;
+                            }
+                            value = value === '' ? '0' : value;
+                            var activeCell_2 = this.parent.cell;
+                            if (activeCell_2) {
+                                activeCell_2 = activeCell_2.indexOf('!') > -1 ? activeCell_2.substring(activeCell_2.lastIndexOf('!') + 1) :
+                                    activeCell_2;
+                                var actColIdx_2 = this.parent.colIndex(activeCell_2);
+                                var actRowIdx_2 = this.parent.rowIndex(activeCell_2);
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                this.parent.parentObject.setValueRowCol(this.parent.getSheetID(this.parent.grid) + 1, value, actRowIdx_2 + rowInc, actColIdx_2 + colInc);
+                            }
+                        }
+                    }
+                    result = this.parent.getValueFromArg(sheetIdx + getAlphalabel(colIdx) + (id[0] + rowIdx));
+                }
+            }
+        }
+        else if (this.parent.isCellReference(argArr[0])) {
+            if (this.parent.dependencyCollection.indexOf(argArr[0]) === -1) {
+                if (!nestedFormula) {
+                    this.parent.dependencyCollection.push(argArr[0]);
+                }
+            }
+            else {
+                this.clearDependency(argArr[0]);
+            }
+            result = this.parent.getValueFromArg(argArr[0]);
+        }
+        else {
+            result = argArr[0].trim();
+            if (this.parent.getErrorStrings().indexOf(result) > -1) {
+                return result;
+            }
+            result = this.parent.removeTics(result);
+        }
+        if (nestedFormula) {
+            return values.join(',');
+        }
+        return result === '' ? '0' : result;
+    };
+    return ArrayFormulas;
+}(FormulaModuleBase));
+export { ArrayFormulas };