@cj-tech-master/excelts 9.3.1 → 9.4.0

package/dist/browser/modules/formula/functions/_shared.js

@@ -76,6 +76,53 @@ export function flattenNumbers(args) {
     }
     return result;
 }
+/**
+ * Streaming fold over numeric arguments.
+ *
+ * Same selection rules as `flattenNumbers` (array cells contribute only
+ * Number/Error; direct scalar coercion via `toNumberRV`; blanks dropped),
+ * but the caller's `onNumber` callback fires inline — no intermediate
+ * array is allocated. On the first error encountered the scan short-
+ * circuits and returns that error.
+ *
+ * Returns:
+ *   - `null` when iteration finished without encountering an error, or
+ *   - the `ErrorValue` that aborted the scan.
+ *
+ * Prefer this over `flattenNumbers` + `firstError` + manual loop in hot
+ * aggregates (SUM / AVERAGE / MIN / MAX / …). The allocation saved is
+ * one `NumberValue | ErrorValue` array per invocation — meaningful
+ * when the engine sums tens of thousands of cells.
+ */
+export function forEachNumber(args, onNumber) {
+    for (const arg of args) {
+        if (arg.kind === RVKind.Array) {
+            for (const row of arg.rows) {
+                for (const cell of row) {
+                    if (cell.kind === RVKind.Error) {
+                        return cell;
+                    }
+                    if (cell.kind === RVKind.Number) {
+                        onNumber(cell.value);
+                    }
+                    // Booleans, strings, blanks inside arrays are skipped.
+                }
+            }
+        }
+        else if (arg.kind === RVKind.Error) {
+            return arg;
+        }
+        else if (arg.kind !== RVKind.Blank) {
+            const n = toNumberRV(arg);
+            if (n.kind === RVKind.Error) {
+                return n;
+            }
+            onNumber(n.value);
+        }
+        // Direct blank scalars are dropped.
+    }
+    return null;
+}
 /**
  * Flatten all cells from the arguments into a flat list of ScalarValue,
  * preserving every cell (including blanks, errors, booleans, strings).

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

@@ -47,35 +47,57 @@ export 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 === RVKind.Number) {
-                return v.value;
-            }
-            if (v.kind === RVKind.Boolean) {
-                return v.value ? 1 : 0;
-            }
-            if (v.kind === 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 === RVKind.Number
+                    ? v.value
+                    : v.kind === RVKind.Boolean
+                        ? v.value
+                            ? 1
+                            : 0
+                        : v.kind === 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 = 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;
             }
@@ -85,14 +107,19 @@ export 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 (hasUnescapedWildcard(s)) {
         try {
             const re = new RegExp("^" + excelWildcardToRegex(s) + "$", "i");
-            return v => re.test(toStringRV(v));
+            return v => v.kind === RVKind.String && re.test(v.value);
         }
         catch {
             const literal = unescapeExcelWildcard(s).toLowerCase();
-            return v => toStringRV(v).toLowerCase() === literal;
+            return v => v.kind === RVKind.String && v.value.toLowerCase() === literal;
         }
     }
     // No wildcards: strip any `~` escapes and do a literal case-insensitive compare.
@@ -133,6 +160,12 @@ export function fnSUMIF(args) {
         for (let c = 0; c < rangeArr.width; c++) {
             if (pred(getCell(rangeArr, r, c))) {
                 const sv = 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 === RVKind.Error) {
+                    return sv;
+                }
                 if (sv.kind === RVKind.Number) {
                     sum += sv.value;
                 }
@@ -205,12 +238,23 @@ export function fnSUMIFS(args) {
         return pairs.error;
     }
     let sum = 0;
+    let sumErr = null;
     iterateMultiCriteria(sumArr, pairs.pairs, (r, c) => {
+        if (sumErr) {
+            return;
+        }
         const sv = getCell(sumArr, r, c);
+        if (sv.kind === RVKind.Error) {
+            sumErr = sv;
+            return;
+        }
         if (sv.kind === RVKind.Number) {
             sum += sv.value;
         }
     });
+    if (sumErr) {
+        return sumErr;
+    }
     return rvNumber(sum);
 }
 export function fnCOUNTIF(args) {
@@ -268,6 +312,10 @@ export function fnAVERAGEIF(args) {
         for (let c = 0; c < rangeArr.width; c++) {
             if (pred(getCell(rangeArr, r, c))) {
                 const sv = getCell(avgArr, r, c);
+                // Propagate errors from the average-range — see SUMIF for rationale.
+                if (sv.kind === RVKind.Error) {
+                    return sv;
+                }
                 if (sv.kind === RVKind.Number) {
                     sum += sv.value;
                     count++;
@@ -288,13 +336,24 @@ export function fnAVERAGEIFS(args) {
     }
     let sum = 0;
     let count = 0;
+    let avgErr = null;
     iterateMultiCriteria(avgArr, pairs.pairs, (r, c) => {
+        if (avgErr) {
+            return;
+        }
         const sv = getCell(avgArr, r, c);
+        if (sv.kind === RVKind.Error) {
+            avgErr = sv;
+            return;
+        }
         if (sv.kind === RVKind.Number) {
             sum += sv.value;
             count++;
         }
     });
+    if (avgErr) {
+        return avgErr;
+    }
     return count === 0 ? ERRORS.DIV0 : rvNumber(sum / count);
 }
 export function fnMAXIFS(args) {
@@ -308,8 +367,16 @@ export function fnMAXIFS(args) {
     }
     let result = -Infinity;
     let found = false;
+    let maxErr = null;
     iterateMultiCriteria(maxArr, pairs.pairs, (r, c) => {
+        if (maxErr) {
+            return;
+        }
         const sv = getCell(maxArr, r, c);
+        if (sv.kind === RVKind.Error) {
+            maxErr = sv;
+            return;
+        }
         if (sv.kind === RVKind.Number) {
             if (sv.value > result) {
                 result = sv.value;
@@ -317,6 +384,9 @@ export function fnMAXIFS(args) {
             found = true;
         }
     });
+    if (maxErr) {
+        return maxErr;
+    }
     return rvNumber(found ? result : 0);
 }
 export function fnMINIFS(args) {
@@ -330,8 +400,16 @@ export function fnMINIFS(args) {
     }
     let result = Infinity;
     let found = false;
+    let minErr = null;
     iterateMultiCriteria(minArr, pairs.pairs, (r, c) => {
+        if (minErr) {
+            return;
+        }
         const sv = getCell(minArr, r, c);
+        if (sv.kind === RVKind.Error) {
+            minErr = sv;
+            return;
+        }
         if (sv.kind === RVKind.Number) {
             if (sv.value < result) {
                 result = sv.value;
@@ -339,5 +417,8 @@ export function fnMINIFS(args) {
             found = true;
         }
     });
+    if (minErr) {
+        return minErr;
+    }
     return rvNumber(found ? result : 0);
 }

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

@@ -16,7 +16,7 @@
  *   correctly through `excelToDate()`.
  */
 import { dateToExcel, excelToDate } from "../../../utils/utils.base.js";
-import { RVKind, ERRORS, isError, isArray, toNumberRV, toStringRV, toBooleanRV, rvNumber, rvBoolean } from "../runtime/values.js";
+import { RVKind, ERRORS, isError, isArray, toNumberRV, toStringRV, toBooleanRV, topLeft, rvNumber, rvBoolean } from "../runtime/values.js";
 import { isDate1904 } from "./_date-context.js";
 import { argToNumber, checkError } from "./_shared.js";
 // ============================================================================
@@ -36,6 +36,11 @@ function collectHolidays(arg) {
     if (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 === RVKind.Error) {
+                    return cell;
+                }
                 if (cell.kind === RVKind.Number) {
                     set.add(Math.floor(cell.value));
                 }
@@ -43,6 +48,9 @@ function collectHolidays(arg) {
         }
     }
     else {
+        if (arg.kind === RVKind.Error) {
+            return arg;
+        }
         const n = toNumberRV(arg);
         if (n.kind === RVKind.Number) {
             set.add(Math.floor(n.value));
@@ -206,7 +214,10 @@ export const fnWEEKDAY = args => {
         return n;
     }
     const d = toDate(n.value);
-    const returnType = args.length > 1 ? argToNumber(args[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 !== RVKind.Blank ? argToNumber(args[1]) : rvNumber(1);
     if (isError(returnType)) {
         return returnType;
     }
@@ -239,8 +250,14 @@ export const fnEOMONTH = args => {
     if (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 rvNumber(fromDate(result));
 };
 export const fnEDATE = args => {
@@ -252,8 +269,19 @@ export const fnEDATE = args => {
     if (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 rvNumber(fromDate(result));
 };
 export const fnDATEDIF = args => {
@@ -269,7 +297,7 @@ export const fnDATEDIF = args => {
     if (endN.value < startN.value) {
         return ERRORS.NUM;
     }
-    const unit = toStringRV(args[2]).toUpperCase();
+    const unit = toStringRV(topLeft(args[2])).toUpperCase();
     const startD = toDate(startN.value);
     const endD = toDate(endN.value);
     const sy = startD.getUTCFullYear();
@@ -353,7 +381,9 @@ export const fnWEEKNUM = args => {
         return n;
     }
     const d = toDate(n.value);
-    const returnType = args.length > 1 ? argToNumber(args[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 !== RVKind.Blank ? argToNumber(args[1]) : rvNumber(1);
     if (isError(returnType)) {
         return returnType;
     }
@@ -407,15 +437,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;
 }
 export const fnNETWORKDAYS = args => {
     const startN = argToNumber(args[0]);
@@ -427,7 +486,10 @@ export const fnNETWORKDAYS = args => {
         return endN;
     }
     const holidays = args.length > 2 ? collectHolidays(args[2]) : new Set();
-    return rvNumber(networkdaysHelper(startN.value, endN.value, holidays));
+    if (holidays instanceof Set) {
+        return rvNumber(networkdaysHelper(startN.value, endN.value, holidays));
+    }
+    return holidays;
 };
 export const fnWORKDAY = args => {
     const startN = argToNumber(args[0]);
@@ -439,9 +501,16 @@ export 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);
@@ -559,7 +628,7 @@ export const fnDATEVALUE = args => {
     if (err) {
         return err;
     }
-    const text = toStringRV(args[0]).trim();
+    const text = toStringRV(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)) {
@@ -576,7 +645,7 @@ export const fnTIMEVALUE = args => {
     if (err) {
         return err;
     }
-    const text = toStringRV(args[0]).trim();
+    const text = toStringRV(topLeft(args[0])).trim();
     const parsed = parseTimeOnly(text);
     if (parsed === null) {
         return ERRORS.VALUE;
@@ -731,7 +800,7 @@ export const fnDAYS360 = args => {
     if (isError(endN)) {
         return endN;
     }
-    const methodRV = args.length > 2 ? toBooleanRV(args[2]) : rvBoolean(false);
+    const methodRV = args.length > 2 ? toBooleanRV(topLeft(args[2])) : rvBoolean(false);
     if (isError(methodRV)) {
         return methodRV;
     }
@@ -806,11 +875,16 @@ export const fnNETWORKDAYS_INTL = args => {
     if (isError(endN)) {
         return endN;
     }
-    const weekendArg = args.length > 2 ? argToNumber(args[2]) : rvNumber(1);
+    // Blank `weekend` → Excel default 1 (Sat+Sun). See getWeekendDays
+    // default fallback.
+    const weekendArg = args.length > 2 && args[2].kind !== RVKind.Blank ? argToNumber(args[2]) : rvNumber(1);
     if (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));
@@ -833,15 +907,23 @@ export const fnWORKDAY_INTL = args => {
     if (isError(days)) {
         return days;
     }
-    const weekendArg = args.length > 2 ? argToNumber(args[2]) : rvNumber(1);
+    // Blank `weekend` → Excel default 1 (Sat+Sun).
+    const weekendArg = args.length > 2 && args[2].kind !== RVKind.Blank ? argToNumber(args[2]) : rvNumber(1);
     if (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);