@a3s-lab/office 0.12.0 → 0.13.1

package/dist/0~6090.js

@@ -1235,11 +1235,15 @@ const OFFICE_MENU_NAVIGATION_KEYS = [
     'Home',
     'End'
 ];
+const OFFICE_GRID_MENU_NAVIGATION_KEYS = [
+    ...OFFICE_MENU_NAVIGATION_KEYS,
+    'ArrowLeft',
+    'ArrowRight'
+];
+const OFFICE_MENU_BUTTON_SELECTOR = 'button[role="menuitem"]:not(:disabled), button[role="menuitemradio"]:not(:disabled), button[role="menuitemcheckbox"]:not(:disabled)';
 function moveOfficeMenuFocus(event) {
     if (!OFFICE_MENU_NAVIGATION_KEYS.includes(event.key)) return false;
-    const buttons = [
-        ...event.currentTarget.querySelectorAll('button[role="menuitem"]:not(:disabled), button[role="menuitemradio"]:not(:disabled), button[role="menuitemcheckbox"]:not(:disabled)')
-    ];
+    const buttons = officeMenuButtons(event.currentTarget);
     if (!buttons.length) return false;
     event.preventDefault();
     const current = buttons.indexOf(document.activeElement);
@@ -1247,6 +1251,61 @@ function moveOfficeMenuFocus(event) {
     buttons[next]?.focus();
     return true;
 }
+function moveOfficeGridMenuFocus(event, columns) {
+    if (!OFFICE_GRID_MENU_NAVIGATION_KEYS.includes(event.key)) return false;
+    const buttons = officeMenuButtons(event.currentTarget);
+    if (!buttons.length) return false;
+    event.preventDefault();
+    const currentButton = document.activeElement;
+    const current = Math.max(0, buttons.indexOf(currentButton));
+    if ('Home' === event.key || 'End' === event.key) {
+        buttons['Home' === event.key ? 0 : buttons.length - 1]?.focus();
+        return true;
+    }
+    if ('ArrowLeft' === event.key || 'ArrowRight' === event.key) {
+        const delta = 'ArrowRight' === event.key ? 1 : -1;
+        buttons[(current + delta + buttons.length) % buttons.length]?.focus();
+        return true;
+    }
+    const groups = [
+        ...event.currentTarget.querySelectorAll('[data-office-menu-grid]')
+    ];
+    const groupIndex = groups.findIndex((group)=>group.contains(currentButton));
+    if (groupIndex < 0) {
+        const delta = 'ArrowDown' === event.key ? columns : -columns;
+        buttons[(current + delta + buttons.length) % buttons.length]?.focus();
+        return true;
+    }
+    const groupButtons = officeMenuButtons(groups[groupIndex]);
+    const localIndex = Math.max(0, groupButtons.indexOf(currentButton));
+    const column = localIndex % columns;
+    if ('ArrowDown' === event.key) {
+        const nextRow = localIndex - column + columns;
+        if (nextRow < groupButtons.length) {
+            groupButtons[Math.min(nextRow + column, groupButtons.length - 1)]?.focus();
+            return true;
+        }
+        const nextGroup = groups[(groupIndex + 1) % groups.length];
+        const nextButtons = officeMenuButtons(nextGroup);
+        nextButtons[Math.min(column, nextButtons.length - 1)]?.focus();
+        return true;
+    }
+    const previousRow = localIndex - column - columns;
+    if (previousRow >= 0) {
+        groupButtons[previousRow + column]?.focus();
+        return true;
+    }
+    const previousGroup = groups[(groupIndex - 1 + groups.length) % groups.length];
+    const previousButtons = officeMenuButtons(previousGroup);
+    const previousRowStart = Math.floor((previousButtons.length - 1) / columns) * columns;
+    previousButtons[Math.min(previousRowStart + column, previousButtons.length - 1)]?.focus();
+    return true;
+}
+function officeMenuButtons(root) {
+    return [
+        ...root.querySelectorAll(OFFICE_MENU_BUTTON_SELECTOR)
+    ];
+}
 function stepOfficeZoom(zoom, direction, { minimum = 50, maximum = 200, step = 10 } = {}) {
     const delta = 'in' === direction ? step : -step;
     return Math.min(maximum, Math.max(minimum, Math.round(zoom + delta)));
@@ -1280,4 +1339,4 @@ function useOfficeEditorWheelZoom({ enabled = true, scopeRef, onZoomIn, onZoomOu
         scopeRef
     ]);
 }
-export { CommittedOfficeTextArea, CommittedOfficeTextField, MarkdownSourcePresenceLayer, OfficePresenceAvatar, OfficeTiptapPresenceLayer, Popover, WorkOfficeCollaborationParticipants, button_Button, icon_button_IconButton, matchesAriaKeyShortcuts, matchesOfficeEditorKeyboardShortcut, moveOfficeMenuFocus, officeOverlayPortalRoot, officePresenceColor, officePresenceColorStyle, office_text_field_OfficeFileInput, office_text_field_OfficeTextArea, office_text_field_OfficeTextField, stepOfficeZoom, useDialogFocusScope, useOfficeEditorWheelZoom, useOfficePublishPresenceLocation, useOfficeRemoteParticipants };
+export { CommittedOfficeTextArea, CommittedOfficeTextField, MarkdownSourcePresenceLayer, OfficePresenceAvatar, OfficeTiptapPresenceLayer, Popover, WorkOfficeCollaborationParticipants, button_Button, icon_button_IconButton, matchesAriaKeyShortcuts, matchesOfficeEditorKeyboardShortcut, moveOfficeGridMenuFocus, moveOfficeMenuFocus, officeOverlayPortalRoot, officePresenceColor, officePresenceColorStyle, office_text_field_OfficeFileInput, office_text_field_OfficeTextArea, office_text_field_OfficeTextField, stepOfficeZoom, useDialogFocusScope, useOfficeEditorWheelZoom, useOfficePublishPresenceLocation, useOfficeRemoteParticipants };

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;
     }
 }