@a3s-lab/office 0.12.0 → 0.13.1

package/dist/internal/features/work/work-xlsx-worksheet.d.ts

@@ -0,0 +1,12 @@
+import type { CellObject, WorkSheet } from 'xlsx';
+export interface XlsxWorksheetCellEntry {
+    address: string;
+    cell: CellObject;
+    column: number;
+    row: number;
+}
+/**
+ * Iterates both SheetJS sparse address maps and dense row arrays without
+ * materializing a second list of every worksheet cell.
+ */
+export declare function xlsxWorksheetCellEntries(worksheet: WorkSheet): Generator<XlsxWorksheetCellEntry>;

package/dist/office-kernel.worker.js

@@ -13051,8 +13051,8 @@
         };
     })();
     (()=>{
-        const MAX_LAYOUT_BLOCKS = 10000;
-        const MAX_LAYOUT_PAGE_STYLES = MAX_LAYOUT_BLOCKS;
+        const MAX_LAYOUT_BLOCKS = 200000;
+        const MAX_LAYOUT_PAGE_STYLES = 10000;
         const MAX_LAYOUT_EXTENT = 1000000;
         const MAX_LAYOUT_PAGE_INDEX = 1000000;
         function layoutOfficeDocumentInJavaScript(request) {
@@ -13072,10 +13072,10 @@
                 ensurePageMetrics(pages, page);
                 if (void 0 !== block.flowCount) {
                     const end = index + block.flowCount;
-                    layoutFlow(request.blocks.slice(index, end), request.blocks.slice(end), pages, page, request.page, pageStyles, end < request.blocks.length);
+                    layoutFlow(request.blocks, index, end, pages, page, request.page, pageStyles, end < request.blocks.length);
                     index = end;
                 } else {
-                    layoutSingleBlock(block, request.blocks.slice(index + 1), pages, page, request.page, pageStyles, index + 1 < request.blocks.length);
+                    layoutSingleBlock(block, request.blocks, index + 1, pages, page, request.page, pageStyles, index + 1 < request.blocks.length);
                     index += 1;
                 }
             }
@@ -13119,7 +13119,7 @@
             }
             validateFlowSequences(request.blocks);
         }
-        function layoutSingleBlock(block, next, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
+        function layoutSingleBlock(block, blocks, nextIndex, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
             const availableHeight = pageBodyHeight(page);
             let current = pages.at(-1);
             let currentHasContent = current.placements.length > 0;
@@ -13129,7 +13129,7 @@
                 currentHasContent = false;
             }
             const remaining = Math.max(0, availableHeight - current.usedHeight);
-            const nextHeight = nextBlockPreviewHeight(next, page, defaultPage, pageStyles);
+            const nextHeight = nextBlockPreviewHeight(blocks, nextIndex, page, defaultPage, pageStyles);
             const groupedHeight = block.height + (block.keepWithNext ? nextHeight : 0);
             const shouldAdvance = currentHasContent && (block.height > remaining || (block.keepTogether || block.keepWithNext) && groupedHeight <= availableHeight && groupedHeight > remaining);
             if (shouldAdvance) {
@@ -13139,13 +13139,13 @@
             placeFragment(block, current, availableHeight);
             if (block.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), page));
         }
-        function layoutFlow(blocks, next, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
+        function layoutFlow(blocks, start, end, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
             const availableHeight = pageBodyHeight(page);
-            const first = blocks[0];
-            const last = blocks.at(-1);
+            const first = blocks[start];
+            const last = blocks[end - 1];
             if (first.breakBefore && pages.at(-1)?.placements.length) pages.push(emptyPage(nextPageIndex(pages), page));
-            const totalHeight = fragmentHeight(blocks, 0, blocks.length);
-            const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(next, page, defaultPage, pageStyles) : 0;
+            const totalHeight = fragmentHeight(blocks, start, end);
+            const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(blocks, end, page, defaultPage, pageStyles) : 0;
             let current = pages.at(-1);
             const repeatHeaderCount = first.repeatHeaderCount ?? 0;
             const repeatHeaderHeight = first.repeatHeaderHeight ?? 0;
@@ -13154,8 +13154,8 @@
                 current = emptyPage(nextPageIndex(pages), page);
                 pages.push(current);
             }
-            if (repeatHeaderCount > 0 && repeatHeaderCount < blocks.length) {
-                const leadingHeight = fragmentHeight(blocks, 0, repeatHeaderCount + 1);
+            if (repeatHeaderCount > 0 && repeatHeaderCount < end - start) {
+                const leadingHeight = fragmentHeight(blocks, start, start + repeatHeaderCount + 1);
                 const remainingHeight = Math.max(0, availableHeight - current.usedHeight);
                 if (current.placements.length > 0 && leadingHeight <= availableHeight && leadingHeight > remainingHeight) {
                     current = emptyPage(nextPageIndex(pages), page);
@@ -13163,22 +13163,23 @@
                 }
             }
             const minimum = Math.max(1, first.minimumFragmentsPerPage ?? 1);
-            let cursor = 0;
-            while(cursor < blocks.length){
+            let cursor = start;
+            let remainingFlowHeight = totalHeight;
+            while(cursor < end){
                 current = pages.at(-1);
-                if (cursor >= repeatHeaderCount && cursor > 0 && repeatHeaderHeight > 0 && 0 === current.placements.length && 0 === current.usedHeight) current.usedHeight = repeatHeaderHeight;
+                if (cursor - start >= repeatHeaderCount && cursor > start && repeatHeaderHeight > 0 && 0 === current.placements.length && 0 === current.usedHeight) current.usedHeight = repeatHeaderHeight;
                 const currentHasContent = current.placements.length > 0;
                 const remainingHeight = Math.max(0, availableHeight - current.usedHeight);
-                const remainingFragments = blocks.length - cursor;
-                const remainingFlowHeight = fragmentHeight(blocks, cursor, blocks.length);
+                const remainingFragments = end - cursor;
                 if (nextHeight > 0 && currentHasContent && remainingFlowHeight <= remainingHeight && remainingFlowHeight + nextHeight > remainingHeight && remainingFlowHeight + nextHeight <= availableHeight) {
                     pages.push(emptyPage(nextPageIndex(pages), page));
                     continue;
                 }
-                let fitting = fragmentsFitting(blocks, cursor, blocks.length, remainingHeight);
+                let fitting = fragmentsFitting(blocks, cursor, end, remainingHeight);
                 if (fitting === remainingFragments) {
-                    placeFragments(blocks, cursor, blocks.length, current, availableHeight);
-                    cursor = blocks.length;
+                    placeFragments(blocks, cursor, end, current, availableHeight);
+                    cursor = end;
+                    remainingFlowHeight = 0;
                     continue;
                 }
                 if (0 === fitting) {
@@ -13195,18 +13196,19 @@
                     continue;
                 }
                 fitting = Math.max(1, fitting);
+                remainingFlowHeight -= fragmentHeight(blocks, cursor, cursor + fitting);
                 placeFragments(blocks, cursor, cursor + fitting, current, availableHeight);
                 cursor += fitting;
-                if (cursor < blocks.length) pages.push(emptyPage(nextPageIndex(pages), page));
+                if (cursor < end) pages.push(emptyPage(nextPageIndex(pages), page));
             }
             if (last.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), page));
         }
-        function nextBlockPreviewHeight(blocks, currentPage, defaultPage, pageStyles) {
-            const first = blocks[0];
+        function nextBlockPreviewHeight(blocks, start, currentPage, defaultPage, pageStyles) {
+            const first = blocks[start];
             if (!first || first.breakBefore) return 0;
             if (!pageMetricsEqual(currentPage, pageMetricsForBlock(first, defaultPage, pageStyles))) return 0;
             const count = Math.min(2, first.flowCount ?? 1);
-            return fragmentHeight(blocks, 0, count);
+            return fragmentHeight(blocks, start, Math.min(blocks.length, start + count));
         }
         function fragmentsFitting(blocks, start, end, availableHeight) {
             let used = 0;
@@ -13274,13 +13276,13 @@
                 const count = block.flowCount;
                 const repeatHeaderCount = block.repeatHeaderCount;
                 const repeatHeaderHeight = block.repeatHeaderHeight;
-                const flow = blocks.slice(index, index + count);
-                if (flow.length !== count) throw kernelError('office.kernel.flow_sequence_invalid', 'A layout flow must contain its declared number of fragments.');
-                flow.forEach((fragment, flowIndex)=>{
+                if (index + count > blocks.length) throw kernelError('office.kernel.flow_sequence_invalid', 'A layout flow must contain its declared number of fragments.');
+                for(let flowIndex = 0; flowIndex < count; flowIndex += 1){
+                    const fragment = blocks[index + flowIndex];
                     if (fragment.flowId !== block.flowId || fragment.flowIndex !== flowIndex || fragment.flowCount !== count || fragment.minimumFragmentsPerPage !== block.minimumFragmentsPerPage || fragment.repeatHeaderCount !== repeatHeaderCount || fragment.repeatHeaderHeight !== repeatHeaderHeight || fragment.pageStyleId !== block.pageStyleId) throw kernelError('office.kernel.flow_sequence_invalid', 'Layout flow fragments must be consecutive and consistently indexed.');
                     if (flowIndex > 0 && fragment.breakBefore) throw kernelError('office.kernel.flow_break_invalid', 'Only the first flow fragment may request breakBefore.');
                     if (flowIndex + 1 < count && fragment.breakAfter) throw kernelError('office.kernel.flow_break_invalid', 'Only the last flow fragment may request breakAfter.');
-                });
+                }
                 index += count;
             }
         }

package/dist/react.d.ts

@@ -8,13 +8,19 @@ import type { SpreadsheetEditorProps as InternalSpreadsheetEditorProps } from '.
 import type { WorkOfficeFileAction } from './internal/features/work/editors/work-office-chrome';
 import { type OfficeSurfaceProps, type OfficeTheme } from './office-surface';
 export type OfficeEditorKind = 'document' | 'markdown' | 'spreadsheet' | 'presentation' | 'pdf';
+export interface OfficeEditorPreloadOptions {
+    /** Overrides the packaged PDFium asset when preloading the PDF runtime. */
+    pdfWasmUrl?: string;
+    /** Also fetches PDFium WebAssembly. Disabled unless explicitly enabled. */
+    preloadRuntimeAssets?: boolean;
+}
 /**
  * Starts loading one editor without mounting it.
  *
  * Call this from an intent signal such as hover or keyboard focus to keep the
  * initial application bundle small without adding latency to editor opening.
  */
-export declare function preloadOfficeEditor(kind: OfficeEditorKind): Promise<void>;
+export declare function preloadOfficeEditor(kind: OfficeEditorKind, options?: OfficeEditorPreloadOptions): Promise<void>;
 export declare const defaultPdfiumWasmUrl: string;
 export declare const defaultOfficeKernelWasmUrl: string;
 export declare const defaultDocumentLayoutFontUrl: string;