@syncfusion/ej2-calculate 35.1.37

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

@@ -0,0 +1,146 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Extended information functions: ISBLANK, ISERROR, ISFORMULA, and cell metadata probes.
+ *
+ * Registers 12 functions including ISBLANK, ISTEXT, ISNONTEXT, ISLOGICAL, ISERROR, and others.
+ *
+ * @hidden
+ */
+export declare class InformationExtraFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private requireOne;
+    /**
+     * Returns TRUE if the value is blank.
+     *
+     * Excel: `ISBLANK(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=ISBLANK(1)');
+     * ```
+     */
+    ComputeISBLANK(...args: string[]): boolean | string;
+    /**
+     * Returns TRUE if the value is text.
+     *
+     * Excel: `ISTEXT(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    ComputeISTEXT(...args: string[]): boolean | string;
+    /**
+     * Returns TRUE if the value is not text.
+     *
+     * Excel: `ISNONTEXT(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    ComputeISNONTEXT(...args: string[]): boolean | string;
+    /**
+     * Returns TRUE if the value is a logical value.
+     *
+     * Excel: `ISLOGICAL(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    ComputeISLOGICAL(...args: string[]): boolean | string;
+    /**
+     * Returns TRUE if the value is any error value.
+     *
+     * Excel: `ISERROR(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    ComputeISERROR(...args: string[]): boolean | string;
+    /**
+     * Returns TRUE if the value is any error value except #N/A.
+     *
+     * Excel: `ISERR(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    ComputeISERR(...args: string[]): boolean | string;
+    /**
+     * Returns TRUE if the value is the #N/A error value.
+     *
+     * Excel: `ISNA(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    ComputeISNA(...args: string[]): boolean | string;
+    /**
+     * Returns TRUE if the number is even.
+     *
+     * Excel: `ISEVEN(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    ComputeISEVEN(...args: string[]): boolean | string;
+    /**
+     * Returns TRUE if the number is odd.
+     *
+     * Excel: `ISODD(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    ComputeISODD(...args: string[]): boolean | string;
+    private parity;
+    /**
+     * Returns a value converted to a number.
+     *
+     * Excel: `N(...)`.
+     *
+     * @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`.
+     */
+    ComputeN(...args: string[]): string | number;
+    /**
+     * Returns the error value #N/A.
+     *
+     * Excel: `NA(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    ComputeNA(...args: string[]): string;
+    /**
+     * Returns a number indicating the data type of a value.
+     *
+     * Excel: `TYPE(...)`.
+     *
+     * @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`.
+     */
+    ComputeTYPE(...args: string[]): string | number;
+}

package/src/formulas/information-extra.js

@@ -0,0 +1,351 @@
+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';
+/**
+ * Extended information functions: ISBLANK, ISERROR, ISFORMULA, and cell metadata probes.
+ *
+ * Registers 12 functions including ISBLANK, ISTEXT, ISNONTEXT, ISLOGICAL, ISERROR, and others.
+ *
+ * @hidden
+ */
+var InformationExtraFormulas = /** @class */ (function (_super) {
+    __extends(InformationExtraFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function InformationExtraFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'ISBLANK', category: 'Information', description: 'Returns TRUE if the value is blank.' },
+            { formulaName: 'ISTEXT', category: 'Information', description: 'Returns TRUE if the value is text.' },
+            { formulaName: 'ISNONTEXT', category: 'Information', description: 'Returns TRUE if the value is not text.' },
+            { formulaName: 'ISLOGICAL', category: 'Information', description: 'Returns TRUE if the value is a logical value.' },
+            { formulaName: 'ISERROR', category: 'Information', description: 'Returns TRUE if the value is any error value.' },
+            { formulaName: 'ISERR', category: 'Information', description: 'Returns TRUE if the value is any error value except #N/A.' },
+            { formulaName: 'ISNA', category: 'Information', description: 'Returns TRUE if the value is the #N/A error value.' },
+            { formulaName: 'ISEVEN', category: 'Information', description: 'Returns TRUE if the number is even.' },
+            { formulaName: 'ISODD', category: 'Information', description: 'Returns TRUE if the number is odd.' },
+            { formulaName: 'N', category: 'Information', description: 'Returns a value converted to a number.' },
+            { formulaName: 'NA', category: 'Information', description: 'Returns the error value #N/A.' },
+            { formulaName: 'TYPE', category: 'Information', description: 'Returns a number indicating the data type of a value.' }
+        ];
+        return _this;
+    }
+    InformationExtraFormulas.prototype.requireOne = function (args) {
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return null;
+    };
+    /**
+     * Returns TRUE if the value is blank.
+     *
+     * Excel: `ISBLANK(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=ISBLANK(1)');
+     * ```
+     */
+    InformationExtraFormulas.prototype.ComputeISBLANK = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        if (this.parent.isCellReference(args[0])) {
+            return this.parent.getValueFromArg(args[0]) === '';
+        }
+        var val = this.parent.getValueFromArg(args[0]);
+        return val === '';
+    };
+    /**
+     * Returns TRUE if the value is text.
+     *
+     * Excel: `ISTEXT(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    InformationExtraFormulas.prototype.ComputeISTEXT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        var val = this.parent.getValueFromArg(args[0]);
+        if (this.parent.getErrorStrings().indexOf(val) > -1) {
+            return false;
+        }
+        if (val === '') {
+            return false;
+        }
+        if (val.toUpperCase() === this.parent.trueValue || val.toUpperCase() === this.parent.falseValue) {
+            return false;
+        }
+        return isNaN(this.parent.parseFloat(val)) || (!this.parent.isCellReference(args[0]) && args[0].indexOf(this.parent.tic) > -1);
+    };
+    /**
+     * Returns TRUE if the value is not text.
+     *
+     * Excel: `ISNONTEXT(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    InformationExtraFormulas.prototype.ComputeISNONTEXT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var result = this.ComputeISTEXT.apply(this, args);
+        return typeof result === 'string' ? result : !result;
+    };
+    /**
+     * Returns TRUE if the value is a logical value.
+     *
+     * Excel: `ISLOGICAL(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    InformationExtraFormulas.prototype.ComputeISLOGICAL = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        var val = this.parent.getValueFromArg(args[0]).toUpperCase();
+        return val === this.parent.trueValue || val === this.parent.falseValue;
+    };
+    /**
+     * Returns TRUE if the value is any error value.
+     *
+     * Excel: `ISERROR(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    InformationExtraFormulas.prototype.ComputeISERROR = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        var val = this.parent.getValueFromArg(args[0]);
+        return this.parent.getErrorStrings().indexOf(val) > -1 || /^#[A-Z/?!]+$/.test(val);
+    };
+    /**
+     * Returns TRUE if the value is any error value except #N/A.
+     *
+     * Excel: `ISERR(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    InformationExtraFormulas.prototype.ComputeISERR = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        var val = this.parent.getValueFromArg(args[0]);
+        if (val === this.parent.getErrorStrings()[CommonErrors.NA] || val === '#N/A') {
+            return false;
+        }
+        return this.parent.getErrorStrings().indexOf(val) > -1 || /^#[A-Z/?!]+$/.test(val);
+    };
+    /**
+     * Returns TRUE if the value is the #N/A error value.
+     *
+     * Excel: `ISNA(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    InformationExtraFormulas.prototype.ComputeISNA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        var val = this.parent.getValueFromArg(args[0]);
+        return val === this.parent.getErrorStrings()[CommonErrors.NA] || val === '#N/A';
+    };
+    /**
+     * Returns TRUE if the number is even.
+     *
+     * Excel: `ISEVEN(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    InformationExtraFormulas.prototype.ComputeISEVEN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.parity(args, true);
+    };
+    /**
+     * Returns TRUE if the number is odd.
+     *
+     * Excel: `ISODD(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    InformationExtraFormulas.prototype.ComputeISODD = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.parity(args, false);
+    };
+    InformationExtraFormulas.prototype.parity = function (args, wantEven) {
+        var errCollection = this.parent.getErrorStrings();
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        var num = this.resolveNumberArg(args[0]);
+        if (typeof num === 'string') {
+            return errCollection[CommonErrors.Value];
+        }
+        var truncated = num < 0 ? Math.ceil(num) : Math.floor(num);
+        var even = truncated % 2 === 0;
+        return wantEven ? even : !even;
+    };
+    /**
+     * Returns a value converted to a number.
+     *
+     * Excel: `N(...)`.
+     *
+     * @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`.
+     */
+    InformationExtraFormulas.prototype.ComputeN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        var val = this.parent.getValueFromArg(args[0]);
+        if (errCollection.indexOf(val) > -1) {
+            return val;
+        }
+        if (val.toUpperCase() === this.parent.trueValue) {
+            return '1';
+        }
+        if (val.toUpperCase() === this.parent.falseValue || val === '') {
+            return '0';
+        }
+        var num = this.parent.parseFloat(val);
+        return isNaN(num) ? '0' : num.toString();
+    };
+    /**
+     * Returns the error value #N/A.
+     *
+     * Excel: `NA(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    InformationExtraFormulas.prototype.ComputeNA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (args && args.length === 1 && args[0] === '') {
+            return this.parent.getErrorStrings()[CommonErrors.NA];
+        }
+        if (args && args.length > 0 && !(args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return this.parent.getErrorStrings()[CommonErrors.NA];
+    };
+    /**
+     * Returns a number indicating the data type of a value.
+     *
+     * Excel: `TYPE(...)`.
+     *
+     * @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`.
+     */
+    InformationExtraFormulas.prototype.ComputeTYPE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var bad = this.requireOne(args);
+        if (bad) {
+            return bad;
+        }
+        var val = this.parent.getValueFromArg(args[0]);
+        if (this.parent.getErrorStrings().indexOf(val) > -1 || /^#[A-Z/?!]+$/.test(val)) {
+            return '16';
+        }
+        if (val.toUpperCase() === this.parent.trueValue || val.toUpperCase() === this.parent.falseValue) {
+            return '4';
+        }
+        if (val !== '' && !isNaN(this.parent.parseFloat(val)) &&
+            (this.parent.isCellReference(args[0]) || args[0].indexOf(this.parent.tic) === -1)) {
+            return '1';
+        }
+        return '2';
+    };
+    return InformationExtraFormulas;
+}(FormulaModuleBase));
+export { InformationExtraFormulas };

package/src/formulas/information.d.ts

@@ -0,0 +1,34 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Type and content inspection functions that classify cell values (numbers, text, errors).
+ *
+ * Registered functions: ISNUMBER.
+ *
+ * @hidden
+ */
+export declare class InformationFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns TRUE, if the argument is number and FALSE otherwise.
+     *
+     * Excel: `ISNUMBER(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=ISNUMBER(1)');
+     * ```
+     */
+    ComputeISNUMBER(...args: string[]): boolean | string;
+}

package/src/formulas/information.js

@@ -0,0 +1,78 @@
+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 } from '../common/index';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Type and content inspection functions that classify cell values (numbers, text, errors).
+ *
+ * Registered functions: ISNUMBER.
+ *
+ * @hidden
+ */
+var InformationFormulas = /** @class */ (function (_super) {
+    __extends(InformationFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function InformationFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'ISNUMBER', category: 'Information', description: 'Returns TRUE, if the argument is number and FALSE otherwise.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns TRUE, if the argument is number and FALSE otherwise.
+     *
+     * Excel: `ISNUMBER(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=ISNUMBER(1)');
+     * ```
+     */
+    InformationFormulas.prototype.ComputeISNUMBER = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        var isNestedFormula;
+        if (argArr && argArr[argArr.length - 1] === 'nestedFormulaTrue') {
+            isNestedFormula = true;
+            argArr.pop();
+        }
+        if (args.length === 1 && args[0] === '') {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var orgValue = (this.parent.isCellReference(argArr[0])) ? this.parent.getValueFromArg(argArr[0]) :
+            this.parent.getValueFromArg(argArr[0].split(this.parent.tic).join(''));
+        if (orgValue.toString() === '' || args.toString().startsWith(this.parent.tic)) {
+            return isNestedFormula ? '0' : false;
+        }
+        var isLogVal = !isNaN(this.parent.parseFloat(orgValue));
+        return isNestedFormula ? (isLogVal ? '1' : '0') : isLogVal;
+    };
+    return InformationFormulas;
+}(FormulaModuleBase));
+export { InformationFormulas };

package/src/formulas/logical-extra.d.ts

@@ -0,0 +1,75 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Extended logical helpers including IFS, SWITCH, XOR, and multi-condition boolean tests.
+ *
+ * Registered functions: TRUE, FALSE, XOR, IFNA, SWITCH.
+ *
+ * @hidden
+ */
+export declare class LogicalExtraFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the logical value TRUE.
+     *
+     * Excel: `TRUE(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=TRUE(1)');
+     * ```
+     */
+    ComputeTRUE(...args: string[]): string;
+    /**
+     * Returns the logical value FALSE.
+     *
+     * Excel: `FALSE(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    ComputeFALSE(...args: string[]): string;
+    private isTruthy;
+    /**
+     * Returns a logical exclusive OR of all arguments.
+     *
+     * Excel: `XOR(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    ComputeXOR(...args: string[]): string;
+    /**
+     * Returns the value you specify if the expression resolves to #N/A; otherwise returns the result of the expression.
+     *
+     * Excel: `IFNA(...)`.
+     *
+     * @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`.
+     */
+    ComputeIFNA(...args: string[]): string | number;
+    /**
+     * Evaluates an expression against a list of values and returns the result corresponding to the first matching value.
+     *
+     * Excel: `SWITCH(...)`.
+     *
+     * @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`.
+     */
+    ComputeSWITCH(...args: string[]): string | number;
+}