@a3s-lab/office 0.11.0 → 0.13.0

package/dist/0~7048.js

@@ -667,8 +667,8 @@ function officeFontFamilyLabel(value) {
 function normalizeOfficeFontFamily(value) {
     return officeFontFamilyLabel(value).toLocaleLowerCase();
 }
-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) {
@@ -688,10 +688,10 @@ function layoutOfficeDocumentInJavaScript(request) {
         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;
         }
     }
@@ -735,7 +735,7 @@ function validateLayoutRequest(request) {
     }
     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;
@@ -745,7 +745,7 @@ function layoutSingleBlock(block, next, pages, page, defaultPage, pageStyles, ha
         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) {
@@ -755,13 +755,13 @@ function layoutSingleBlock(block, next, pages, page, defaultPage, pageStyles, ha
     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;
@@ -770,8 +770,8 @@ function layoutFlow(blocks, next, pages, page, defaultPage, pageStyles, hasMoreB
         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);
@@ -779,22 +779,23 @@ function layoutFlow(blocks, next, pages, page, defaultPage, pageStyles, hasMoreB
         }
     }
     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) {
@@ -811,18 +812,19 @@ function layoutFlow(blocks, next, pages, page, defaultPage, pageStyles, hasMoreB
             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;
@@ -890,13 +892,13 @@ function validateFlowSequences(blocks) {
         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;
     }
 }