@cj-tech-master/excelts 9.3.1 → 9.4.0

package/dist/cjs/modules/formula/functions/conditional.js

@@ -58,35 +58,57 @@ function buildCriteriaPredicateRV(criteria) {
         // blank (→0); numeric strings are NOT coerced (COUNTIF stays textual
         // for those). Only real Number / Boolean / Blank cells participate in
         // numeric comparisons; everything else falls back to string compare.
-        const numericOf = (v) => {
-            if (v.kind === 1 /* RVKind.Number */) {
-                return v.value;
-            }
-            if (v.kind === 3 /* RVKind.Boolean */) {
-                return v.value ? 1 : 0;
-            }
-            if (v.kind === 0 /* RVKind.Blank */) {
-                return 0;
-            }
-            return Number.NaN;
-        };
+        if (isNum) {
+            // Specialised numeric-comparison path — avoids per-cell string
+            // coercion allocations that dominate the hot loop otherwise.
+            // Non-numeric cells produce NaN and fall through to the switch,
+            // where only `<>` evaluates NaN-relations to TRUE (Excel semantics).
+            return (v) => {
+                const vn = v.kind === 1 /* RVKind.Number */
+                    ? v.value
+                    : v.kind === 3 /* RVKind.Boolean */
+                        ? v.value
+                            ? 1
+                            : 0
+                        : v.kind === 0 /* RVKind.Blank */
+                            ? 0
+                            : Number.NaN;
+                switch (op) {
+                    case "=":
+                        return vn === numVal;
+                    case "<>":
+                        return vn !== numVal;
+                    case ">":
+                        return vn > numVal;
+                    case "<":
+                        return vn < numVal;
+                    case ">=":
+                        return vn >= numVal;
+                    case "<=":
+                        return vn <= numVal;
+                    default:
+                        return false;
+                }
+            };
+        }
+        // String-comparison path — lowercase the criterion once outside the
+        // closure so every cell only pays a single `toStringRV().toLowerCase()`.
+        const cs = valStr.toLowerCase();
         return (v) => {
-            const vn = numericOf(v);
             const vs = (0, values_1.toStringRV)(v).toLowerCase();
-            const cs = valStr.toLowerCase();
             switch (op) {
                 case "=":
-                    return isNum ? vn === numVal : vs === cs;
+                    return vs === cs;
                 case "<>":
-                    return isNum ? vn !== numVal : vs !== cs;
+                    return vs !== cs;
                 case ">":
-                    return isNum ? vn > numVal : vs > cs;
+                    return vs > cs;
                 case "<":
-                    return isNum ? vn < numVal : vs < cs;
+                    return vs < cs;
                 case ">=":
-                    return isNum ? vn >= numVal : vs >= cs;
+                    return vs >= cs;
                 case "<=":
-                    return isNum ? vn <= numVal : vs <= cs;
+                    return vs <= cs;
                 default:
                     return false;
             }
@@ -96,14 +118,19 @@ function buildCriteriaPredicateRV(criteria) {
     // literal `*`, `?`, `~` and everything else as a regex special character
     // that must be escaped. Only an unescaped `*` or `?` triggers the wildcard
     // path; a pattern like `~*` matches a literal asterisk.
+    //
+    // Excel restricts wildcard matching to TEXT cells — a criterion like
+    // `"1*"` must not match the number 1 even though `String(1) === "1"`.
+    // Without this guard, `COUNTIF({1, 15, "15"}, "1*")` would return 3
+    // instead of the correct `1` (only the string `"15"` matches).
     if ((0, _shared_1.hasUnescapedWildcard)(s)) {
         try {
             const re = new RegExp("^" + (0, _shared_1.excelWildcardToRegex)(s) + "$", "i");
-            return v => re.test((0, values_1.toStringRV)(v));
+            return v => v.kind === 2 /* RVKind.String */ && re.test(v.value);
         }
         catch {
             const literal = (0, _shared_1.unescapeExcelWildcard)(s).toLowerCase();
-            return v => (0, values_1.toStringRV)(v).toLowerCase() === literal;
+            return v => v.kind === 2 /* RVKind.String */ && v.value.toLowerCase() === literal;
         }
     }
     // No wildcards: strip any `~` escapes and do a literal case-insensitive compare.
@@ -144,6 +171,12 @@ function fnSUMIF(args) {
         for (let c = 0; c < rangeArr.width; c++) {
             if (pred((0, _shared_1.getCell)(rangeArr, r, c))) {
                 const sv = (0, _shared_1.getCell)(sumArr, r, c);
+                // Excel propagates errors from the sum-range; previously we
+                // silently skipped them, masking `#DIV/0!` / `#VALUE!` cells
+                // under the aggregation.
+                if (sv.kind === 4 /* RVKind.Error */) {
+                    return sv;
+                }
                 if (sv.kind === 1 /* RVKind.Number */) {
                     sum += sv.value;
                 }
@@ -216,12 +249,23 @@ function fnSUMIFS(args) {
         return pairs.error;
     }
     let sum = 0;
+    let sumErr = null;
     iterateMultiCriteria(sumArr, pairs.pairs, (r, c) => {
+        if (sumErr) {
+            return;
+        }
         const sv = (0, _shared_1.getCell)(sumArr, r, c);
+        if (sv.kind === 4 /* RVKind.Error */) {
+            sumErr = sv;
+            return;
+        }
         if (sv.kind === 1 /* RVKind.Number */) {
             sum += sv.value;
         }
     });
+    if (sumErr) {
+        return sumErr;
+    }
     return (0, values_1.rvNumber)(sum);
 }
 function fnCOUNTIF(args) {
@@ -279,6 +323,10 @@ function fnAVERAGEIF(args) {
         for (let c = 0; c < rangeArr.width; c++) {
             if (pred((0, _shared_1.getCell)(rangeArr, r, c))) {
                 const sv = (0, _shared_1.getCell)(avgArr, r, c);
+                // Propagate errors from the average-range — see SUMIF for rationale.
+                if (sv.kind === 4 /* RVKind.Error */) {
+                    return sv;
+                }
                 if (sv.kind === 1 /* RVKind.Number */) {
                     sum += sv.value;
                     count++;
@@ -299,13 +347,24 @@ function fnAVERAGEIFS(args) {
     }
     let sum = 0;
     let count = 0;
+    let avgErr = null;
     iterateMultiCriteria(avgArr, pairs.pairs, (r, c) => {
+        if (avgErr) {
+            return;
+        }
         const sv = (0, _shared_1.getCell)(avgArr, r, c);
+        if (sv.kind === 4 /* RVKind.Error */) {
+            avgErr = sv;
+            return;
+        }
         if (sv.kind === 1 /* RVKind.Number */) {
             sum += sv.value;
             count++;
         }
     });
+    if (avgErr) {
+        return avgErr;
+    }
     return count === 0 ? values_1.ERRORS.DIV0 : (0, values_1.rvNumber)(sum / count);
 }
 function fnMAXIFS(args) {
@@ -319,8 +378,16 @@ function fnMAXIFS(args) {
     }
     let result = -Infinity;
     let found = false;
+    let maxErr = null;
     iterateMultiCriteria(maxArr, pairs.pairs, (r, c) => {
+        if (maxErr) {
+            return;
+        }
         const sv = (0, _shared_1.getCell)(maxArr, r, c);
+        if (sv.kind === 4 /* RVKind.Error */) {
+            maxErr = sv;
+            return;
+        }
         if (sv.kind === 1 /* RVKind.Number */) {
             if (sv.value > result) {
                 result = sv.value;
@@ -328,6 +395,9 @@ function fnMAXIFS(args) {
             found = true;
         }
     });
+    if (maxErr) {
+        return maxErr;
+    }
     return (0, values_1.rvNumber)(found ? result : 0);
 }
 function fnMINIFS(args) {
@@ -341,8 +411,16 @@ function fnMINIFS(args) {
     }
     let result = Infinity;
     let found = false;
+    let minErr = null;
     iterateMultiCriteria(minArr, pairs.pairs, (r, c) => {
+        if (minErr) {
+            return;
+        }
         const sv = (0, _shared_1.getCell)(minArr, r, c);
+        if (sv.kind === 4 /* RVKind.Error */) {
+            minErr = sv;
+            return;
+        }
         if (sv.kind === 1 /* RVKind.Number */) {
             if (sv.value < result) {
                 result = sv.value;
@@ -350,5 +428,8 @@ function fnMINIFS(args) {
             found = true;
         }
     });
+    if (minErr) {
+        return minErr;
+    }
     return (0, values_1.rvNumber)(found ? result : 0);
 }

package/dist/cjs/modules/formula/functions/date.js

@@ -39,6 +39,11 @@ function collectHolidays(arg) {
     if ((0, values_1.isArray)(arg)) {
         for (const row of arg.rows) {
             for (const cell of row) {
+                // Propagate errors from the holidays list rather than silently
+                // skipping them — Excel surfaces `#N/A` from a holiday cell.
+                if (cell.kind === 4 /* RVKind.Error */) {
+                    return cell;
+                }
                 if (cell.kind === 1 /* RVKind.Number */) {
                     set.add(Math.floor(cell.value));
                 }
@@ -46,6 +51,9 @@ function collectHolidays(arg) {
         }
     }
     else {
+        if (arg.kind === 4 /* RVKind.Error */) {
+            return arg;
+        }
         const n = (0, values_1.toNumberRV)(arg);
         if (n.kind === 1 /* RVKind.Number */) {
             set.add(Math.floor(n.value));
@@ -219,7 +227,10 @@ const fnWEEKDAY = args => {
         return n;
     }
     const d = toDate(n.value);
-    const returnType = args.length > 1 ? (0, _shared_1.argToNumber)(args[1]) : (0, values_1.rvNumber)(1);
+    // Blank `return_type` → Excel default 1 (Sun=1..Sat=7). Without the
+    // blank guard, `argToNumber(BLANK)` coerces to 0 which falls to the
+    // default branch and yields a spurious #NUM! for `WEEKDAY(date, )`.
+    const returnType = args.length > 1 && args[1].kind !== 0 /* RVKind.Blank */ ? (0, _shared_1.argToNumber)(args[1]) : (0, values_1.rvNumber)(1);
     if ((0, values_1.isError)(returnType)) {
         return returnType;
     }
@@ -253,8 +264,14 @@ const fnEOMONTH = args => {
     if ((0, values_1.isError)(months)) {
         return months;
     }
+    // Excel truncates `months` toward zero before doing month arithmetic.
+    // `Date.UTC` happens to truncate too, but the explicit `Math.trunc`
+    // makes the contract visible and protects against engines that might
+    // not (or against a future refactor that routes through a different
+    // date constructor).
+    const m = Math.trunc(months.value);
     const d = toDate(startDate.value);
-    const result = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + months.value + 1, 0));
+    const result = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + m + 1, 0));
     return (0, values_1.rvNumber)(fromDate(result));
 };
 exports.fnEOMONTH = fnEOMONTH;
@@ -267,8 +284,19 @@ const fnEDATE = args => {
     if ((0, values_1.isError)(months)) {
         return months;
     }
+    const m = Math.trunc(months.value);
     const d = toDate(startDate.value);
-    const result = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + months.value, d.getUTCDate()));
+    // Excel clamps to the last day of the target month when the source day
+    // would overflow (e.g. `EDATE(2024-01-31, 1)` → 2024-02-29, not rolling
+    // forward into March). JS Date.UTC rolls over by default, so we detect
+    // the overflow and clamp explicitly. To do so we first construct the
+    // 1st of the target month, read `daysInMonth` via the "day 0 of next
+    // month" trick, and cap the original day at that.
+    const targetYearMonth = d.getUTCMonth() + m;
+    const firstOfTarget = new Date(Date.UTC(d.getUTCFullYear(), targetYearMonth, 1));
+    const lastDayOfTarget = new Date(Date.UTC(firstOfTarget.getUTCFullYear(), firstOfTarget.getUTCMonth() + 1, 0)).getUTCDate();
+    const clampedDay = Math.min(d.getUTCDate(), lastDayOfTarget);
+    const result = new Date(Date.UTC(firstOfTarget.getUTCFullYear(), firstOfTarget.getUTCMonth(), clampedDay));
     return (0, values_1.rvNumber)(fromDate(result));
 };
 exports.fnEDATE = fnEDATE;
@@ -285,7 +313,7 @@ const fnDATEDIF = args => {
     if (endN.value < startN.value) {
         return values_1.ERRORS.NUM;
     }
-    const unit = (0, values_1.toStringRV)(args[2]).toUpperCase();
+    const unit = (0, values_1.toStringRV)((0, values_1.topLeft)(args[2])).toUpperCase();
     const startD = toDate(startN.value);
     const endD = toDate(endN.value);
     const sy = startD.getUTCFullYear();
@@ -372,7 +400,9 @@ const fnWEEKNUM = args => {
         return n;
     }
     const d = toDate(n.value);
-    const returnType = args.length > 1 ? (0, _shared_1.argToNumber)(args[1]) : (0, values_1.rvNumber)(1);
+    // Blank `return_type` → Excel default 1 (Sunday start). See WEEKDAY
+    // for the same rationale.
+    const returnType = args.length > 1 && args[1].kind !== 0 /* RVKind.Blank */ ? (0, _shared_1.argToNumber)(args[1]) : (0, values_1.rvNumber)(1);
     if ((0, values_1.isError)(returnType)) {
         return returnType;
     }
@@ -427,15 +457,44 @@ function networkdaysHelper(startN, endN, holidays) {
     const s = Math.floor(Math.min(startN, endN));
     const e = Math.floor(Math.max(startN, endN));
     const sign = startN <= endN ? 1 : -1;
-    let count = 0;
-    for (let d = s; d <= e; d++) {
-        const dt = toDate(d);
-        const dow = dt.getUTCDay();
-        if (dow !== 0 && dow !== 6 && !holidays.has(d)) {
-            count++;
+    // Closed-form weekday count: partition `[s, e]` into whole weeks plus
+    // a tail. Each whole week contributes 5 weekdays, regardless of its
+    // starting day-of-week. The tail contributes however many of its
+    // remaining days fall on Monday..Friday.
+    //
+    // `getUTCDay()`: Sun=0, Mon=1, …, Sat=6. We compute `dow` once for
+    // the start date and then just walk the `tail` days forward by
+    // modular arithmetic — no Date allocations in the loop.
+    const totalDays = e - s + 1;
+    const weeks = Math.floor(totalDays / 7);
+    const tail = totalDays % 7;
+    let weekdays = weeks * 5;
+    if (tail > 0) {
+        const startDow = toDate(s).getUTCDay();
+        for (let i = 0; i < tail; i++) {
+            const dow = (startDow + i) % 7;
+            if (dow !== 0 && dow !== 6) {
+                weekdays++;
+            }
         }
     }
-    return count * sign;
+    else {
+        // When `totalDays` is an exact multiple of 7 the start DOW still
+        // governs whether any holidays from the caller's list fall on a
+        // weekday, so we stop here — no tail to walk.
+    }
+    // Subtract holidays that land on a weekday and fall within [s, e].
+    if (holidays.size > 0) {
+        for (const h of holidays) {
+            if (h >= s && h <= e) {
+                const dow = toDate(h).getUTCDay();
+                if (dow !== 0 && dow !== 6) {
+                    weekdays--;
+                }
+            }
+        }
+    }
+    return weekdays * sign;
 }
 const fnNETWORKDAYS = args => {
     const startN = (0, _shared_1.argToNumber)(args[0]);
@@ -447,7 +506,10 @@ const fnNETWORKDAYS = args => {
         return endN;
     }
     const holidays = args.length > 2 ? collectHolidays(args[2]) : new Set();
-    return (0, values_1.rvNumber)(networkdaysHelper(startN.value, endN.value, holidays));
+    if (holidays instanceof Set) {
+        return (0, values_1.rvNumber)(networkdaysHelper(startN.value, endN.value, holidays));
+    }
+    return holidays;
 };
 exports.fnNETWORKDAYS = fnNETWORKDAYS;
 const fnWORKDAY = args => {
@@ -460,9 +522,16 @@ const fnWORKDAY = args => {
         return days;
     }
     const holidays = args.length > 2 ? collectHolidays(args[2]) : new Set();
+    if (!(holidays instanceof Set)) {
+        return holidays;
+    }
     let current = Math.floor(startN.value);
-    const step = days.value >= 0 ? 1 : -1;
-    let remaining = Math.abs(days.value);
+    // Excel truncates `days` toward zero. Without this, a fractional input
+    // like 2.7 would walk extra iterations until the fractional remainder
+    // underflowed past zero, silently producing a wrong result.
+    const daysInt = Math.trunc(days.value);
+    const step = daysInt >= 0 ? 1 : -1;
+    let remaining = Math.abs(daysInt);
     while (remaining > 0) {
         current += step;
         const dt = toDate(current);
@@ -582,7 +651,7 @@ const fnDATEVALUE = args => {
     if (err) {
         return err;
     }
-    const text = (0, values_1.toStringRV)(args[0]).trim();
+    const text = (0, values_1.toStringRV)((0, values_1.topLeft)(args[0])).trim();
     // Lotus 1-2-3 bug: "2/29/1900" or "February 29, 1900" etc. should return 60
     const lotus29 = /^(2[/-]29[/-]1900|1900[/-]2[/-]29|1900[/-]02[/-]29|02[/-]29[/-]1900|Feb(ruary)?\s+29[,]?\s+1900)$/i;
     if (lotus29.test(text)) {
@@ -600,7 +669,7 @@ const fnTIMEVALUE = args => {
     if (err) {
         return err;
     }
-    const text = (0, values_1.toStringRV)(args[0]).trim();
+    const text = (0, values_1.toStringRV)((0, values_1.topLeft)(args[0])).trim();
     const parsed = parseTimeOnly(text);
     if (parsed === null) {
         return values_1.ERRORS.VALUE;
@@ -756,7 +825,7 @@ const fnDAYS360 = args => {
     if ((0, values_1.isError)(endN)) {
         return endN;
     }
-    const methodRV = args.length > 2 ? (0, values_1.toBooleanRV)(args[2]) : (0, values_1.rvBoolean)(false);
+    const methodRV = args.length > 2 ? (0, values_1.toBooleanRV)((0, values_1.topLeft)(args[2])) : (0, values_1.rvBoolean)(false);
     if ((0, values_1.isError)(methodRV)) {
         return methodRV;
     }
@@ -832,11 +901,16 @@ const fnNETWORKDAYS_INTL = args => {
     if ((0, values_1.isError)(endN)) {
         return endN;
     }
-    const weekendArg = args.length > 2 ? (0, _shared_1.argToNumber)(args[2]) : (0, values_1.rvNumber)(1);
+    // Blank `weekend` → Excel default 1 (Sat+Sun). See getWeekendDays
+    // default fallback.
+    const weekendArg = args.length > 2 && args[2].kind !== 0 /* RVKind.Blank */ ? (0, _shared_1.argToNumber)(args[2]) : (0, values_1.rvNumber)(1);
     if ((0, values_1.isError)(weekendArg)) {
         return weekendArg;
     }
     const holidays = args.length > 3 ? collectHolidays(args[3]) : new Set();
+    if (!(holidays instanceof Set)) {
+        return holidays;
+    }
     const weekendDays = getWeekendDays(weekendArg.value);
     const s = Math.floor(Math.min(startN.value, endN.value));
     const e = Math.floor(Math.max(startN.value, endN.value));
@@ -860,15 +934,23 @@ const fnWORKDAY_INTL = args => {
     if ((0, values_1.isError)(days)) {
         return days;
     }
-    const weekendArg = args.length > 2 ? (0, _shared_1.argToNumber)(args[2]) : (0, values_1.rvNumber)(1);
+    // Blank `weekend` → Excel default 1 (Sat+Sun).
+    const weekendArg = args.length > 2 && args[2].kind !== 0 /* RVKind.Blank */ ? (0, _shared_1.argToNumber)(args[2]) : (0, values_1.rvNumber)(1);
     if ((0, values_1.isError)(weekendArg)) {
         return weekendArg;
     }
     const holidays = args.length > 3 ? collectHolidays(args[3]) : new Set();
+    if (!(holidays instanceof Set)) {
+        return holidays;
+    }
     const weekendDays = getWeekendDays(weekendArg.value);
     let current = Math.floor(startN.value);
-    const step = days.value >= 0 ? 1 : -1;
-    let remaining = Math.abs(days.value);
+    // Truncate `days` toward zero before stepping — see WORKDAY for the
+    // same rationale. A fractional input like 2.7 would otherwise walk
+    // extra iterations and silently produce the wrong result.
+    const daysInt = Math.trunc(days.value);
+    const step = daysInt >= 0 ? 1 : -1;
+    let remaining = Math.abs(daysInt);
     while (remaining > 0) {
         current += step;
         const dt = toDate(current);