@syncfusion/ej2-calculate 35.1.37

package/src/formulas/date-time-intl.js

@@ -0,0 +1,309 @@
+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';
+/**
+ * Locale-aware and ECMA date functions including DATEDIF and custom-weekend WORKDAY/NETWORKDAYS variants.
+ *
+ * Registered functions: DATEDIF, NETWORKDAYS.INTL, WORKDAY.INTL.
+ *
+ * @hidden
+ */
+var DateTimeIntlFormulas = /** @class */ (function (_super) {
+    __extends(DateTimeIntlFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function DateTimeIntlFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'DATEDIF', category: 'Date & Time', description: 'Calculates the number of days, months, or years between two dates.' },
+            { formulaName: 'NETWORKDAYS.INTL', category: 'Date & Time', description: 'Returns workdays between dates for a custom weekend.' },
+            { formulaName: 'WORKDAY.INTL', category: 'Date & Time', description: 'Returns the date before or after a number of workdays with a custom weekend.' }
+        ];
+        return _this;
+    }
+    DateTimeIntlFormulas.prototype.toSerial = function (arg) {
+        var errCollection = this.parent.getErrorStrings();
+        var value = this.parent.getValueFromArg(arg);
+        if (errCollection.indexOf(value) > -1) {
+            return value;
+        }
+        if (!this.parent.isCellReference(arg)) {
+            value = this.parent.removeTics(value);
+        }
+        if (value === '') {
+            return errCollection[CommonErrors.Value];
+        }
+        if (this.parent.isNumber(value)) {
+            return Math.floor(this.parent.parseFloat(value));
+        }
+        var parsed = this.parent.isDate(new Date(value));
+        if (parsed) {
+            return Math.floor(this.parent.toOADate(parsed));
+        }
+        return errCollection[CommonErrors.Value];
+    };
+    DateTimeIntlFormulas.prototype.holidaySet = function (arg) {
+        var set = new Set();
+        if (!arg || arg === '') {
+            return set;
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (this.parent.isCellReference(arg) && arg.indexOf(':') > -1) {
+            var cells = this.parent.getCellCollection(arg);
+            var list = Array.isArray(cells) ? cells : [cells];
+            for (var i = 0; i < list.length; i++) {
+                var serial = this.toSerial(list[i]);
+                if (typeof serial === 'string') {
+                    if (errCollection.indexOf(serial) > -1) {
+                        return serial;
+                    }
+                    continue;
+                }
+                set.add(serial);
+            }
+        }
+        else {
+            var serial = this.toSerial(arg);
+            if (typeof serial === 'string') {
+                return serial;
+            }
+            set.add(serial);
+        }
+        return set;
+    };
+    DateTimeIntlFormulas.prototype.weekendMask = function (weekendArg) {
+        var defaultMask = [false, false, false, false, false, true, true];
+        if (!weekendArg || weekendArg === '') {
+            return defaultMask;
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var text = this.resolveTextArg(weekendArg);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        if (text.length === 7 && /^[01]+$/.test(text)) {
+            var mask = [];
+            for (var i = 0; i < 7; i++) {
+                mask.push(text.charAt(i) === '1');
+            }
+            return mask;
+        }
+        var num = this.resolveNumberArg(weekendArg);
+        if (typeof num === 'string') {
+            return num;
+        }
+        var n = Math.floor(num);
+        var masks = {
+            1: [false, false, false, false, false, true, true],
+            2: [true, false, false, false, false, false, true],
+            3: [true, true, false, false, false, false, false],
+            4: [false, true, true, false, false, false, false],
+            5: [false, false, true, true, false, false, false],
+            6: [false, false, false, true, true, false, false],
+            7: [false, false, false, false, true, true, false],
+            11: [true, false, false, false, false, false, false],
+            12: [false, true, false, false, false, false, false],
+            13: [false, false, true, false, false, false, false],
+            14: [false, false, false, true, false, false, false],
+            15: [false, false, false, false, true, false, false],
+            16: [false, false, false, false, false, true, false],
+            17: [false, false, false, false, false, false, true]
+        };
+        // eslint-disable-next-line security/detect-object-injection
+        return masks[n] || errCollection[CommonErrors.Num];
+    };
+    DateTimeIntlFormulas.prototype.isWeekendMask = function (date, mask) {
+        var dow = (date.getDay() + 6) % 7;
+        return mask[dow];
+    };
+    /**
+     * Calculates the number of days, months, or years between two dates.
+     *
+     * Excel: `DATEDIF(...)`.
+     *
+     * @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('=DATEDIF(DATE(2020,1,1),DATE(2024,1,1),"Y")');
+     * ```
+     */
+    DateTimeIntlFormulas.prototype.ComputeDATEDIF = 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 !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var start = this.toSerial(args[0]);
+        var end = this.toSerial(args[1]);
+        if (typeof start === 'string') {
+            return start;
+        }
+        if (typeof end === 'string') {
+            return end;
+        }
+        var unit = this.resolveTextArg(args[2]).toUpperCase();
+        if (start > end) {
+            return errCollection[CommonErrors.Num];
+        }
+        var d1 = this.parent.fromOADate(start);
+        var d2 = this.parent.fromOADate(end);
+        switch (unit) {
+            case 'Y':
+                return (d2.getFullYear() - d1.getFullYear() -
+                    (d2.getMonth() < d1.getMonth() || (d2.getMonth() === d1.getMonth() && d2.getDate() < d1.getDate()) ? 1 : 0)).toString();
+            case 'M': {
+                var months = (d2.getFullYear() - d1.getFullYear()) * 12 + (d2.getMonth() - d1.getMonth());
+                if (d2.getDate() < d1.getDate()) {
+                    months--;
+                }
+                return months.toString();
+            }
+            case 'D':
+                return (end - start).toString();
+            case 'MD': {
+                var md = d2.getDate() - d1.getDate();
+                if (md < 0) {
+                    md += new Date(d2.getFullYear(), d2.getMonth(), 0).getDate();
+                }
+                return md.toString();
+            }
+            case 'YM': {
+                var ym = d2.getMonth() - d1.getMonth();
+                if (d2.getDate() < d1.getDate()) {
+                    ym--;
+                }
+                if (ym < 0) {
+                    ym += 12;
+                }
+                return ym.toString();
+            }
+            case 'YD': {
+                var anchor = new Date(d2.getFullYear(), d1.getMonth(), d1.getDate());
+                var yd = Math.round((d2.getTime() - anchor.getTime()) / 86400000);
+                if (yd < 0) {
+                    yd += this.isLeapYear(d2.getFullYear()) ? 366 : 365;
+                }
+                return yd.toString();
+            }
+            default:
+                return errCollection[CommonErrors.Num];
+        }
+    };
+    DateTimeIntlFormulas.prototype.isLeapYear = function (year) {
+        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    };
+    /**
+     * Returns workdays between dates for a custom weekend.
+     *
+     * Excel: `NETWORKDAYS.INTL(...)`.
+     *
+     * @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`.
+     */
+    DateTimeIntlFormulas.prototype['ComputeNETWORKDAYS.INTL'] = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 2 || args.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var start = this.toSerial(args[0]);
+        var end = this.toSerial(args[1]);
+        if (typeof start === 'string') {
+            return start;
+        }
+        if (typeof end === 'string') {
+            return end;
+        }
+        var mask = this.weekendMask(args[2]);
+        if (!(mask instanceof Array)) {
+            return mask;
+        }
+        var holidays = this.holidaySet(args[3]);
+        if (!(holidays instanceof Set)) {
+            return holidays;
+        }
+        var step = start <= end ? 1 : -1;
+        var count = 0;
+        for (var s = start; step > 0 ? s <= end : s >= end; s += step) {
+            var d = this.parent.fromOADate(s);
+            if (!this.isWeekendMask(d, mask) && !holidays.has(s)) {
+                count += step;
+            }
+        }
+        return count.toString();
+    };
+    /**
+     * Returns the date before or after a number of workdays with a custom weekend.
+     *
+     * Excel: `WORKDAY.INTL(...)`.
+     *
+     * @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`.
+     */
+    DateTimeIntlFormulas.prototype['ComputeWORKDAY.INTL'] = 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 < 2 || args.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var start = this.toSerial(args[0]);
+        var daysArg = this.resolveNumberArg(args[1]);
+        if (typeof start === 'string') {
+            return start;
+        }
+        if (typeof daysArg === 'string') {
+            return daysArg;
+        }
+        var mask = this.weekendMask(args[2]);
+        if (!(mask instanceof Array)) {
+            return mask;
+        }
+        var holidays = this.holidaySet(args[3]);
+        if (!(holidays instanceof Set)) {
+            return holidays;
+        }
+        var current = start;
+        var step = daysArg >= 0 ? 1 : -1;
+        var remaining = Math.abs(Math.trunc(daysArg));
+        while (remaining > 0) {
+            current += step;
+            var d = this.parent.fromOADate(current);
+            if (!this.isWeekendMask(d, mask) && !holidays.has(current)) {
+                remaining--;
+            }
+            if (current < 0) {
+                return errCollection[CommonErrors.Num];
+            }
+        }
+        return current.toString();
+    };
+    return DateTimeIntlFormulas;
+}(FormulaModuleBase));
+export { DateTimeIntlFormulas };

package/src/formulas/date-time.d.ts

@@ -0,0 +1,164 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Date and time construction, extraction, and serial-number conversion for spreadsheet calendars.
+ *
+ * Registers 14 functions including DATE, DAY, TODAY, DAYS, WEEKDAY, and others.
+ *
+ * @hidden
+ */
+export declare class DateTimeFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the date, given the year, month and day of the month.
+     *
+     * Excel: `DATE(...)`.
+     *
+     * @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('=DATE(2024,1,15)');
+     * ```
+     */
+    ComputeDATE(...args: string[]): Date | string;
+    /**
+     * Returns the day of a given date.
+     *
+     * Excel: `DAY(...)`.
+     *
+     * @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`.
+     */
+    ComputeDAY(...args: string[]): number | string;
+    /**
+     * Returns the current date as date value.
+     *
+     * Excel: `TODAY(...)`.
+     *
+     * @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`.
+     */
+    ComputeTODAY(...args: string[]): Date | string;
+    /**
+     * Returns the number of days between two dates.
+     *
+     * Excel: `DAYS(...)`.
+     *
+     * @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`.
+     */
+    ComputeDAYS(...args: string[]): number | string;
+    /**
+     * Returns the day of the week corresponding to a date.
+     *
+     * Excel: `WEEKDAY(...)`.
+     *
+     * @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`.
+     */
+    ComputeWEEKDAY(...args: string[]): number | string;
+    /**
+     * Converts hours, minutes, seconds to the time formatted text.
+     *
+     * Excel: `TIME(...)`.
+     *
+     * @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`.
+     */
+    ComputeTIME(...args: string[]): string | number;
+    /**
+     * Returns a date with given number of months before or after the specified date.
+     *
+     * Excel: `EDATE(...)`.
+     *
+     * @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`.
+     */
+    ComputeEDATE(...args: string[]): Date | string;
+    /**
+     * Returns the last day of the month that is a specified number of months before or after an initially supplied start date.
+     *
+     * Excel: `EOMONTH(...)`.
+     *
+     * @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`.
+     */
+    ComputeEOMONTH(...args: string[]): Date | string;
+    /**
+     * Converts a date string into date value.
+     *
+     * Excel: `DATEVALUE(...)`.
+     *
+     * @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`.
+     */
+    ComputeDATEVALUE(...args: string[]): Date | string;
+    /**
+     * Returns the number of hours in a specified time string.
+     *
+     * Excel: `HOUR(...)`.
+     *
+     * @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`.
+     */
+    ComputeHOUR(...args: string[]): number | string;
+    /**
+     * Returns the number of minutes in a specified time string.
+     *
+     * Excel: `MINUTE(...)`.
+     *
+     * @hidden
+     * @param {string[]} argArr - 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`.
+     */
+    ComputeMINUTE(...argArr: string[]): number | string;
+    /**
+     * Returns the number of seconds in a specified time string.
+     *
+     * Excel: `SECOND(...)`.
+     *
+     * @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`.
+     */
+    ComputeSECOND(...args: string[]): number | string;
+    /**
+     * Returns the current date and time.
+     *
+     * Excel: `NOW(...)`.
+     *
+     * @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!`.
+     */
+    ComputeNOW(...args: string[]): string;
+    /**
+     * Returns the number of months in a specified date string.
+     *
+     * Excel: `MONTH(...)`.
+     *
+     * @hidden
+     * @param {string[]} argsVal - 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`.
+     */
+    ComputeMONTH(...argsVal: string[]): number | string;
+}