@rowsncolumns/spreadsheet-state 29.1.4 → 29.1.7

package/dist/esm/api/datatype.js

@@ -1,6 +1,6 @@
-import { getDefaultDateFormat, getDefaultDateTimeFormat, isAFormula, isNil, ssfFormat, ssfFormatColor, toDate, toSerial, } from "@rowsncolumns/utils";
+import { getDefaultDateFormat, getDefaultDateTimeFormat, isAFormula, isNil, ssfFormat, ssfFormatColor, toDate, toSerial, toSerialFromParts, } from "@rowsncolumns/utils";
 import { detectDateFormatPattern, detectDateTimeFormatPattern, isValidDate, isValidDateTime, toTimeSerial, validateDate, validateDateTime, } from "./date";
-import { detectDecimalPattern } from "./decimals";
+import { changeDecimals, detectDecimalPattern, getDecimalPlaces, hasThousandsGrouping, pattern_number_thousands, } from "./decimals";
 import { buildGroupRegex, getGroupingInfo, getLocaleDigitMap, getLocaleSeparators, getPercentSignInfo, getSignInfo, } from "./intl";
 export const pattern_percent = "0%";
 export const pattern_percent_decimal = "0.00%";
@@ -11,6 +11,11 @@ export const pattern_percent_decimal = "0.00%";
 // Excel renders the workbook identically to one it produced itself.
 export const pattern_currency = '"$"#,##0_);("$"#,##0)';
 export const pattern_currency_decimal = '"$"#,##0.00_);("$"#,##0.00)';
+// Excel's built-in "Comma Style" / "Comma [0]" cell styles (numFmtId 43 / 41):
+// accounting layout without a currency symbol — negatives in parentheses,
+// zero as `-`, padded so the digits align in a column. Neither is red.
+export const pattern_comma = '_(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)';
+export const pattern_comma_rounded = '_(* #,##0_);_(* (#,##0);_(* "-"??_);_(@_)';
 export const date_pattern = "mm/dd/yyyy";
 export const time_pattern_base = "hh:mm:ss";
 export const time_pattern = `hh:mm:ss AM/PM`;
@@ -403,11 +408,12 @@ export const createNumberValue = (value, numFormatType, locale, use1904, lenient
     const isDate = numFormatType === "DATE";
     const isDateTime = numFormatType === "DATE_TIME";
     if (typeof value !== "boolean" && (isDate || isDateTime)) {
+        // A number is already a serial: applying the Date type only changes the
+        // format. Round-tripping it through `toDate`/`toSerial` moved Excel's
+        // phantom 1900-02-29 (60) onto the 28th (59) because no `Date` holds the
+        // 29th (rowsncolumns/spreadsheet#1026).
         if (typeof value === "number") {
-            const dateValue = createDateValueFromNumber(value, use1904);
-            if (!isNil(dateValue) && dateValue instanceof Date) {
-                return toSerial(dateValue, use1904);
-            }
+            return value;
         }
         const dateValue = isDate
             ? validateDate(value, locale)
@@ -417,7 +423,7 @@ export const createNumberValue = (value, numFormatType, locale, use1904, lenient
             if (isTimeOnly) {
                 return toTimeSerial(hour ?? 0, minute ?? 0, second ?? 0);
             }
-            return toSerial(new Date(year, month, day, hour, minute, second, 0), use1904);
+            return toSerialFromParts(year, month, day, hour, minute, second, use1904);
         }
     }
     return convertToNumber(value, locale, lenientGrouping);
@@ -463,6 +469,33 @@ export const detectNumberFormatType = (value, locale, lenientGrouping = true) =>
         return "DATE_TIME";
     }
 };
+/**
+ * Currency base pattern for a typed literal: the detected symbol in the position it was typed
+ * (`$30` → `"$"#,##0`, `12,50 €` → `#,##0"€"`), defaulting to a `$` prefix.
+ */
+const currencyBasePattern = (value) => {
+    const currencyInfo = extractCurrencySymbol(String(value));
+    const symbol = currencyInfo?.symbol || "$";
+    const position = currencyInfo?.position || "prefix";
+    return position === "suffix" ? `#,##0"${symbol}"` : `"${symbol}"#,##0`;
+};
+/**
+ * Currency / percent pattern whose decimal places are the ones the user TYPED
+ * (`$1,234.50` → `"$"#,##0.00`, `50.00%` → `0.00%`), not the parsed number's (`1234.5` → one
+ * place), so trailing zeros survive like in Excel. The base already carries the symbol and
+ * grouping, so only the decimals are appended. Ports Rust `detect_decimal_pattern_typed`; both
+ * `detectValueTypeAndPattern` (typed cell entry) and `detectNumberFormatPattern` go through it
+ * so the two never disagree on the same literal.
+ */
+const detectTypedDecimalPattern = (value, numberValue, basePattern, locale) => {
+    // A JS number carries no typed digits; its own decimal expansion is the best we have (a
+    // percent's `numberValue` is already /100, so it must not be the source for a numeric input).
+    const typed = typeof value === "string" || typeof value === "number"
+        ? value
+        : numberValue ?? 0;
+    const decimalsLen = getDecimalPlaces(typed, locale);
+    return decimalsLen ? changeDecimals(basePattern, decimalsLen, true) : basePattern;
+};
 /**
  * Detect pattern of a number format
  * @param type
@@ -470,16 +503,10 @@ export const detectNumberFormatType = (value, locale, lenientGrouping = true) =>
  */
 export const detectNumberFormatPattern = (value, numberValue, type, locale, use1904) => {
     if (type === "PERCENT") {
-        return detectDecimalPattern(value, pattern_percent, locale);
+        return detectTypedDecimalPattern(value, numberValue, pattern_percent, locale);
     }
     if (type === "CURRENCY") {
-        // Extract the actual currency symbol and position from the input
-        const currencyInfo = extractCurrencySymbol(String(value));
-        const symbol = currencyInfo?.symbol || "$";
-        const position = currencyInfo?.position || "prefix";
-        // Create a pattern with the detected currency symbol in the correct position
-        const baseCurrencyPattern = position === "suffix" ? `#,##0"${symbol}"` : `"${symbol}"#,##0`;
-        return detectDecimalPattern(numberValue, baseCurrencyPattern, locale);
+        return detectTypedDecimalPattern(value, numberValue, currencyBasePattern(value), locale);
     }
     if (type === "DATE") {
         return detectDateFormatPattern(value, locale) ?? date_pattern;
@@ -488,17 +515,20 @@ export const detectNumberFormatPattern = (value, numberValue, type, locale, use1
         return detectDateTimeFormatPattern(value) ?? time_pattern;
     }
     if (type === "NUMBER") {
-        // An integer zero with no explicit format stays "General" — typing `0`,
-        // `00`, or a signed zero into a blank cell shouldn't manufacture a `#`
-        // number pattern that renders the value as blank. This rule is
-        // specific to the implicit NUMBER format; explicit CURRENCY / PERCENT
-        // formats keep their own base pattern for zero (handled above), so `$0`
-        // stays `"$"#,##0` rather than collapsing to a bare `0`.
-        if (value === 0 ||
-            (typeof value === "string" && /^[-+]?0+$/.test(value.trim()))) {
-            return "General";
+        // Excel leaves a General cell General for a plain number — `5`, `5.25`,
+        // `1.50`, `0.0000123` all display through General (`1.5`, `1.23E-05`)
+        // and stamp nothing, so a later entry in the same cell is never rounded
+        // through an inferred `#` / `#.00`. Only a thousands-grouped literal
+        // (`1,000`, `1,234.56`) is a formatting cue: it stamps `#,##0` plus the
+        // typed decimal places, and that stamp then sticks like any other format
+        // (Excel shows `0` for a later `0.25`). This rule is specific to the
+        // implicit NUMBER format; explicit CURRENCY / PERCENT formats keep their
+        // own base pattern (handled above), so `$0` stays `"$"#,##0`.
+        if (typeof value === "string" &&
+            hasThousandsGrouping(value, locale, numberValue)) {
+            return detectDecimalPattern(value, pattern_number_thousands, locale);
         }
-        return detectDecimalPattern(value, undefined, locale);
+        return "General";
     }
     return undefined;
 };
@@ -559,18 +589,12 @@ export const detectValueTypeAndPattern = (value, locale, lenientGrouping = true,
         }
         // Check currency
         if (isCurr) {
-            // Extract the actual currency symbol and position from the input
-            const currencyInfo = extractCurrencySymbol(String(value));
-            const symbol = currencyInfo?.symbol || "$";
-            const position = currencyInfo?.position || "prefix";
-            // Create a pattern with the detected currency symbol in the correct position
-            const baseCurrencyPattern = position === "suffix" ? `#,##0"${symbol}"` : `"${symbol}"#,##0`;
-            const pattern = detectDecimalPattern(numberValue, baseCurrencyPattern, locale);
+            const pattern = detectTypedDecimalPattern(value, numberValue, currencyBasePattern(value), locale);
             return ["numberValue", "CURRENCY", numberValue, pattern];
         }
         // Numbers can be number, percent, date, datetime
         if (isPercentage(value, locale, lenientGrouping)) {
-            const pattern = detectDecimalPattern(numberValue, pattern_percent, locale);
+            const pattern = detectTypedDecimalPattern(value, numberValue, pattern_percent, locale);
             const percentValue = convertToNumber(value, locale, lenientGrouping) / 100;
             return ["numberValue", "PERCENT", percentValue, pattern];
         }
@@ -594,14 +618,16 @@ export const detectValueTypeAndPattern = (value, locale, lenientGrouping = true,
         const { parts: { year, month, day, hour, minute, second }, isTimeOnly, } = dateTimeValue;
         const numberValue = isTimeOnly
             ? toTimeSerial(hour ?? 0, minute ?? 0, second ?? 0)
-            : toSerial(new Date(year, month, day, hour, minute, second, 0), use1904);
+            : toSerialFromParts(year, month, day, hour, minute, second, use1904);
         return ["numberValue", "DATE_TIME", numberValue, dateTimeValue.format];
     }
     // Dates
     const dateValue = validateDate(value, locale);
     if (dateValue) {
         const { parts: { year, month, day, hour, minute, second }, } = dateValue;
-        const numberValue = toSerial(new Date(year, month, day, hour, minute, second, 0), use1904);
+        // Parts, not a `Date`: Excel's phantom 1900-02-29 must land on serial 60
+        // rather than roll over to March 1 (rowsncolumns/spreadsheet#1026).
+        const numberValue = toSerialFromParts(year, month, day, hour, minute, second, use1904);
         return ["numberValue", "DATE", numberValue, dateValue.format];
     }
     return ["stringValue"];

package/dist/esm/api/date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../api/date.ts"],"names":[],"mappings":"AAoCA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAYD,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EACnD,QAAQ,MAAM,GAAG,SAAS,KACzB,eAAe,GAAG,SAiCpB,CAAC;AAGF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,KAClD,eAAe,GAAG,SAoEpB,CAAC;AA6CF;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,EAAE,QAAQ,MAAM,WAGxE,CAAC;AAwBF,eAAO,MAAM,WAAW,GACtB,OAAO,GAAG,EACV,QAAQ,MAAM,GAAG,SAAS,KACzB,OAKF,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,GAAG,KAAG,OAK5C,CAAC;AAGF,eAAO,MAAM,uBAAuB,GAClC,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EACnD,QAAQ,MAAM,GAAG,SAAS,KACzB,MAAM,GAAG,SAKX,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,KAClD,MAAM,GAAG,SAKX,CAAC;AAYF,eAAO,MAAM,cAAc,cAA+B,CAAC;AAC3D,eAAO,MAAM,eAAe,cAAgC,CAAC;AAC7D,eAAO,MAAM,aAAa,cAA8B,CAAC"}
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../api/date.ts"],"names":[],"mappings":"AAwCA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAYD,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EACnD,QAAQ,MAAM,GAAG,SAAS,KACzB,eAAe,GAAG,SAsCpB,CAAC;AAGF,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,KAClD,eAAe,GAAG,SAsEpB,CAAC;AA6CF;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,EAAE,QAAQ,MAAM,WAGxE,CAAC;AAwBF,eAAO,MAAM,WAAW,GACtB,OAAO,GAAG,EACV,QAAQ,MAAM,GAAG,SAAS,KACzB,OAKF,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,GAAG,KAAG,OAK5C,CAAC;AAGF,eAAO,MAAM,uBAAuB,GAClC,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EACnD,QAAQ,MAAM,GAAG,SAAS,KACzB,MAAM,GAAG,SAKX,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACtC,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,KAClD,MAAM,GAAG,SAKX,CAAC;AAYF,eAAO,MAAM,cAAc,cAA+B,CAAC;AAC3D,eAAO,MAAM,eAAe,cAAgC,CAAC;AAC7D,eAAO,MAAM,aAAa,cAA8B,CAAC"}

package/dist/esm/api/date.js

@@ -17,14 +17,17 @@ const TIME_FORMATS = {
     FULL: "hh:mm:ss",
     SHORT_WITH_MERIDIAN: "hh:mm AM/PM",
     SHORT: "hh:mm",
-    // Excel "elapsed time" patterns. The square brackets around `h` tell the
-    // formatter to display the full elapsed-hours count without wrapping at
-    // 24 — `[h]:mm:ss` will render a 25.5-hour duration as `25:30:00`, not
-    // `01:30:00`. Excel auto-applies these when the user types a value with
-    // hours > 24.
-    FULL_ELAPSED: "[h]:mm:ss",
-    SHORT_ELAPSED: "[h]:mm",
+    // Excel "elapsed time" (Duration) pattern. The square brackets around `h`
+    // tell the formatter to display the full elapsed-hours count without
+    // wrapping at 24 — `[h]:mm:ss` renders a 25.5-hour duration as `25:30:00`,
+    // not `01:30:00`. Excel auto-applies it when the typed hours reach 24
+    // (`24:00` is one day, `25:00` a duration) and always shows the seconds, so
+    // a typed `25:00` displays `25:00:00` (rowsncolumns/spreadsheet#1027) —
+    // the same pattern the Number menu's "Duration" item applies.
+    ELAPSED: "[h]:mm:ss",
 };
+// Typed hours at or past a full day are a Duration, never a clock time.
+const ELAPSED_HOURS_MIN = 24;
 // Cap elapsed-time hours at Excel's documented limit (`9999:59:59`). Beyond
 // this, treat as text rather than producing absurdly large fractional
 // serials. JS `Number.isFinite` would let `Infinity` through, so we cap
@@ -60,12 +63,17 @@ export const validateDate = (value, locale) => {
     if (year < EXCEL_DATE_MIN_YEAR || year > EXCEL_DATE_MAX_YEAR) {
         return undefined;
     }
+    // Excel's phantom 1900-02-29 (serial 60): the parser hands back a stand-in
+    // `Date` on the 28th with `excelLeapDay` set, because no `Date` can hold the
+    // 29th. Report the day the user typed; `toSerialFromParts` maps it to 60
+    // (rowsncolumns/spreadsheet#1026).
+    const day = "excelLeapDay" in result && result.excelLeapDay ? 29 : dateValue.getDate();
     return {
         format: result.pattern,
         parts: {
             year,
             month: dateValue.getMonth(),
-            day: dateValue.getDate(),
+            day,
             hour: dateValue.getHours(),
             minute: dateValue.getMinutes(),
             second: dateValue.getSeconds(),
@@ -94,10 +102,10 @@ export const validateDateTime = (value) => {
         const minute = parseInt(match[2], 10);
         const second = parseInt(match[3], 10);
         if (isValidTimeComponents(hour, minute, second)) {
-            // Excel parity: hour > 24 is an elapsed-time entry (e.g. `25:30:00`,
-            // `48:00:00`). Auto-apply `[h]:mm:ss` so the cell displays the full
-            // hours count instead of wrapping to `01:30:00`.
-            const format = hour > 24 ? TIME_FORMATS.FULL_ELAPSED : TIME_FORMATS.FULL;
+            // Excel parity: hours >= 24 are an elapsed-time entry (`24:00:00`,
+            // `25:30:00`, `48:00:00`). Auto-apply `[h]:mm:ss` so the cell displays
+            // the full hours count instead of wrapping to `01:30:00`.
+            const format = hour >= ELAPSED_HOURS_MIN ? TIME_FORMATS.ELAPSED : TIME_FORMATS.FULL;
             return createTimeResult(format, hour, minute, second);
         }
     }
@@ -115,8 +123,9 @@ export const validateDateTime = (value) => {
         const hour = parseInt(match[1], 10);
         const minute = parseInt(match[2], 10);
         if (isValidTimeComponents(hour, minute, 0)) {
-            // Same elapsed-time auto-pattern logic as the full form above.
-            const format = hour > 24 ? TIME_FORMATS.SHORT_ELAPSED : TIME_FORMATS.SHORT;
+            // Same elapsed-time rule as the full form: a duration typed without
+            // seconds still gets `[h]:mm:ss` (`25:00` → `25:00:00`, as Excel).
+            const format = hour >= ELAPSED_HOURS_MIN ? TIME_FORMATS.ELAPSED : TIME_FORMATS.SHORT;
             return createTimeResult(format, hour, minute, 0);
         }
     }

package/dist/esm/api/decimals.d.ts

@@ -1,6 +1,16 @@
 export declare const pattern_number = "#";
 export declare const pattern_number_thousands = "#,##0";
 export declare const getDecimalPlaces: (value: string | number, locale?: string) => number;
+/**
+ * Whether a typed literal groups its integer part with the locale's thousands
+ * separator (`1,000` / `1,234.56` in en-US, `1.234,56` in de-DE, `1 234` in
+ * fr-FR). In a comma-decimal locale a canonical dot-decimal string (`1.234`)
+ * is ambiguous — the programmatic decimal 1.234, or the grouped 1234 — so when
+ * the caller knows what the literal parsed to (`parsedValue`) that decides;
+ * without it the canonical reading wins, so the locale's `.` group separator
+ * is not mistaken for grouping. Rust `has_thousands_grouping`.
+ */
+export declare const hasThousandsGrouping: (value: string | number, locale?: string, parsedValue?: number) => boolean;
 export declare const detectDecimalPattern: (value: string | number | boolean | Date | undefined, defaultPattern?: string, locale?: string) => string;
 export declare const changeDecimals: (pattern?: string | undefined, changeBy?: number, delta?: boolean) => string;
 export declare const getCurrentDecimalCountInPattern: (pattern?: string | undefined | null) => number;

package/dist/esm/api/decimals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimals.d.ts","sourceRoot":"","sources":["../../../api/decimals.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,wBAAwB,UAAU,CAAC;AAyDhD,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,GAAG,MAAM,EACtB,SAAS,MAAM,KACd,MAsCF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EACnD,uBAA+B,EAC/B,SAAS,MAAM,WAkChB,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,UAAS,MAAM,GAAG,SAAc,EAChC,WAAU,MAAU,EACpB,eAAY,WAuCb,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,UAAS,MAAM,GAAG,SAAS,GAAG,IAAS,WAexC,CAAC;AAGF,eAAO,MAAM,oBAAoB,GAAI,UAAS,MAAM,GAAG,SAAc,WAwBpE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,UAAS,MAAM,GAAG,SAAc,WAQvE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,UAAS,MAAM,GAAG,SAAc,YAIrE,CAAC"}
+{"version":3,"file":"decimals.d.ts","sourceRoot":"","sources":["../../../api/decimals.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,eAAO,MAAM,wBAAwB,UAAU,CAAC;AAyDhD,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,GAAG,MAAM,EACtB,SAAS,MAAM,KACd,MAsCF,CAAC;AAcF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,MAAM,GAAG,MAAM,EACtB,SAAS,MAAM,EACf,cAAc,MAAM,KACnB,OAeF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,EACnD,uBAA+B,EAC/B,SAAS,MAAM,WAsBhB,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,UAAS,MAAM,GAAG,SAAc,EAChC,WAAU,MAAU,EACpB,eAAY,WAuCb,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,UAAS,MAAM,GAAG,SAAS,GAAG,IAAS,WAexC,CAAC;AAGF,eAAO,MAAM,oBAAoB,GAAI,UAAS,MAAM,GAAG,SAAc,WAwBpE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,UAAS,MAAM,GAAG,SAAc,WAQvE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,UAAS,MAAM,GAAG,SAAc,YAIrE,CAAC"}

package/dist/esm/api/decimals.js

@@ -73,19 +73,40 @@ export const getDecimalPlaces = (value, locale) => {
     // Return the length of the decimal part
     return decimalPart.length;
 };
-export const detectDecimalPattern = (value, defaultPattern = pattern_number, locale) => {
-    const str = typeof value === "number" ? normalizeFloatingPointString(value) : String(value);
+const WHITESPACE_GROUP_REGEX = /[\s\u00A0\u202F]/;
+/**
+ * Whether `integerPart` contains the locale's group separator. Locales that
+ * group with a space accept the whole whitespace family (regular, no-break,
+ * narrow no-break) — users type a plain space for fr-FR's `\u202F`.
+ */
+const integerPartHasGroup = (integerPart, group) => group.trim() === ""
+    ? WHITESPACE_GROUP_REGEX.test(integerPart)
+    : integerPart.includes(group);
+/**
+ * Whether a typed literal groups its integer part with the locale's thousands
+ * separator (`1,000` / `1,234.56` in en-US, `1.234,56` in de-DE, `1 234` in
+ * fr-FR). In a comma-decimal locale a canonical dot-decimal string (`1.234`)
+ * is ambiguous — the programmatic decimal 1.234, or the grouped 1234 — so when
+ * the caller knows what the literal parsed to (`parsedValue`) that decides;
+ * without it the canonical reading wins, so the locale's `.` group separator
+ * is not mistaken for grouping. Rust `has_thousands_grouping`.
+ */
+export const hasThousandsGrouping = (value, locale, parsedValue) => {
+    const str = typeof value === "number" ? normalizeFloatingPointString(value) : value;
     const { decimal, group } = getLocaleSeparators(locale);
     const groupSeparator = group ?? ",";
     const decimalSeparator = decimal ?? ".";
-    const usesCanonicalDotDecimal = decimalSeparator !== "." && CANONICAL_DOT_DECIMAL_REGEX.test(str);
-    const effectiveDecimalSeparator = usesCanonicalDotDecimal
-        ? "."
-        : decimalSeparator;
-    const integerPart = effectiveDecimalSeparator
-        ? str.split(effectiveDecimalSeparator)[0]
-        : str;
-    const hasThousands = Boolean(groupSeparator) && integerPart.includes(groupSeparator);
+    if (decimalSeparator !== "." && CANONICAL_DOT_DECIMAL_REGEX.test(str)) {
+        return (parsedValue !== undefined &&
+            Number(str) !== parsedValue &&
+            integerPartHasGroup(str, groupSeparator));
+    }
+    const integerPart = str.split(decimalSeparator)[0];
+    return Boolean(groupSeparator) && integerPartHasGroup(integerPart, groupSeparator);
+};
+export const detectDecimalPattern = (value, defaultPattern = pattern_number, locale) => {
+    const str = typeof value === "number" ? normalizeFloatingPointString(value) : String(value);
+    const hasThousands = hasThousandsGrouping(str, locale);
     const decimalsLen = getDecimalPlaces(value, locale);
     // Use "0" pattern for numbers less than 1 to ensure leading zero
     const numValue = Number(str.replace(/[^0-9.-]/g, ""));

package/dist/esm/api/dependency.d.ts

@@ -38,7 +38,17 @@ export declare const collectUniqueDependentsForRange: <T extends CellData>(param
     rowIndex: number;
     columnIndex: number;
 }>;
-export declare const moveFormulaAtPosition: <T extends CellData>({ draft, position, destinationSheetId, activeSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, movedKeys, rowDelta, columnDelta, sourceRange, deletedRange, destinationPosition, locale, rowCount, columnCount, cellXfsRegistry, sharedStringRegistry, }: {
+/**
+ * One reference shift of a structural edit: the references inside `sourceRange` move by the
+ * deltas, those inside `deletedRange` break to `#REF!`.
+ */
+export type FormulaMoveStep = {
+    rowDelta: number;
+    columnDelta: number;
+    sourceRange?: GridRange;
+    deletedRange?: GridRange;
+};
+export declare const moveFormulaAtPosition: <T extends CellData>({ draft, position, destinationSheetId, activeSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, movedKeys, rowDelta, columnDelta, sourceRange, deletedRange, steps, destinationPosition, locale, rowCount, columnCount, cellXfsRegistry, sharedStringRegistry, }: {
     draft: Draft<SheetData<T>>;
     position: {
         sheetId: number;
@@ -56,6 +66,14 @@ export declare const moveFormulaAtPosition: <T extends CellData>({ draft, positi
     sourceRange?: GridRange;
     /** Cells removed by a delete-cells shift — references into it become `#REF!` (SHF-09). */
     deletedRange?: GridRange;
+    /**
+     * Several shifts applied to the formula text in order, one per deleted band of a
+     * non-contiguous delete (Ctrl-selected rows 2 and 4): each step shifts the references inside
+     * its own `sourceRange` by its delta and breaks those inside its `deletedRange`. Replaces the
+     * single `rowDelta` / `columnDelta` / `sourceRange` / `deletedRange` shift when given; pass
+     * `destinationPosition` with it (the cell's own move is not any single step's delta).
+     */
+    steps?: FormulaMoveStep[];
     /**
      * Where the formula cell itself ends up. Defaults to `position + delta` (the cell moves with the
      * shift). A dependent OUTSIDE the shifted band keeps its place while its references into the

package/dist/esm/api/dependency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dependency.d.ts","sourceRoot":"","sources":["../../../api/dependency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAE1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAEnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAIrD,KAAK,0BAA0B,CAAC,CAAC,SAAS,QAAQ,IAAI;IACpD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;IAClE,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3C,kBAAkB,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7E,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACnD,WAAW,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACzD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC/C,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,CAAC,SAAS,QAAQ,EAAE,0QAoBjE,0BAA0B,CAAC,CAAC,CAAC,SAwO/B,CAAC;AAIF,eAAO,MAAM,+BAA+B,GAAI,CAAC,SAAS,QAAQ,EAAE,QAAQ;IAC1E,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,SAAS,CAAC;IACvB,aAAa,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,eAAe,CAAC,CAAC;CACnE;aAIc,MAAM;cAAY,MAAM;iBAAe,MAAM;EAsC3D,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EAAE,2QAmBvD;IACD,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B,QAAQ,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IACrE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC7E,qBAAqB,CAAC,EAAE,UAAU,CAChC,OAAO,cAAc,CACtB,CAAC,uBAAuB,CAAC,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC/C,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,0FAA0F;IAC1F,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C,SAwFA,CAAC"}
+{"version":3,"file":"dependency.d.ts","sourceRoot":"","sources":["../../../api/dependency.ts"],"names":[],"mappings":"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"}

package/dist/esm/api/dependency.js

@@ -205,7 +205,7 @@ export const collectUniqueDependentsForRange = (params) => {
     return dependentMap;
 };
 // Process a single formula move at a specific position with the specified deltas.
-export const moveFormulaAtPosition = ({ draft, position, destinationSheetId, activeSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, movedKeys, rowDelta = 0, columnDelta = 0, sourceRange, deletedRange, destinationPosition, locale, rowCount, columnCount, cellXfsRegistry, sharedStringRegistry, }) => {
+export const moveFormulaAtPosition = ({ draft, position, destinationSheetId, activeSheetName, enqueueCalculation, enqueueGraphOperation, recalcCells, movedKeys, rowDelta = 0, columnDelta = 0, sourceRange, deletedRange, steps, destinationPosition, locale, rowCount, columnCount, cellXfsRegistry, sharedStringRegistry, }) => {
     const sheetCell = new SheetCell();
     const currentSheet = createSheetDraft(draft, position.sheetId, position.rowIndex);
     const cellData = currentSheet[position.rowIndex]?.values?.[position.columnIndex];
@@ -218,15 +218,20 @@ export const moveFormulaAtPosition = ({ draft, position, destinationSheetId, act
         const resolvedSheetName = activeSheetName ?? "";
         // The delta is applied to the references inside `sourceRange`; the formula cell's own
         // destination (for the graph re-key) may differ when it does not move itself.
-        sheetCell.moveFormula({ rowIndex: position.rowIndex, columnIndex: position.columnIndex }, {
-            rowIndex: position.rowIndex + rowDelta,
-            columnIndex: position.columnIndex + columnDelta,
-        }, resolvedSheetName, {
-            exclusionRange: sourceRange,
-            deletedRange,
-            rowCount,
-            columnCount,
-        });
+        const moves = steps ?? [
+            { rowDelta, columnDelta, sourceRange, deletedRange },
+        ];
+        for (const move of moves) {
+            sheetCell.moveFormula({ rowIndex: position.rowIndex, columnIndex: position.columnIndex }, {
+                rowIndex: position.rowIndex + move.rowDelta,
+                columnIndex: position.columnIndex + move.columnDelta,
+            }, resolvedSheetName, {
+                exclusionRange: move.sourceRange,
+                deletedRange: move.deletedRange,
+                rowCount,
+                columnCount,
+            });
+        }
         if (previousFormula !== sheetCell.formula) {
             // Set cell data at old position (formula updated prior to structural move)
             currentSheet[position.rowIndex].values[position.columnIndex] =

package/dist/esm/api/filter-condition.d.ts

@@ -0,0 +1,58 @@
+import type { BooleanCondition, ConditionType } from "@rowsncolumns/spreadsheet";
+export declare const isDateFilterCondition: (type: ConditionType | string | null | undefined) => boolean;
+/**
+ * Whether a filter clause compares the cell's NUMBER — a Number Filter or a
+ * Date Filter comparison. Text (even numeric-looking text such as `'500`),
+ * booleans, errors and blanks never satisfy such a clause.
+ */
+export declare const isNumericFilterCondition: (type: ConditionType | string | null | undefined) => boolean;
+/** A cell value that takes part in a Number / Date Filter: a finite number. */
+export declare const isNumericFilterCellValue: (value: unknown) => value is number;
+/**
+ * How a Number / Date Filter criterion (`userEnteredValue`, the free text
+ * typed into the filter dialog) reads.
+ *
+ * - `empty`: nothing typed — the clause is inactive.
+ * - `number`: a typed literal — number, `50%`, currency, or a date / time in
+ *   the document locale — as its numeric value (a date is its serial, exactly
+ *   what the cell holds).
+ * - `formula`: `=…` or a cell reference; only the calculator can resolve it.
+ * - `text`: anything else; no number satisfies it.
+ */
+export type FilterCriterion = {
+    kind: "empty";
+} | {
+    kind: "number";
+    value: number;
+} | {
+    kind: "formula";
+} | {
+    kind: "text";
+};
+/**
+ * Classify a filter criterion the way Excel's Custom AutoFilter reads the typed
+ * box — as a cell entry in the workbook `locale` (`1/15/2024` is Jan 15 in
+ * en-US, `15.1.2024` in de-DE, `2024-02-01` anywhere, `6,5` is 6.5 in de-DE),
+ * so a Date Filter compares serials instead of quoting the text.
+ */
+export declare const classifyFilterCriterion: (raw: string | undefined | null, locale?: string) => FilterCriterion;
+/**
+ * Decide one Number Filter / Date Filter clause against a cell's typed value,
+ * the way Excel does — without the calculator:
+ *
+ * - Only NUMBERS take part. Text (including numeric-looking text such as
+ *   `'500`), booleans, errors and blanks never satisfy `> 500` / `after
+ *   1/15/2024` and are hidden (`false`). The calculator's coercion would say
+ *   text > number is TRUE and a blank is 0 — neither is Excel. "Does not
+ *   equal" is the complement of "equals": text and blanks stay visible.
+ * - A typed date criterion is read in the document `locale` and compared as a
+ *   SERIAL; Date Filters compare calendar days (`INT`), so `1/15/2024 14:00`
+ *   equals `1/15/2024` and is not after it.
+ * - A `=…` / reference criterion is `undefined` — left to the calculator, which
+ *   then compares a number (the cell-type gate has already run). An empty
+ *   criterion is `undefined` too (an inactive clause).
+ *
+ * `undefined` for a condition type this evaluator does not own.
+ */
+export declare const evaluateNumericFilterCondition: (condition: BooleanCondition | null | undefined, value: unknown, locale?: string) => boolean | undefined;
+//# sourceMappingURL=filter-condition.d.ts.map

package/dist/esm/api/filter-condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-condition.d.ts","sourceRoot":"","sources":["../../../api/filter-condition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,2BAA2B,CAAC;AA4CnC,eAAO,MAAM,qBAAqB,GAChC,MAAM,aAAa,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,KAC9C,OACsE,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,MAAM,aAAa,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,KAC9C,OAKA,CAAC;AAEJ,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACd,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAErB;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAClC,KAAK,MAAM,GAAG,SAAS,GAAG,IAAI,EAC9B,SAAS,MAAM,KACd,eAcF,CAAC;AAKF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,8BAA8B,GACzC,WAAW,gBAAgB,GAAG,IAAI,GAAG,SAAS,EAC9C,OAAO,OAAO,EACd,SAAS,MAAM,KACd,OAAO,GAAG,SA2DZ,CAAC"}

package/dist/esm/api/filter-condition.js

@@ -0,0 +1,146 @@
+import { checkIfStringIsReference } from "@rowsncolumns/utils";
+import { detectValueTypeAndPattern } from "./datatype";
+/**
+ * Excel's Number Filters and Date Filters — the AutoFilter clauses that act on
+ * the cell's NUMBER (a date is its serial) and hide every non-numeric cell.
+ * Twin of `is_numeric_filter_kind` in the Rust engine (`rnc-store/support.rs`);
+ * the shared table `libs/common-types/fixtures/filter-evaluator-table.json`
+ * (`numeric`) keeps the two evaluators identical.
+ */
+const NUMBER_FILTER_CONDITION_TYPES = new Set([
+    "NUMBER_EQ",
+    "NUMBER_NOT_EQ",
+    "NUMBER_GREATER",
+    "NUMBER_GREATER_THAN_EQ",
+    "NUMBER_LESS",
+    "NUMBER_LESS_THAN_EQ",
+    "NUMBER_BETWEEN",
+    "NUMBER_NOT_BETWEEN",
+]);
+const DATE_FILTER_CONDITION_TYPES = new Set([
+    "DATE_EQ",
+    "DATE_NOT_EQ",
+    "DATE_BEFORE",
+    "DATE_AFTER",
+    "DATE_ON_OR_BEFORE",
+    "DATE_ON_OR_AFTER",
+    "DATE_BETWEEN",
+    "DATE_NOT_BETWEEN",
+]);
+const TWO_OPERAND_FILTER_CONDITION_TYPES = new Set([
+    "NUMBER_BETWEEN",
+    "NUMBER_NOT_BETWEEN",
+    "DATE_BETWEEN",
+    "DATE_NOT_BETWEEN",
+]);
+export const isDateFilterCondition = (type) => Boolean(type && DATE_FILTER_CONDITION_TYPES.has(type));
+/**
+ * Whether a filter clause compares the cell's NUMBER — a Number Filter or a
+ * Date Filter comparison. Text (even numeric-looking text such as `'500`),
+ * booleans, errors and blanks never satisfy such a clause.
+ */
+export const isNumericFilterCondition = (type) => Boolean(type &&
+    (NUMBER_FILTER_CONDITION_TYPES.has(type) ||
+        DATE_FILTER_CONDITION_TYPES.has(type)));
+/** A cell value that takes part in a Number / Date Filter: a finite number. */
+export const isNumericFilterCellValue = (value) => typeof value === "number" && Number.isFinite(value);
+/**
+ * Classify a filter criterion the way Excel's Custom AutoFilter reads the typed
+ * box — as a cell entry in the workbook `locale` (`1/15/2024` is Jan 15 in
+ * en-US, `15.1.2024` in de-DE, `2024-02-01` anywhere, `6,5` is 6.5 in de-DE),
+ * so a Date Filter compares serials instead of quoting the text.
+ */
+export const classifyFilterCriterion = (raw, locale) => {
+    const trimmed = raw?.trim() ?? "";
+    if (!trimmed)
+        return { kind: "empty" };
+    if (trimmed.startsWith("=") || checkIfStringIsReference(trimmed)) {
+        return { kind: "formula" };
+    }
+    const [formatValue, , numberValue] = detectValueTypeAndPattern(trimmed, locale ?? "en-US");
+    if (formatValue === "numberValue" && isNumericFilterCellValue(numberValue)) {
+        return { kind: "number", value: numberValue };
+    }
+    return { kind: "text" };
+};
+const numbersEqual = (a, b) => Math.abs(a - b) <= 1e-9 * Math.max(Math.abs(a), Math.abs(b), 1);
+/**
+ * Decide one Number Filter / Date Filter clause against a cell's typed value,
+ * the way Excel does — without the calculator:
+ *
+ * - Only NUMBERS take part. Text (including numeric-looking text such as
+ *   `'500`), booleans, errors and blanks never satisfy `> 500` / `after
+ *   1/15/2024` and are hidden (`false`). The calculator's coercion would say
+ *   text > number is TRUE and a blank is 0 — neither is Excel. "Does not
+ *   equal" is the complement of "equals": text and blanks stay visible.
+ * - A typed date criterion is read in the document `locale` and compared as a
+ *   SERIAL; Date Filters compare calendar days (`INT`), so `1/15/2024 14:00`
+ *   equals `1/15/2024` and is not after it.
+ * - A `=…` / reference criterion is `undefined` — left to the calculator, which
+ *   then compares a number (the cell-type gate has already run). An empty
+ *   criterion is `undefined` too (an inactive clause).
+ *
+ * `undefined` for a condition type this evaluator does not own.
+ */
+export const evaluateNumericFilterCondition = (condition, value, locale) => {
+    const type = condition?.type;
+    if (!type || !isNumericFilterCondition(type))
+        return undefined;
+    const values = condition?.values ?? [];
+    if (!isNumericFilterCellValue(value)) {
+        // "Does not equal" is the complement of "equals" over the whole column: a
+        // text cell or a blank does not equal 500 and stays visible (a text cell
+        // whose display text IS the criterion hides).
+        if (type === "NUMBER_NOT_EQ" || type === "DATE_NOT_EQ") {
+            const shown = value === undefined || value === null ? "" : String(value);
+            return (shown.trim().toLowerCase() !==
+                (values[0]?.userEnteredValue ?? "").trim().toLowerCase());
+        }
+        return false;
+    }
+    const first = classifyFilterCriterion(values[0]?.userEnteredValue, locale);
+    const second = TWO_OPERAND_FILTER_CONDITION_TYPES.has(type)
+        ? classifyFilterCriterion(values[1]?.userEnteredValue, locale)
+        : { kind: "number", value: 0 };
+    if (first.kind === "empty" || second.kind === "empty")
+        return undefined;
+    if (first.kind === "formula" || second.kind === "formula")
+        return undefined;
+    if (first.kind !== "number" || second.kind !== "number")
+        return false;
+    // Date Filters compare calendar days; Number Filters the exact values.
+    const day = isDateFilterCondition(type)
+        ? (n) => Math.floor(n)
+        : (n) => n;
+    const a = day(value);
+    const lo = day(first.value);
+    const hi = day(second.value);
+    switch (type) {
+        case "NUMBER_EQ":
+        case "DATE_EQ":
+            return numbersEqual(a, lo);
+        case "NUMBER_NOT_EQ":
+        case "DATE_NOT_EQ":
+            return !numbersEqual(a, lo);
+        case "NUMBER_GREATER":
+        case "DATE_AFTER":
+            return a > lo;
+        case "NUMBER_GREATER_THAN_EQ":
+        case "DATE_ON_OR_AFTER":
+            return a >= lo;
+        case "NUMBER_LESS":
+        case "DATE_BEFORE":
+            return a < lo;
+        case "NUMBER_LESS_THAN_EQ":
+        case "DATE_ON_OR_BEFORE":
+            return a <= lo;
+        case "NUMBER_BETWEEN":
+        case "DATE_BETWEEN":
+            return a >= lo && a <= hi;
+        case "NUMBER_NOT_BETWEEN":
+        case "DATE_NOT_BETWEEN":
+            return a < lo || a > hi;
+        default:
+            return undefined;
+    }
+};