@a3s-lab/office 0.36.0 → 0.37.1

package/dist/internal/features/work/work-xlsx-table-filters.d.ts

@@ -1,3 +1,5 @@
-import type { WorkSpreadsheetTableFilter } from './work-types';
+import type { WorkSpreadsheetFilter, WorkSpreadsheetTableFilter } from './work-types';
 export declare function readXlsxTableFilters(table: Document, width: number): WorkSpreadsheetTableFilter[];
+export declare function readXlsxAutoFilterColumns(autoFilter: Element, width: number): WorkSpreadsheetFilter[];
 export declare function xlsxTableAutoFilterXml(filters: readonly WorkSpreadsheetTableFilter[], rangeReference: string, totalsRow: boolean): string;
+export declare function xlsxAutoFilterXml(filters: readonly WorkSpreadsheetFilter[], rangeReference: string): string;

package/dist/internal/kernel/office-kernel-spreadsheet-fallback-formula.d.ts

@@ -1,3 +1,14 @@
 export declare const browserScalarFunctionArities: Map<string, readonly [minimum: number, maximum: number]>;
 export declare function normalizeSpreadsheetFunctionName(name: string): string;
+/**
+ * Evaluate the bounded browser implementation of `SUBTOTAL`.
+ *
+ * Fortune delegates unknown functions to Formula.js. Formula.js returns an
+ * undefined value for an unknown function number, which the parser can then
+ * coerce into a boolean. Keeping this small implementation here makes the
+ * JavaScript fallback deterministic and aligned with the Rust kernel. The
+ * calculation request does not carry hidden-row metadata yet, so the 1–11
+ * and 101–111 function-number families intentionally have the same result.
+ */
+export declare function evaluateParserSubtotal(parameters: readonly unknown[]): unknown;
 export declare function normalizeFormulaForFortuneParser(formula: string): string;

package/dist/office-kernel.worker.js

@@ -13727,6 +13727,13 @@
                     1
                 ]
             ],
+            [
+                'SUBTOTAL',
+                [
+                    2,
+                    255
+                ]
+            ],
             [
                 'SUM',
                 [
@@ -13747,6 +13754,90 @@
             while(normalized.startsWith('_XLFN.') || normalized.startsWith('_XLWS.'))normalized = normalized.slice(6);
             return normalized;
         }
+        function evaluateParserSubtotal(parameters) {
+            const codeValue = parserNumericValue(parameters[0]);
+            if (void 0 === codeValue) return 'VALUE!';
+            const code = Math.trunc(codeValue);
+            const values = parameters.slice(1).flatMap((parameter)=>flattenParserValues(parameter));
+            for (const value of values){
+                const error = parserErrorValue(value);
+                if (error) return error;
+            }
+            switch(code){
+                case 1:
+                case 101:
+                    return parserSubtotalNumeric(values, 'average');
+                case 2:
+                case 102:
+                    return values.filter((value)=>'number' == typeof value).length;
+                case 3:
+                case 103:
+                    return values.filter((value)=>null != value).length;
+                case 4:
+                case 104:
+                    return parserSubtotalNumeric(values, 'max');
+                case 5:
+                case 105:
+                    return parserSubtotalNumeric(values, 'min');
+                case 6:
+                case 106:
+                    return parserSubtotalNumeric(values, 'product');
+                case 7:
+                case 107:
+                    return parserSubtotalNumeric(values, 'stddev');
+                case 8:
+                case 108:
+                    return parserSubtotalNumeric(values, 'stddevp');
+                case 9:
+                case 109:
+                    return parserSubtotalNumeric(values, 'sum');
+                case 10:
+                case 110:
+                    return parserSubtotalNumeric(values, 'var');
+                case 11:
+                case 111:
+                    return parserSubtotalNumeric(values, 'varp');
+                default:
+                    return 'VALUE!';
+            }
+        }
+        function parserSubtotalNumeric(values, operation) {
+            const numbers = values.filter((value)=>'number' == typeof value && Number.isFinite(value));
+            const count = numbers.length;
+            const sum = numbers.reduce((total, value)=>total + value, 0);
+            if ('sum' === operation) return finiteParserNumber(sum);
+            if ('average' === operation) return count ? finiteParserNumber(sum / count) : 'DIV/0!';
+            if ('max' === operation) return finiteParserNumber(Math.max(...numbers, 0));
+            if ('min' === operation) return finiteParserNumber(Math.min(...numbers, 0));
+            if ('product' === operation) return finiteParserNumber(count ? numbers.reduce((total, value)=>total * value, 1) : 0);
+            if ('stddev' === operation || 'var' === operation) {
+                if (count < 2) return 'DIV/0!';
+            } else if (0 === count) return 'DIV/0!';
+            const mean = sum / count;
+            const divisor = 'stddev' === operation || 'var' === operation ? count - 1 : count;
+            const variance = numbers.reduce((total, value)=>total + (value - mean) ** 2, 0) / divisor;
+            return finiteParserNumber('stddev' === operation || 'stddevp' === operation ? Math.sqrt(variance) : variance);
+        }
+        function flattenParserValues(value) {
+            if (!Array.isArray(value)) return [
+                value
+            ];
+            return value.flatMap((entry)=>flattenParserValues(entry));
+        }
+        function parserNumericValue(value) {
+            if ('number' == typeof value) return Number.isFinite(value) ? value : void 0;
+            if ('boolean' == typeof value) return value ? 1 : 0;
+            if ('string' != typeof value || !value.trim()) return;
+            const parsed = Number(value);
+            return Number.isFinite(parsed) ? parsed : void 0;
+        }
+        function parserErrorValue(value) {
+            if (value instanceof Error) return value.message.startsWith('#') ? value.message.slice(1) : 'VALUE!';
+            return 'string' == typeof value && value.startsWith('#') ? value.slice(1) : void 0;
+        }
+        function finiteParserNumber(value) {
+            return Number.isFinite(value) ? value : 'NUM!';
+        }
         function normalizeFormulaForFortuneParser(formula) {
             const source = formula.replace(/^=/, '');
             let output = '';
@@ -14608,10 +14699,11 @@
                 let unsupportedFunction;
                 let materializedRangeCells = 0;
                 parser.setFunction('IFERROR', evaluateParserIfError).setFunction('ROW', (parameters)=>parameters.length ? null : coordinate.row + 1).setFunction('COLUMN', (parameters)=>parameters.length ? null : coordinate.column + 1);
-                parser.on('callFunction', (name, parameters)=>{
+                parser.on('callFunction', (name, parameters, done)=>{
                     const normalized = normalizeSpreadsheetFunctionName(name);
                     const arity = browserScalarFunctionArities.get(normalized);
                     if (!arity || parameters.length < arity[0] || parameters.length > arity[1]) unsupportedFunction ??= name.toUpperCase();
+                    if ('SUBTOTAL' === normalized) done(evaluateParserSubtotal(parameters));
                 });
                 parser.on('callCellValue', (cell, _options, done)=>{
                     const dependency = this.resolveCoordinate(indexed.sheet, cell);