@a3s-lab/office 0.1.0 → 0.2.2

package/dist/internal/features/work/editors/document-navigation-window.d.ts

@@ -0,0 +1,64 @@
+import { type UIEventHandler } from 'react';
+export declare const DOCUMENT_NAVIGATION_COLLECTION_WINDOW_THRESHOLD = 48;
+export declare const DOCUMENT_NAVIGATION_COLLECTION_WINDOW_LIMIT = 32;
+export declare const DOCUMENT_NAVIGATION_COLLECTION_WINDOW_OVERSCAN = 4;
+export interface DocumentNavigationWindowRange {
+    end: number;
+    start: number;
+    windowed: boolean;
+}
+export interface DocumentNavigationWindowSpacerEntry {
+    end: number;
+    height: number;
+    kind: 'spacer';
+    position: 'after' | 'before' | 'between';
+    start: number;
+}
+export interface DocumentNavigationWindowItemEntry {
+    index: number;
+    kind: 'item';
+}
+export type DocumentNavigationWindowEntry = DocumentNavigationWindowItemEntry | DocumentNavigationWindowSpacerEntry;
+export interface DocumentNavigationListHandle {
+    focusFirst: () => void;
+    focusLast: () => void;
+}
+export declare function useDocumentNavigationWindow<TViewport extends HTMLElement = HTMLElement>({ estimatedItemHeight, itemGap, keys, listPaddingTop, onRovingKeyChange, pinnedKeys, rovingKey, }: {
+    estimatedItemHeight: number;
+    itemGap: number;
+    keys: readonly string[];
+    listPaddingTop: number;
+    onRovingKeyChange: (key: string) => void;
+    pinnedKeys?: readonly (string | null | undefined)[];
+    rovingKey: string | null;
+}): {
+    entries: DocumentNavigationWindowEntry[];
+    focusAt: (requestedIndex: number) => void;
+    mountedCount: number;
+    onItemFocus: (index: number) => void;
+    onScroll: UIEventHandler<HTMLElement>;
+    range: DocumentNavigationWindowRange;
+    registerItem: (key: string, element: HTMLElement | null) => void;
+    rovingIndex: number;
+    viewportRef: import("react").RefObject<TViewport | null>;
+};
+export declare function DocumentNavigationWindowSpacer({ entry, }: {
+    entry: DocumentNavigationWindowSpacerEntry;
+}): import("react").JSX.Element;
+export declare function calculateDocumentNavigationWindowRange({ anchorIndex, averageItemHeight, itemCount, limit, overscan, threshold, viewportHeight, }: {
+    anchorIndex: number;
+    averageItemHeight: number;
+    itemCount: number;
+    limit: number;
+    overscan: number;
+    threshold: number;
+    viewportHeight: number;
+}): DocumentNavigationWindowRange;
+export declare function documentNavigationItemStarts(itemHeights: readonly number[], itemGap: number): number[];
+export declare function documentNavigationWindowIndices({ itemCount, pinnedIndices, range, }: {
+    itemCount: number;
+    pinnedIndices: readonly number[];
+    range: DocumentNavigationWindowRange;
+}): number[];
+export declare function documentNavigationWindowEntries(mountedIndices: readonly number[], itemStarts: readonly number[], itemCount: number, itemGap: number): DocumentNavigationWindowEntry[];
+export declare function documentNavigationIndexAtOffset(itemStarts: readonly number[], offset: number, itemCount: number): number;

package/dist/internal/features/work/editors/document-outline-navigation.d.ts

@@ -0,0 +1,11 @@
+import type { WorkDocumentOutlineItem } from '../work-document-outline';
+import { type DocumentNavigationListHandle } from './document-navigation-window';
+export declare const DocumentOutlineNavigation: import("react").ForwardRefExoticComponent<{
+    activeItemId: string | null;
+    collapsedIds: ReadonlySet<string>;
+    items: readonly WorkDocumentOutlineItem[];
+    rovingId: string | null;
+    onNavigate: (position: number) => void;
+    onRovingIdChange: (itemId: string) => void;
+    onToggleCollapsed: (itemId: string) => void;
+} & import("react").RefAttributes<DocumentNavigationListHandle>>;

package/dist/internal/features/work/editors/document-page-navigation.d.ts

@@ -1,4 +1,7 @@
 import type { WorkDocumentSectionLayout } from '../work-types';
+import { type DocumentNavigationWindowRange } from './document-navigation-window';
+import { type WorkDocumentPageThumbnailSource } from './document-page-thumbnail';
+export declare const DOCUMENT_PAGE_WINDOW_LIMIT = 24;
 export interface DocumentNavigationPage {
     backgroundColor?: string;
     physicalPage: number;
@@ -7,8 +10,15 @@ export interface DocumentNavigationPage {
     previewText: string;
     selectionPosition: number;
 }
-export declare function DocumentPageNavigation({ currentPage, pages, onSelectPage, }: {
+export declare function DocumentPageNavigation({ currentPage, pages, thumbnailSource, onSelectPage, }: {
     currentPage: number;
     pages: readonly DocumentNavigationPage[];
+    thumbnailSource?: WorkDocumentPageThumbnailSource;
     onSelectPage: (page: DocumentNavigationPage) => void | Promise<void>;
 }): import("react").JSX.Element;
+export declare function calculateDocumentPageRange({ anchorIndex, averageItemHeight, pageCount, viewportHeight, }: {
+    anchorIndex: number;
+    averageItemHeight: number;
+    pageCount: number;
+    viewportHeight: number;
+}): DocumentNavigationWindowRange;

package/dist/internal/features/work/editors/document-page-thumbnail.d.ts

@@ -0,0 +1,31 @@
+export interface WorkDocumentPageThumbnailSource {
+    element: HTMLElement;
+    pageCount: number;
+    pageGap: number;
+    pageHeight: number;
+    pageWidth: number;
+    revision: string;
+}
+export interface DocumentPageCanvasRenderOptions {
+    backgroundColor: string;
+    fontReadyTimeout: 0;
+    height: number;
+    logging: false;
+    scale: number;
+    useCORS: true;
+    width: number;
+    windowHeight: number;
+    windowWidth: number;
+}
+export type DocumentPageCanvasRenderer = (element: HTMLElement, options: DocumentPageCanvasRenderOptions) => Promise<HTMLCanvasElement>;
+export type DocumentPageThumbnailRenderer = (source: WorkDocumentPageThumbnailSource, pageIndex: number, targetPixelWidth: number) => Promise<string>;
+export declare function DocumentPageThumbnail({ backgroundColor, fallbackText, orientation, pageIndex, priority, source, renderThumbnail, }: {
+    backgroundColor?: string;
+    fallbackText: string;
+    orientation: 'portrait' | 'landscape';
+    pageIndex: number;
+    priority?: boolean;
+    source?: WorkDocumentPageThumbnailSource;
+    renderThumbnail?: DocumentPageThumbnailRenderer;
+}): import("react").JSX.Element;
+export declare function renderDocumentPageThumbnail(source: WorkDocumentPageThumbnailSource, pageIndex: number, targetPixelWidth: number, renderCanvas?: DocumentPageCanvasRenderer): Promise<string>;

package/dist/internal/features/work/editors/document-picture-properties-dialog-model.d.ts

@@ -0,0 +1,28 @@
+import type { WorkDocumentImageAlignment, WorkDocumentImageLayout, WorkDocumentImageProperties } from '../work-document-image-layout';
+export declare const IMAGE_PIXELS_PER_CENTIMETER: number;
+export interface DocumentPicturePropertiesSource {
+    properties: WorkDocumentImageProperties;
+    renderedWidth?: number;
+    renderedHeight?: number;
+}
+export interface DocumentPicturePropertiesDraft {
+    width: string;
+    height: string;
+    lockAspectRatio: boolean;
+    aspectRatio: number;
+    layout: WorkDocumentImageLayout;
+    alignment: WorkDocumentImageAlignment;
+    wrapDistance: string;
+    alternativeText: string;
+}
+export interface DocumentPicturePropertiesErrors {
+    width: string | null;
+    height: string | null;
+    wrapDistance: string | null;
+}
+export declare function createDocumentPicturePropertiesDraft(source: DocumentPicturePropertiesSource): DocumentPicturePropertiesDraft;
+export declare function withDocumentPictureDimension(draft: DocumentPicturePropertiesDraft, dimension: 'height' | 'width', value: string): DocumentPicturePropertiesDraft;
+export declare function withDocumentPictureAspectRatioLock(draft: DocumentPicturePropertiesDraft, lockAspectRatio: boolean): DocumentPicturePropertiesDraft;
+export declare function documentPicturePropertiesErrors(draft: DocumentPicturePropertiesDraft): DocumentPicturePropertiesErrors;
+export declare function hasDocumentPicturePropertiesErrors(errors: DocumentPicturePropertiesErrors): boolean;
+export declare function documentPicturePropertyChanges(initial: DocumentPicturePropertiesDraft, current: DocumentPicturePropertiesDraft): Partial<WorkDocumentImageProperties> | null;

package/dist/internal/features/work/editors/document-picture-properties-dialog.d.ts

@@ -0,0 +1,4 @@
+import type { Editor } from '@tiptap/core';
+export declare function DocumentPicturePropertiesControl({ editor, }: {
+    editor: Editor;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-search-navigation.d.ts

@@ -0,0 +1,12 @@
+import { type WorkDocumentOutlineItem } from '../work-document-outline';
+import type { DocumentTextMatch } from '../work-document-search';
+import { type DocumentNavigationListHandle } from './document-navigation-window';
+export declare const DocumentSearchNavigation: import("react").ForwardRefExoticComponent<{
+    matches: readonly DocumentTextMatch[];
+    outline: readonly WorkDocumentOutlineItem[];
+    rovingId: string | null;
+    selectedMatchIndex: number;
+    onRovingIdChange: (resultId: string) => void;
+    onSelect: (match: DocumentTextMatch) => void;
+} & import("react").RefAttributes<DocumentNavigationListHandle>>;
+export declare function documentNavigationMatchId(match: DocumentTextMatch): string;

package/dist/internal/features/work/editors/document-table-margins-popover.d.ts

@@ -0,0 +1,4 @@
+import type { Editor } from '@tiptap/core';
+export declare function DocumentTableMarginsPopover({ editor }: {
+    editor: Editor;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-table-properties-dialog-model.d.ts

@@ -0,0 +1,51 @@
+import type { DocumentTableCellFormat } from '../work-document-table-cell-formatting';
+import type { DocumentTableAlignment, DocumentTableCellMarginSide, DocumentTablePreferredWidthType } from '../work-document-table-geometry';
+import type { DocumentTableRowHeightRule, DocumentTableRowOptions } from '../work-document-table-row';
+import type { DocumentTablePropertyChanges, DocumentTableSizingState } from '../work-document-table-sizing';
+export declare const PIXELS_PER_CENTIMETER: number;
+export type DocumentTablePropertiesTab = 'table' | 'row' | 'column' | 'cell';
+export interface DocumentTablePropertiesDraft {
+    table: {
+        widthType: DocumentTablePreferredWidthType;
+        width: string;
+        alignment: DocumentTableAlignment;
+        indent: string;
+    };
+    row: {
+        heightEnabled: boolean;
+        height: string;
+        heightRule: DocumentTableRowHeightRule;
+        cantSplit: boolean;
+        repeatHeader: boolean;
+    };
+    column: {
+        width: string;
+    };
+    cell: {
+        verticalAlign: DocumentTableCellFormat['verticalAlign'];
+        useTableMargins: boolean;
+        margins: Record<DocumentTableCellMarginSide, string>;
+    };
+}
+export interface DocumentTablePropertiesSource {
+    sizing: DocumentTableSizingState;
+    rowOptions: DocumentTableRowOptions;
+    cellFormat: DocumentTableCellFormat;
+    canRepeatHeader: boolean;
+    renderedTableWidth?: number;
+    renderedRowHeight?: number;
+    renderedColumnWidth?: number;
+    renderedColumnWidths?: readonly number[];
+}
+export interface DocumentTablePropertiesErrors {
+    tableWidth: string | null;
+    tableIndent: string | null;
+    rowHeight: string | null;
+    columnWidth: string | null;
+    cellMargins: Partial<Record<DocumentTableCellMarginSide, string>>;
+}
+export declare function createDocumentTablePropertiesDraft(source: DocumentTablePropertiesSource): DocumentTablePropertiesDraft;
+export declare function documentTablePropertiesErrors(draft: DocumentTablePropertiesDraft): DocumentTablePropertiesErrors;
+export declare function hasDocumentTablePropertiesErrors(errors: DocumentTablePropertiesErrors): boolean;
+export declare function draftForTableWidthType(current: DocumentTablePropertiesDraft, widthType: DocumentTablePreferredWidthType, renderedTableWidth: number | undefined): DocumentTablePropertiesDraft;
+export declare function documentTablePropertyChanges(initial: DocumentTablePropertiesDraft, current: DocumentTablePropertiesDraft, source: Pick<DocumentTablePropertiesSource, 'canRepeatHeader' | 'cellFormat' | 'renderedColumnWidths' | 'sizing'>): DocumentTablePropertyChanges | null;

package/dist/internal/features/work/editors/document-table-properties-dialog-sections.d.ts

@@ -0,0 +1,19 @@
+import type { Dispatch, SetStateAction } from 'react';
+import type { DocumentTablePropertiesSource } from './document-table-properties-dialog-model';
+import { type DocumentTablePropertiesDraft, type DocumentTablePropertiesErrors, type DocumentTablePropertiesTab } from './document-table-properties-dialog-model';
+interface SectionProps {
+    draft: DocumentTablePropertiesDraft;
+    setDraft: Dispatch<SetStateAction<DocumentTablePropertiesDraft>>;
+    errors: DocumentTablePropertiesErrors;
+    source: DocumentTablePropertiesSource;
+}
+export declare function DocumentTablePropertiesTabs({ activeTab, idBase, onTabChange, }: {
+    activeTab: DocumentTablePropertiesTab;
+    idBase: string;
+    onTabChange: (tab: DocumentTablePropertiesTab) => void;
+}): import("react").JSX.Element;
+export declare function DocumentTablePropertiesPanel({ activeTab, idBase, ...props }: SectionProps & {
+    activeTab: DocumentTablePropertiesTab;
+    idBase: string;
+}): import("react").JSX.Element;
+export {};

package/dist/internal/features/work/editors/document-table-properties-dialog.d.ts

@@ -0,0 +1,8 @@
+import type { Editor } from '@tiptap/core';
+export declare function DocumentTablePropertiesControl({ editor, renderedTableWidth, renderedRowHeight, renderedColumnWidth, renderedColumnWidths, }: {
+    editor: Editor;
+    renderedTableWidth?: number;
+    renderedRowHeight?: number;
+    renderedColumnWidth?: number;
+    renderedColumnWidths?: readonly number[];
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/office-task-pane.d.ts

@@ -3,5 +3,5 @@ export declare const OFFICE_TASK_PANE_MODAL_QUERY = "(max-width: 900px)";
 type OfficeTaskPaneClose = () => unknown;
 export declare function handleOfficeTaskPaneKeyDown(event: KeyboardEvent<HTMLElement>, onClose: OfficeTaskPaneClose): void;
 export declare function useOfficeTaskPaneEscape(active: boolean, onClose: OfficeTaskPaneClose): void;
-export declare function useOfficeTaskPaneModal(): boolean;
+export declare function useOfficeTaskPaneModal(query?: string): boolean;
 export {};

package/dist/internal/features/work/editors/presentation-chart-panel.d.ts

@@ -1,7 +1,8 @@
 import type { WorkSlideChart } from '../work-types';
-export declare function PresentationChartPanel({ chart, onChange, onDelete, onClose, }: {
+export declare function PresentationChartPanel({ chart, onChange, onDelete, onClose, restoreFocusTarget, }: {
     chart: WorkSlideChart;
     onChange: (chart: WorkSlideChart) => void;
     onDelete: () => void;
     onClose: () => void;
+    restoreFocusTarget?: () => HTMLElement | null;
 }): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-comments-panel.d.ts

@@ -1,9 +1,10 @@
 import type { WorkSlide } from '../work-types';
 import type { PresentationEditorCommands } from './presentation-command-types';
 export type PresentationCommentsPanelCommands = Pick<PresentationEditorCommands, 'closeComments' | 'deletePresentationComment' | 'locatePresentationComment' | 'updatePresentationComment'>;
-export declare function PresentationCommentsPanel({ slides, activeCommentId, commands, }: {
+export declare function PresentationCommentsPanel({ slides, activeCommentId, commands, restoreFocusTarget, }: {
     slides: WorkSlide[];
     activeCommentId: string | null;
     commands: PresentationCommentsPanelCommands;
+    restoreFocusTarget?: () => HTMLElement | null;
 }): import("react").JSX.Element;
 export declare function presentationCommentCount(slides: readonly WorkSlide[]): number;

package/dist/internal/features/work/editors/spreadsheet-workbook-panel.d.ts

@@ -10,7 +10,8 @@ interface SpreadsheetWorkbookPanelProps {
     selection?: Selection;
     can: Pick<SpreadsheetEditorCanCommands, 'recalculateFormula'>;
     commands: Pick<SpreadsheetEditorCommands, 'recalculateFormula' | 'setSpreadsheetContent'>;
+    restoreFocusTarget?: () => HTMLElement | null;
     onClose: () => void;
 }
-export declare function SpreadsheetWorkbookPanel({ id, content, view, activeSheetId, selection, can, commands, onClose, }: SpreadsheetWorkbookPanelProps): import("react").JSX.Element;
+export declare function SpreadsheetWorkbookPanel({ id, content, view, activeSheetId, selection, can, commands, restoreFocusTarget, onClose, }: SpreadsheetWorkbookPanelProps): import("react").JSX.Element;
 export {};

package/dist/internal/features/work/editors/use-document-pagination.d.ts

@@ -23,6 +23,11 @@ export interface DocumentPaginationPageDescriptor {
     layout: WorkDocumentSectionLayout;
     pageChrome: ResolvedDocumentPageChrome;
 }
+export interface DocumentPaginationPageDescriptorDerivation {
+    pages: DocumentPaginationPageDescriptor[];
+    reusedPageCount: number;
+    derivedPageCount: number;
+}
 export interface UseDocumentPaginationOptions {
     editor: Editor | null;
     documentRevision: number;
@@ -43,4 +48,5 @@ export interface UseDocumentPaginationValue {
 }
 export declare function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, page, selectionVersion, wasmUrl, layoutFonts, loadedLayoutFontIds, }: UseDocumentPaginationOptions): UseDocumentPaginationValue;
 export declare function documentPaginationPageDescriptors(layout: OfficeKernelLayoutResult, blocks: readonly MeasuredDocumentLayoutBlock[], documentNode?: ProseMirrorNode): DocumentPaginationPageDescriptor[];
+export declare function deriveDocumentPaginationPageDescriptors(layout: OfficeKernelLayoutResult, blocks: readonly MeasuredDocumentLayoutBlock[], documentNode?: ProseMirrorNode, previousPages?: readonly DocumentPaginationPageDescriptor[], requestedReusedPageCount?: number): DocumentPaginationPageDescriptorDerivation;
 export declare function pageForPosition(pagination: DocumentPaginationResult, position: number): number;

package/dist/internal/features/work/editors/use-presentation-review-commands.d.ts

@@ -14,7 +14,7 @@ export declare function usePresentationReviewCommands({ content, onChange, onCle
     onChange: (content: WorkPresentationContent) => void;
     onClearSelection: () => void;
     onCloseComments: () => void;
-    onOpenComments: () => void;
+    onOpenComments: (invoker?: HTMLElement | null) => void;
     onSelectComment: (id: string | null) => void;
     onSelectSlide: (id: string) => void;
     selectedElement: WorkSlideElement | null;

package/dist/internal/features/work/work-document-image-layout.d.ts

@@ -6,12 +6,19 @@ export interface WorkDocumentImageLayoutOptions {
     alignment: WorkDocumentImageAlignment;
     wrapDistance: number;
 }
+export interface WorkDocumentImageProperties extends WorkDocumentImageLayoutOptions {
+    width: number | null;
+    height: number | null;
+    lockAspectRatio: boolean;
+    alternativeText: string;
+}
 export interface DocumentImageCommandOptions {
     restoreFocus?: boolean;
 }
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
         documentImage: {
+            setDocumentImageProperties: (value: Partial<WorkDocumentImageProperties>, options?: DocumentImageCommandOptions) => ReturnType;
             setDocumentImageAlternativeText: (alternativeText: string, options?: DocumentImageCommandOptions) => ReturnType;
             setDocumentImageLayoutOptions: (value: Partial<WorkDocumentImageLayoutOptions>, options?: DocumentImageCommandOptions) => ReturnType;
         };
@@ -19,6 +26,8 @@ declare module '@tiptap/core' {
 }
 export declare const DocumentImage: import("@tiptap/core").Node<import("@tiptap/extension-image").ImageOptions, any>;
 export declare function documentImageLayoutOptions(editor: Editor): WorkDocumentImageLayoutOptions;
+export declare function documentImageProperties(editor: Editor): WorkDocumentImageProperties;
+export declare function setDocumentImageProperties(editor: Editor, value: Partial<WorkDocumentImageProperties>, options?: DocumentImageCommandOptions): boolean;
 export declare function setDocumentImageLayoutOptions(editor: Editor, value: Partial<WorkDocumentImageLayoutOptions>, options?: DocumentImageCommandOptions): boolean;
 export declare function setDocumentImageAlternativeText(editor: Editor, alternativeText: string, options?: DocumentImageCommandOptions): boolean;
 export declare function documentImageAlternativeText(editor: Editor): string;
@@ -27,3 +36,5 @@ export declare function normalizeDocumentImageLayoutOptions(value: Partial<Recor
 export declare function normalizeDocumentImageLayout(value: unknown): WorkDocumentImageLayout;
 export declare function normalizeDocumentImageAlignment(value: unknown): WorkDocumentImageAlignment;
 export declare function normalizeDocumentImageWrapDistance(value: unknown): number;
+export declare function normalizeDocumentImageDimension(value: unknown): number | null;
+export declare function normalizeDocumentImageLockAspectRatio(value: unknown): boolean;

package/dist/internal/features/work/work-document-page-capture.d.ts

@@ -0,0 +1,15 @@
+export interface WorkLiveDocumentCaptureSurface {
+    element: HTMLElement;
+    pageCount: number;
+    pageGap: number;
+    pageHeight: number;
+    pageWidth: number;
+}
+export interface WorkLiveDocumentCapture {
+    backgroundColor: string;
+    host: HTMLDivElement;
+    snapshot: HTMLElement;
+    viewport: HTMLDivElement;
+}
+export declare function mountWorkLiveDocumentCapture(surface: WorkLiveDocumentCaptureSurface, firstPageIndex?: number, captureHeight?: number): WorkLiveDocumentCapture;
+export declare function normalizeWorkLiveDocumentSnapshot(snapshot: HTMLElement): void;

package/dist/internal/features/work/work-document-paragraph-formatting.d.ts

@@ -3,6 +3,7 @@ export declare const DOCUMENT_INDENT_STEP_PX = 24;
 export declare const MAX_DOCUMENT_INDENT_LEVEL = 8;
 export declare const DOCUMENT_RULER_INDENT_STEP_PX = 6;
 export declare const MAX_DOCUMENT_INDENT_PX: number;
+export declare const DOCUMENT_WORD_SINGLE_LINE_HEIGHT = 1.15;
 export interface DocumentParagraphIndent {
     left: number;
     right: number;
@@ -59,3 +60,6 @@ export declare function setDocumentParagraphSpacing(editor: Editor, spacing: Doc
 export declare function normalizeDocumentParagraphIndent(indent: DocumentParagraphIndent): DocumentParagraphIndent;
 export declare function normalizeDocumentParagraphDirection(value: unknown): DocumentParagraphDirection | null;
 export declare function clearDocumentFormatting(editor: Editor): boolean;
+export declare function documentAutoLineHeight(value: unknown): number | null;
+export declare function documentAutoLineLeadingShift(value: unknown): number | null;
+export declare function renderDocumentAutoLineHeight(lineHeight: unknown, autoLineHeight?: unknown): Record<string, string>;

package/dist/internal/features/work/work-document-section.d.ts

@@ -1,4 +1,4 @@
-import type { WorkDocumentContent, WorkDocumentSectionBreakType, WorkDocumentSectionLayout } from './work-types';
+import type { WorkDocumentContent, WorkDocumentGridType, WorkDocumentSectionBreakType, WorkDocumentSectionLayout } from './work-types';
 export interface WorkDocumentSection {
     id: string;
     layout: WorkDocumentSectionLayout;
@@ -22,6 +22,8 @@ export interface DocumentSectionNodeAttributes {
     showPageNumbers: boolean;
     pageNumberStart: number | null;
     pageChrome: string;
+    documentGridType: WorkDocumentGridType | '';
+    documentGridLinePitch: number | null;
 }
 export declare function documentInitialSectionLayout(content: WorkDocumentContent): WorkDocumentSectionLayout;
 export declare function normalizeDocumentHtml(content: WorkDocumentContent): string;

package/dist/internal/features/work/work-document-table-borders.d.ts

@@ -0,0 +1,20 @@
+import type { CommandProps } from '@tiptap/core';
+export type DocumentTableBorderStyle = 'solid' | 'dashed' | 'dotted' | 'double' | 'none';
+export type DocumentTableBorderEdge = 'top' | 'right' | 'bottom' | 'left';
+export type DocumentTableBorderTarget = 'all' | 'outside' | 'inside' | 'top' | 'right' | 'bottom' | 'left' | 'insideHorizontal' | 'insideVertical';
+export interface DocumentTableBorder {
+    color: string;
+    style: DocumentTableBorderStyle;
+    width: number;
+}
+export type DocumentTableCellBorders = Record<DocumentTableBorderEdge, DocumentTableBorder>;
+export declare function uniformDocumentTableBorders(border: DocumentTableBorder): DocumentTableCellBorders;
+export declare function documentTableBordersFromAttributes(attributes: Record<string, unknown>, fallback: DocumentTableBorder): DocumentTableCellBorders;
+export declare function documentTableBordersFromElement(element: HTMLElement, fallback: DocumentTableBorder): DocumentTableCellBorders;
+export declare function renderDocumentTableBorders(borders: DocumentTableCellBorders): Record<string, string>;
+export declare function uniformDocumentTableBorder(borders: DocumentTableCellBorders): DocumentTableBorder | null;
+export declare function normalizeDocumentTableBorder(value: unknown): DocumentTableBorder | null;
+export declare function normalizeTableColor(value: string | null | undefined): string | null;
+export declare function normalizeDocumentTableBorderStyle(value: string | null | undefined): DocumentTableBorderStyle | null;
+export declare function normalizeDocumentTableBorderWidth(value: unknown): number | null;
+export declare function setSelectedDocumentTableBorders({ dispatch, state }: CommandProps, target: DocumentTableBorderTarget, requestedBorder: DocumentTableBorder): boolean;

package/dist/internal/features/work/work-document-table-cell-formatting.d.ts

@@ -1,16 +1,21 @@
 import { Extension } from '@tiptap/core';
 import { type EditorState } from '@tiptap/pm/state';
+import { type DocumentTableBorder, type DocumentTableBorderStyle, type DocumentTableBorderTarget, type DocumentTableCellBorders } from './work-document-table-borders';
+import { type DocumentTableCellMarginOverrides } from './work-document-table-geometry';
+export { documentTableBordersFromElement, normalizeDocumentTableBorder, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeTableColor, renderDocumentTableBorders, uniformDocumentTableBorder, uniformDocumentTableBorders, } from './work-document-table-borders';
+export type { DocumentTableBorder, DocumentTableBorderEdge, DocumentTableBorderStyle, DocumentTableBorderTarget, DocumentTableCellBorders, } from './work-document-table-borders';
 export type DocumentTableVerticalAlign = 'top' | 'middle' | 'bottom';
 export type DocumentTableHorizontalAlign = 'left' | 'center' | 'right';
-export type DocumentTableBorderStyle = 'solid' | 'dashed' | 'dotted' | 'double' | 'none';
 export interface DocumentTableCellFormat {
     backgroundColor: string;
     verticalAlign: DocumentTableVerticalAlign;
     borderColor: string;
     borderStyle: DocumentTableBorderStyle;
     borderWidth: number;
+    borders: DocumentTableCellBorders;
+    margins: DocumentTableCellMarginOverrides | null;
 }
-export type DocumentTableCellFormatPatch = Partial<DocumentTableCellFormat>;
+export type DocumentTableCellFormatPatch = Partial<Omit<DocumentTableCellFormat, 'borders'>>;
 export type DocumentTableStyleId = 'grid' | 'blueStripe' | 'greenStripe' | 'grayStripe' | 'clean';
 export interface DocumentTableStyleOption {
     id: DocumentTableStyleId;
@@ -31,6 +36,7 @@ declare module '@tiptap/core' {
             setDocumentTableCellFormat: (format: DocumentTableCellFormatPatch) => ReturnType;
             setDocumentTableHorizontalAlignment: (alignment: DocumentTableHorizontalAlign) => ReturnType;
             applyDocumentTableStyle: (style: DocumentTableStyleId) => ReturnType;
+            setDocumentTableBorders: (target: DocumentTableBorderTarget, border: DocumentTableBorder) => ReturnType;
         };
     }
 }
@@ -40,7 +46,4 @@ export declare const DocumentTableFormatting: Extension<any, any>;
 export declare function documentTableCellFormat(state: EditorState): DocumentTableCellFormat | null;
 export declare function documentTableHorizontalAlignment(state: EditorState): DocumentTableHorizontalAlign;
 export declare function activeDocumentTableStyle(state: EditorState): DocumentTableStyleId | null;
-export declare function normalizeTableColor(value: string | null | undefined): string | null;
 export declare function normalizeDocumentTableVerticalAlign(value: string | null | undefined): DocumentTableVerticalAlign | null;
-export declare function normalizeDocumentTableBorderStyle(value: string | null | undefined): DocumentTableBorderStyle | null;
-export declare function normalizeDocumentTableBorderWidth(value: unknown): number | null;

package/dist/internal/features/work/work-document-table-geometry.d.ts

@@ -0,0 +1,41 @@
+export type DocumentTableLayoutAlgorithm = 'autofit' | 'fixed';
+export type DocumentTablePreferredWidthType = 'auto' | 'percent' | 'pixels';
+export type DocumentTableAlignment = 'left' | 'center' | 'right';
+export type DocumentTableLayoutMode = 'window' | 'contents' | 'fixed';
+export type DocumentTableCellMarginSide = 'top' | 'right' | 'bottom' | 'left';
+export interface DocumentTablePreferredWidth {
+    type: DocumentTablePreferredWidthType;
+    value: number | null;
+}
+export interface DocumentTableCellMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export type DocumentTableCellMarginOverrides = Partial<DocumentTableCellMargins>;
+export interface DocumentTableGeometry {
+    layout: DocumentTableLayoutAlgorithm;
+    width: DocumentTablePreferredWidth;
+    alignment: DocumentTableAlignment;
+    indent: number;
+    cellMargins: DocumentTableCellMargins;
+}
+export type DocumentTableProperties = Pick<DocumentTableGeometry, 'width' | 'alignment' | 'indent'>;
+export declare const DEFAULT_DOCUMENT_TABLE_CELL_MARGINS: DocumentTableCellMargins;
+export declare const DEFAULT_DOCUMENT_TABLE_GEOMETRY: DocumentTableGeometry;
+export declare function normalizeDocumentTableGeometry(value: unknown, legacyLayoutMode?: unknown): DocumentTableGeometry;
+export declare function normalizeDocumentTableLayoutMode(value: unknown): DocumentTableLayoutMode;
+export declare function normalizeDocumentTableLayoutAlgorithm(value: unknown): DocumentTableLayoutAlgorithm | null;
+export declare function normalizeDocumentTableAlignment(value: unknown): DocumentTableAlignment | null;
+export declare function normalizeDocumentTableProperties(value: unknown): DocumentTableProperties | null;
+export declare function normalizeDocumentTableCellMargins(value: unknown): DocumentTableCellMargins | null;
+export declare function normalizeDocumentTableCellMarginOverrides(value: unknown): DocumentTableCellMarginOverrides | null;
+export declare function documentTableLayoutMode(geometry: DocumentTableGeometry): DocumentTableLayoutMode;
+export declare function documentTableGeometryForLayoutMode(mode: DocumentTableLayoutMode, current: DocumentTableGeometry, renderedTableWidth?: number): DocumentTableGeometry;
+export declare function documentTableGeometryFromElement(table: HTMLElement): DocumentTableGeometry;
+export declare function renderDocumentTableGeometry(value: unknown, legacyLayoutMode?: unknown): Record<string, string>;
+export declare function applyDocumentTableGeometryToElement(table: HTMLElement, value: unknown, legacyLayoutMode?: unknown): void;
+export declare function documentTableCellMarginOverridesFromElement(cell: HTMLElement): DocumentTableCellMarginOverrides | null;
+export declare function renderDocumentTableCellMarginOverrides(value: unknown): Record<string, string>;
+export declare function normalizeDocumentTablePreferredWidth(value: unknown): DocumentTablePreferredWidth | null;

package/dist/internal/features/work/work-document-table-property-changes.d.ts

@@ -0,0 +1,25 @@
+import { type DocumentTableVerticalAlign } from './work-document-table-cell-formatting';
+import { type DocumentTableCellMarginOverrides, type DocumentTableProperties } from './work-document-table-geometry';
+import type { DocumentTableRowHeightRule } from './work-document-table-row';
+export declare const MIN_DOCUMENT_TABLE_COLUMN_WIDTH = 25;
+export declare const MIN_DOCUMENT_TABLE_ROW_HEIGHT = 12;
+export declare const MAX_DOCUMENT_TABLE_DIMENSION = 4000;
+export interface DocumentTablePropertyChanges {
+    table?: DocumentTableProperties;
+    row?: {
+        height: number | null;
+        heightRule: DocumentTableRowHeightRule;
+        cantSplit: boolean;
+        repeatHeader?: boolean;
+    };
+    column?: {
+        width: number;
+        renderedColumnWidths?: readonly number[];
+    };
+    cell?: {
+        verticalAlign: DocumentTableVerticalAlign;
+        margins: DocumentTableCellMarginOverrides | null;
+    };
+}
+export declare function normalizeDocumentTablePropertyChanges(value: unknown): DocumentTablePropertyChanges | null;
+export declare function normalizeDocumentTableDimension(value: number, minimum: number): number | null;

package/dist/internal/features/work/work-document-table-sizing.d.ts

@@ -1,12 +1,22 @@
 import { Extension } from '@tiptap/core';
 import { type EditorState } from '@tiptap/pm/state';
 import { type DocumentTableRowHeightRule } from './work-document-table-row';
-export type DocumentTableLayoutMode = 'window' | 'contents' | 'fixed';
+import { type DocumentTableAlignment, type DocumentTableCellMargins, type DocumentTableLayoutAlgorithm, type DocumentTableLayoutMode, type DocumentTablePreferredWidthType, type DocumentTableProperties } from './work-document-table-geometry';
+import { type DocumentTablePropertyChanges } from './work-document-table-property-changes';
+export { normalizeDocumentTableGeometry, normalizeDocumentTableLayoutMode, } from './work-document-table-geometry';
+export type { DocumentTableAlignment, DocumentTableCellMargins, DocumentTableGeometry, DocumentTableLayoutAlgorithm, DocumentTableLayoutMode, DocumentTablePreferredWidth, DocumentTablePreferredWidthType, DocumentTableProperties, } from './work-document-table-geometry';
+export type { DocumentTablePropertyChanges } from './work-document-table-property-changes';
 export interface DocumentTableSizingState {
     columnWidth: number | null;
     rowHeight: number | null;
     rowHeightRule: DocumentTableRowHeightRule | null;
     layoutMode: DocumentTableLayoutMode;
+    layoutAlgorithm: DocumentTableLayoutAlgorithm;
+    preferredWidthType: DocumentTablePreferredWidthType;
+    preferredWidth: number | null;
+    alignment: DocumentTableAlignment;
+    indent: number;
+    cellMargins: DocumentTableCellMargins;
     selectedColumnCount: number;
     selectedRowCount: number;
 }
@@ -16,6 +26,10 @@ declare module '@tiptap/core' {
             setDocumentTableColumnWidth: (width: number, renderedColumnWidths?: readonly number[]) => ReturnType;
             setDocumentTableRowHeight: (height: number | null, rule?: DocumentTableRowHeightRule) => ReturnType;
             setDocumentTableLayoutMode: (mode: DocumentTableLayoutMode, renderedTableWidth?: number) => ReturnType;
+            setDocumentTableAlignment: (alignment: DocumentTableAlignment) => ReturnType;
+            setDocumentTableProperties: (properties: DocumentTableProperties) => ReturnType;
+            setDocumentTablePropertyChanges: (changes: DocumentTablePropertyChanges) => ReturnType;
+            setDocumentTableCellMargins: (margins: DocumentTableCellMargins) => ReturnType;
             distributeDocumentTableColumns: (renderedSelectionWidth?: number) => ReturnType;
             distributeDocumentTableRows: (renderedSelectionHeight?: number) => ReturnType;
         };
@@ -24,4 +38,3 @@ declare module '@tiptap/core' {
 export declare const DocumentTable: import("@tiptap/core").Node<import("@tiptap/extension-table").TableOptions, any>;
 export declare const DocumentTableSizing: Extension<any, any>;
 export declare function documentTableSizing(state: EditorState): DocumentTableSizingState | null;
-export declare function normalizeDocumentTableLayoutMode(value: unknown): DocumentTableLayoutMode;

package/dist/internal/features/work/work-document-word-line-metrics.d.ts

@@ -0,0 +1,11 @@
+export declare const DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT = 1.15;
+declare module '@tiptap/extension-text-style' {
+    interface TextStyleAttributes {
+        wordLineHeightFactor?: number | null;
+        wordSnapToGrid?: boolean | null;
+    }
+}
+export declare function documentWordLineHeightFactor(fontFamily: unknown): number;
+export declare function normalizedDocumentWordLineHeightFactor(value: unknown): number | null;
+export declare const DocumentTextStyle: import("@tiptap/core").Mark<import("@tiptap/extension-text-style").TextStyleOptions, any>;
+export declare const DocumentFontFamily: import("@tiptap/core").Extension<import("@tiptap/extension-text-style/font-family").FontFamilyOptions, any>;

package/dist/internal/features/work/work-docx-document-layout.d.ts

@@ -0,0 +1,2 @@
+import type { WorkDocumentSection } from './work-document-section';
+export declare function patchDocxDocumentLayout(buffer: ArrayBuffer, sections: readonly WorkDocumentSection[]): Promise<ArrayBuffer>;