@syncfusion/ej2-calculate 35.1.37

package/src/formulas/formula-module-base.js

@@ -0,0 +1,125 @@
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { FormulasErrorsStrings, CommonErrors } from '../common/index';
+/**
+ * Base class for formula category modules registered with {@link BasicFormulas}.
+ *
+ * Provides shared argument parsing helpers used across Compute handlers.
+ *
+ * @hidden
+ */
+var FormulaModuleBase = /** @class */ (function () {
+    /**
+     * @param {FormulaOwner} owner - Formula registration owner whose `parent` is the Calculate engine.
+     */
+    function FormulaModuleBase(owner) {
+        this.owner = owner;
+        this.parent = owner.parent;
+    }
+    /**
+     * @hidden
+     * @param {string} value - specify the value
+     * @returns {number} - Returns parse double value.
+     */
+    FormulaModuleBase.prototype.parseDouble = function (value) {
+        var val = this.parent.parseFloat(value.toString());
+        return !isNaN(val) ? val : NaN;
+    };
+    /**
+     * @hidden
+     * @param {string} range - Cell / range text.
+     * @returns {string} - Sheet token prefix when present.
+     */
+    FormulaModuleBase.prototype.getSheetReference = function (range) {
+        return range.indexOf(this.parent.sheetToken) === 0 && range.lastIndexOf(this.parent.sheetToken) > range.indexOf(this.parent.sheetToken) ? range.substring(0, range.lastIndexOf(this.parent.sheetToken) + 1) : '';
+    };
+    /**
+     * @hidden
+     * @param {string[]} ranges - IFS ranges / criteria.
+     * @param {string} isAvgIfs - AVERAGEIFS marker.
+     * @returns {string | number} - Aggregated IFS result.
+     */
+    FormulaModuleBase.prototype.calculateIFS = function (ranges, isAvgIfs) {
+        var _this = this;
+        if (isNullOrUndefined(ranges) || ranges[0] === '' || ranges.length < 2 || ranges.length > 127 || ranges.length % 2 === 0) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        if (ranges.length === 3 && ranges[2] !== '""') { // SUMIFS and AVERAGEIFS OR operation will contains only 3 arguments.
+            if (ranges[2].includes(this.parent.tic + this.parent.tic)) {
+                var result_1 = '';
+                var sumVal_1;
+                var separator_1 = this.parent.getParseArgumentSeparator();
+                var criterias = ranges[2].split(this.parent.tic + this.parent.tic);
+                criterias.forEach(function (criteria) {
+                    criteria = criteria.trim().split(_this.parent.tic).join('');
+                    if (criteria) {
+                        sumVal_1 = _this.parent.computeIfsFormulas([ranges[0], ranges[1], criteria], _this.parent.falseValue, isAvgIfs).toString();
+                        result_1 += (result_1 ? separator_1 : '') + sumVal_1;
+                    }
+                });
+                return result_1;
+            }
+        }
+        return this.parent.computeIfsFormulas(ranges, this.parent.falseValue, isAvgIfs);
+    };
+    /**
+     * Resolve an argument to a display/text value (strips quotes for literals).
+     *
+     * @hidden
+     * @param {string} arg - Formula argument token.
+     * @returns {string} - Resolved text (may be an error token).
+     */
+    FormulaModuleBase.prototype.resolveTextArg = function (arg) {
+        if (isNullOrUndefined(arg)) {
+            return '';
+        }
+        var value = this.parent.getValueFromArg(arg);
+        var errCollection = this.parent.getErrorStrings();
+        if (errCollection.indexOf(value) > -1) {
+            return value;
+        }
+        if (!this.parent.isCellReference(arg)) {
+            value = this.parent.removeTics(value);
+        }
+        return value;
+    };
+    /**
+     * Resolve an argument to a number (booleans → 1/0).
+     *
+     * @hidden
+     * @param {string} arg - Formula argument token.
+     * @returns {number | string} - Number or error token.
+     */
+    FormulaModuleBase.prototype.resolveNumberArg = function (arg) {
+        var errCollection = this.parent.getErrorStrings();
+        var value = this.parent.getValueFromArg(arg);
+        if (errCollection.indexOf(value) > -1) {
+            return value;
+        }
+        if (value === '') {
+            return 0;
+        }
+        var upper = value.toUpperCase();
+        if (upper === this.parent.trueValue) {
+            return 1;
+        }
+        if (upper === this.parent.falseValue) {
+            return 0;
+        }
+        if (!this.parent.isCellReference(arg)) {
+            value = this.parent.removeTics(value);
+        }
+        if (value.indexOf('%') > -1) {
+            var pct = value.replace('%', '');
+            if (this.parent.isNumber(pct)) {
+                return this.parent.parseFloat(pct) / 100;
+            }
+        }
+        var num = this.parent.parseFloat(value);
+        if (isNaN(num)) {
+            return errCollection[CommonErrors.Value];
+        }
+        return num;
+    };
+    return FormulaModuleBase;
+}());
+export { FormulaModuleBase };

package/src/formulas/formula-owner.d.ts

@@ -0,0 +1,17 @@
+import { Calculate } from '../base/index';
+/**
+ * Host surface shared by {@link BasicFormulas} and formula category modules.
+ *
+ * Category modules register `Compute*` handlers on the owner; cross-formula calls
+ * (for example SUBTOTAL delegating to SUM) resolve through this interface.
+ *
+ * @hidden
+ */
+export interface FormulaOwner {
+    /** Calculate engine that evaluates cell values and hosts the formula library. */
+    parent: Calculate;
+    /** When true, CONCATENATE uses empty-string semantics instead of skipping blanks. */
+    isConcat?: boolean;
+    /** Bound `Compute*` handlers and category-module methods keyed by name. */
+    [key: string]: any;
+}

package/src/formulas/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Built-in Excel / ECMA-376 formula modules for `@syncfusion/ej2-calculate`.
+ *
+ * {@link BasicFormulas} registers every category module with the {@link Calculate}
+ * engine. Each category class exposes public `Compute*` handlers documented with
+ * TSDoc (Excel name, parameters, return value, and examples).
+ *
+ * @packageDocumentation
+ */
+export * from './basic';
+export * from './formula-owner';
+export * from './formula-module-base';
+export * from './formula-math-helpers';
+export * from './math-aggregate';
+export * from './math-rounding';
+export * from './math-misc';
+export * from './math-trig';
+export * from './math-trig-hyperbolic';
+export * from './math-combinatorics';
+export * from './math-number';
+export * from './matrix-base';
+export * from './matrix';
+export * from './engineering-base';
+export * from './engineering-misc';
+export * from './engineering-convert';
+export * from './engineering-bessel';
+export * from './financial-annuity';
+export * from './financial-depreciation';
+export * from './financial-rates';
+export * from './financial-cashflow';
+export * from './financial-securities';
+export * from './statistical';
+export * from './statistical-advanced';
+export * from './statistical-dispersion';
+export * from './statistical-sample-base';
+export * from './statistical-moments';
+export * from './statistical-correlation';
+export * from './statistical-percentile';
+export * from './statistical-distribution';
+export * from './statistical-ifs';
+export * from './statistical-extended';
+export * from './statistical-distribution-extended';
+export * from './complex-numbers';
+export * from './date-time';
+export * from './date-time-extra';
+export * from './logical';
+export * from './logical-extra';
+export * from './lookup';
+export * from './lookup-ref';
+export * from './lookup-ref-extra';
+export * from './lookup-array';
+export * from './array';
+export * from './text';
+export * from './text-extra';
+export * from './text-advanced';
+export * from './information';
+export * from './information-extra';
+export * from './information-advanced';
+export * from './date-time-intl';
+export * from './math-ceiling-ecma';
+export * from './information-ecma';
+export * from './text-ecma';
+export * from './financial-bond-helpers';
+export * from './financial-coupons';
+export * from './financial-amortization-ecma';
+export * from './statistical-ecma';
+export * from './database';
+export * from './regression-ecma';

package/src/formulas/index.js

@@ -0,0 +1,67 @@
+/**
+ * Built-in Excel / ECMA-376 formula modules for `@syncfusion/ej2-calculate`.
+ *
+ * {@link BasicFormulas} registers every category module with the {@link Calculate}
+ * engine. Each category class exposes public `Compute*` handlers documented with
+ * TSDoc (Excel name, parameters, return value, and examples).
+ *
+ * @packageDocumentation
+ */
+export * from './basic';
+export * from './formula-module-base';
+export * from './formula-math-helpers';
+export * from './math-aggregate';
+export * from './math-rounding';
+export * from './math-misc';
+export * from './math-trig';
+export * from './math-trig-hyperbolic';
+export * from './math-combinatorics';
+export * from './math-number';
+export * from './matrix-base';
+export * from './matrix';
+export * from './engineering-base';
+export * from './engineering-misc';
+export * from './engineering-convert';
+export * from './engineering-bessel';
+export * from './financial-annuity';
+export * from './financial-depreciation';
+export * from './financial-rates';
+export * from './financial-cashflow';
+export * from './financial-securities';
+export * from './statistical';
+export * from './statistical-advanced';
+export * from './statistical-dispersion';
+export * from './statistical-sample-base';
+export * from './statistical-moments';
+export * from './statistical-correlation';
+export * from './statistical-percentile';
+export * from './statistical-distribution';
+export * from './statistical-ifs';
+export * from './statistical-extended';
+export * from './statistical-distribution-extended';
+export * from './complex-numbers';
+export * from './date-time';
+export * from './date-time-extra';
+export * from './logical';
+export * from './logical-extra';
+export * from './lookup';
+export * from './lookup-ref';
+export * from './lookup-ref-extra';
+export * from './lookup-array';
+export * from './array';
+export * from './text';
+export * from './text-extra';
+export * from './text-advanced';
+export * from './information';
+export * from './information-extra';
+export * from './information-advanced';
+export * from './date-time-intl';
+export * from './math-ceiling-ecma';
+export * from './information-ecma';
+export * from './text-ecma';
+export * from './financial-bond-helpers';
+export * from './financial-coupons';
+export * from './financial-amortization-ecma';
+export * from './statistical-ecma';
+export * from './database';
+export * from './regression-ecma';

package/src/formulas/information-advanced.d.ts

@@ -0,0 +1,44 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Advanced information utilities including SHEET, SHEETS, and structured reference introspection.
+ *
+ * Registered functions: INFO, CELL.
+ *
+ * @hidden
+ */
+export declare class InformationAdvancedFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns information about the current operating environment.
+     *
+     * Excel: `INFO(...)`.
+     *
+     * @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('=INFO(1)');
+     * ```
+     */
+    ComputeINFO(...args: string[]): string | number;
+    /**
+     * Returns information about the formatting, location, or contents of a cell.
+     *
+     * Excel: `CELL(...)`.
+     *
+     * @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`.
+     */
+    ComputeCELL(...args: string[]): string | number;
+}

package/src/formulas/information-advanced.js

@@ -0,0 +1,157 @@
+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 { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Advanced information utilities including SHEET, SHEETS, and structured reference introspection.
+ *
+ * Registered functions: INFO, CELL.
+ *
+ * @hidden
+ */
+var InformationAdvancedFormulas = /** @class */ (function (_super) {
+    __extends(InformationAdvancedFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function InformationAdvancedFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'INFO', category: 'Information', description: 'Returns information about the current operating environment.' },
+            { formulaName: 'CELL', category: 'Information', description: 'Returns information about the formatting, location, or contents of a cell.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns information about the current operating environment.
+     *
+     * Excel: `INFO(...)`.
+     *
+     * @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('=INFO(1)');
+     * ```
+     */
+    InformationAdvancedFormulas.prototype.ComputeINFO = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var typeText = this.resolveTextArg(args[0]).toLowerCase();
+        if (errCollection.indexOf(typeText) > -1) {
+            return typeText;
+        }
+        var validTypes = ['system', 'release', 'numfile', 'directory', 'origin', 'recalc', 'memavail', 'memused'];
+        if (validTypes.indexOf(typeText) === -1) {
+            return errCollection[CommonErrors.NA];
+        }
+        var infoType = typeText;
+        switch (infoType) {
+            case 'system':
+                return 'pcdos';
+            case 'release':
+                return '16.0';
+            case 'numfile':
+                return '1';
+            case 'directory':
+                return '/';
+            case 'origin':
+                return 'A1';
+            case 'recalc':
+                return this.parent.parentObject.calculationMode === 'Manual' ? 'Manual' : 'Automatic';
+            case 'memavail':
+                return '1048576';
+            case 'memused':
+                return '0';
+            default: {
+                var _exhaustive = infoType;
+                return _exhaustive;
+            }
+        }
+    };
+    /**
+     * Returns information about the formatting, location, or contents of a cell.
+     *
+     * Excel: `CELL(...)`.
+     *
+     * @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`.
+     */
+    InformationAdvancedFormulas.prototype.ComputeCELL = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var infoType = this.resolveTextArg(args[0]).toLowerCase();
+        if (errCollection.indexOf(infoType) > -1) {
+            return infoType;
+        }
+        var ref = args.length === 2 ? args[1] : (this.parent.actCell || this.parent.cell || 'A1');
+        ref = ref.split('$').join('');
+        if (!this.parent.isCellReference(ref.split(':')[0])) {
+            return errCollection[CommonErrors.Value];
+        }
+        var cell = ref.indexOf(':') > -1 ? ref.split(':')[0] : ref;
+        var stripped = cell.indexOf('!') > -1 ? cell.substring(cell.lastIndexOf('!') + 1) : cell;
+        var value = this.parent.getValueFromArg(cell);
+        switch (infoType) {
+            case 'address':
+                return '$' + stripped.replace(/([A-Z]+)(\d+)/, '$1$$$2');
+            case 'col':
+                return this.parent.colIndex(stripped).toString();
+            case 'row':
+                return this.parent.rowIndex(stripped).toString();
+            case 'contents':
+                return value;
+            case 'format':
+                return 'G';
+            case 'prefix':
+                return '';
+            case 'protect':
+                return '0';
+            case 'type':
+                if (value === '') {
+                    return 'b';
+                }
+                if (this.parent.isNumber(value)) {
+                    return 'v';
+                }
+                return 'l';
+            case 'width':
+                return '8';
+            case 'parentheses':
+                return '0';
+            default:
+                return errCollection[CommonErrors.NA];
+        }
+    };
+    return InformationAdvancedFormulas;
+}(FormulaModuleBase));
+export { InformationAdvancedFormulas };

package/src/formulas/information-ecma.d.ts

@@ -0,0 +1,33 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * ECMA information helpers such as ERROR.TYPE for classifying error values.
+ *
+ * Registered functions: ERROR.TYPE.
+ *
+ * @hidden
+ */
+export declare class InformationEcmaFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns a number corresponding to an error type.
+     *
+     * Excel: `ERROR.TYPE(...)`.
+     *
+     * @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('=ERROR.TYPE(1)');
+     * ```
+     */
+    ['ComputeERROR.TYPE'](...args: string[]): string | number;
+}

package/src/formulas/information-ecma.js

@@ -0,0 +1,88 @@
+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 { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * ECMA information helpers such as ERROR.TYPE for classifying error values.
+ *
+ * Registered functions: ERROR.TYPE.
+ *
+ * @hidden
+ */
+var InformationEcmaFormulas = /** @class */ (function (_super) {
+    __extends(InformationEcmaFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function InformationEcmaFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'ERROR.TYPE', category: 'Information', description: 'Returns a number corresponding to an error type.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns a number corresponding to an error type.
+     *
+     * Excel: `ERROR.TYPE(...)`.
+     *
+     * @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('=ERROR.TYPE(1)');
+     * ```
+     */
+    InformationEcmaFormulas.prototype['ComputeERROR.TYPE'] = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var val = this.parent.getValueFromArg(args[0]);
+        var map = {
+            '#NULL!': 1,
+            '#DIV/0!': 2,
+            '#VALUE!': 3,
+            '#REF!': 4,
+            '#NAME?': 5,
+            '#NUM!': 6,
+            '#N/A': 7,
+            '#GETTING_DATA': 8
+        };
+        // eslint-disable-next-line security/detect-object-injection
+        if (map[val] !== undefined) {
+            // eslint-disable-next-line security/detect-object-injection
+            return map[val].toString();
+        }
+        for (var i = 0; i < errCollection.length; i++) {
+            if (val === errCollection[i]) {
+                var idx = i + 1;
+                if (idx >= 1 && idx <= 8) {
+                    return idx.toString();
+                }
+            }
+        }
+        return errCollection[CommonErrors.NA];
+    };
+    return InformationEcmaFormulas;
+}(FormulaModuleBase));
+export { InformationEcmaFormulas };