@univerjs/engine-render 1.0.0-insiders.20260809-70eefdd → 1.0.0-rc.0

package/lib/types/components/docs/layout/doc-skeleton.d.ts

@@ -18,6 +18,8 @@ import type { IDocumentSkeletonCached, IDocumentSkeletonGlyph, IDocumentSkeleton
 import type { INodeInfo, INodePosition, INodeSearch } from '../../../basics/interfaces';
 import type { IViewportInfo, Vector2 } from '../../../basics/vector2';
 import type { DocumentViewModel } from '../view-model/document-view-model';
+import type { IDocumentLayoutGeometryPublication, IDocumentLayoutPagePublication } from './document-layout-publication';
+import type { DocumentLayoutReason, IDocumentLayoutApplyResult, IDocumentLayoutInvalidation, IDocumentLayoutPageRange, IDocumentLayoutProgress, IDocumentLayoutProtectedRange } from './document-layout-types';
 import type { IDocumentPaginationMetrics } from './tools';
 import { Skeleton } from '@univerjs/core';
 import { PageLayoutType } from '../../../basics/i-document-skeleton-cached';
@@ -28,6 +30,10 @@ export declare enum DocumentSkeletonState {
     READY = "ready",
     INVALID = "invalid"
 }
+export interface IDocumentCustomBlockPresentationRefreshResult {
+    didRefresh: boolean;
+    requiresLayout: boolean;
+}
 export interface IFindNodeRestrictions {
     strict: boolean;
     segmentId: string;
@@ -37,15 +43,30 @@ export declare class DocumentSkeleton extends Skeleton {
     private _docViewModel;
     private _dirty$;
     readonly dirty$: import("rxjs").Observable<boolean>;
+    private _layoutProgress$;
+    readonly layoutProgress$: import("rxjs").Observable<IDocumentLayoutProgress>;
     private _skeletonData;
     private _findLiquid;
     private _hyphen;
     private _languageDetector;
-    private _iteratorCount;
     private _initialWidth;
     private _paginationMetrics;
-    constructor(_docViewModel: DocumentViewModel, localeService: LocaleService);
-    static create(docViewModel: DocumentViewModel, localeService: LocaleService): DocumentSkeleton;
+    private _lastCompleteSkeletonData;
+    private _pendingInvalidationAnchor;
+    private _layoutGeneration;
+    private _activeLayout;
+    private _externalLayoutProgress;
+    private _externalProtectedPages;
+    private _externalProtectedContinuousLayout;
+    private _topLevelBlockSections;
+    private _topLevelBlocks;
+    private readonly _isolateIncrementalPublications;
+    constructor(_docViewModel: DocumentViewModel, localeService: LocaleService, options?: {
+        isolateIncrementalPublications?: boolean;
+    });
+    static create(docViewModel: DocumentViewModel, localeService: LocaleService, options?: {
+        isolateIncrementalPublications?: boolean;
+    }): DocumentSkeleton;
     dispose(): void;
     getViewModel(): DocumentViewModel;
     /**
@@ -53,7 +74,66 @@ export declare class DocumentSkeleton extends Skeleton {
      * PS: This method has significant impact on performance.
      */
     calculate(bounds?: IViewportInfo): void;
+    startIncrementalLayout(options?: {
+        reason?: DocumentLayoutReason;
+        anchor?: number;
+        priorityAnchor?: number;
+        invalidation?: IDocumentLayoutInvalidation;
+        bounds?: IViewportInfo;
+        reuseUnaffectedTail?: boolean;
+        /** The caller proved this edit only changes offset-preserving render metadata. */
+        allowMetadataOnlyStructuralTailReuse?: boolean;
+        preserveInteractionWindow?: boolean;
+        /** Cooperative schedulers wait for code-split dictionaries before publishing. */
+        waitForHyphenationPatterns?: boolean;
+    }): number;
+    private _prepareIncrementalLayoutStart;
+    private _preparePaginatedParagraphPrefix;
+    private _prepareContinuousPrefix;
+    private _findBodyPageIndex;
+    private _getTopLevelBlocks;
+    private _copySkeletonResources;
+    cancelIncrementalLayout(generation?: number): void;
+    stepIncrementalLayout(generation: number, budgetMs?: number, maxWorkUnits?: number): IDocumentLayoutProgress;
+    /**
+     * Publishes at most one page that a previous layout slice has already
+     * completed. It never advances shaping or pagination work.
+     */
+    publishIncrementalLayoutBacklog(generation: number): IDocumentLayoutProgress;
+    private _stepIncrementalLayout;
+    private _createPublishablePartialSkeleton;
+    private _createSharedPublishablePartialSkeleton;
+    private _findPublishablePriorityPageIndex;
+    private _finalizePaginatedPagesForPublication;
+    getLayoutProgress(): Nullable<IDocumentLayoutProgress>;
+    /**
+     * Opens a presentation barrier before an external executor starts layout.
+     * The Main interaction snapshot remains authoritative inside its protected
+     * page or block range while the external executor publishes a newer tail.
+     */
+    beginExternalLayout(options: {
+        reason: DocumentLayoutReason;
+        protectedRange?: IDocumentLayoutProtectedRange;
+    }): void;
+    cancelExternalLayout(): void;
+    /**
+     * Whether this skeleton owns a fully finalized layout that can be used as
+     * stable geometry while a later incremental generation is still running.
+     */
+    hasCompleteLayout(): boolean;
     getSkeletonData(): Nullable<IDocumentSkeletonCached>;
+    /**
+     * Refreshes Custom Block viewport-only metrics without rebuilding document flow.
+     * Pure presentation metrics are published as one batch. Flow metrics are only
+     * replaced for compatible drawings; incompatible drawings retain their stable
+     * flow geometry while callers schedule a normal layout generation.
+     */
+    refreshCustomBlockPresentationViewports(): IDocumentCustomBlockPresentationRefreshResult;
+    applyLayoutPublication(publication: IDocumentLayoutGeometryPublication, progress: IDocumentLayoutProgress, materializedPageRange?: IDocumentLayoutPageRange): IDocumentLayoutApplyResult;
+    applyLayoutPagePublication(publication: IDocumentLayoutPagePublication, materializedPageRange: IDocumentLayoutPageRange): boolean;
+    private _compactMaterializedPages;
+    private _applyExternalLayoutResources;
+    private _resolveProtectedContinuousPublication;
     /**
      * Returns a cloned snapshot of the most recent layout's bounded pagination counters.
      * These diagnostics describe renderer work and are not part of the document model.
@@ -69,6 +149,7 @@ export declare class DocumentSkeleton extends Skeleton {
     findPositionByGlyph(glyph: IDocumentSkeletonGlyph, segmentPage: number): Nullable<INodeSearch>;
     findCharIndexByPosition(position: INodePosition): Nullable<number>;
     findNodePositionByCharIndex(charIndex: number, isBack?: boolean, segmentId?: string, segmentPIndex?: number): Nullable<INodePosition>;
+    findBodyPageIndexByCharIndex(charIndex: number): number;
     findNodeByCharIndex(charIndex: number, segmentId?: string, segmentPageIndex?: number): Nullable<IDocumentSkeletonGlyph>;
     findGlyphByPosition(position: Nullable<INodePosition>): IDocumentSkeletonGlyph | undefined;
     findEditAreaByCoord(coord: Vector2, pageLayoutType: PageLayoutType, pageMarginLeft: number, pageMarginTop: number): {
@@ -77,10 +158,23 @@ export declare class DocumentSkeleton extends Skeleton {
         page: Nullable<IDocumentSkeletonPage>;
     };
     findNodeByCoord(coord: Vector2, pageLayoutType: PageLayoutType, pageMarginLeft: number, pageMarginTop: number, restrictions?: IFindNodeRestrictions): Nullable<INodeInfo>;
+    private _findNodeByCoord;
     private _collectNearestNode;
     private _getNearestNode;
     private _getPageBoundingBox;
     private _translatePage;
+    private _getLayoutProgress;
+    private _tryConvergeUnaffectedTail;
+    private _isPriorityAnchorReady;
+    private _tryReuseInteractionPageTail;
+    private _prepareIncrementalHyphenation;
+    private _advanceIncrementalLayout;
+    private _resumeAfterSealedInteractionPage;
+    private _captureIncrementalParagraphCheckpoint;
+    private _restoreIncrementalParagraphCheckpoint;
+    private _initializeIncrementalSection;
+    private _restartDirtyIncrementalLayout;
+    private _finishIncrementalLayout;
     private _prepareLayoutContext;
     /**
      * \v COLUMN_BREAK
@@ -110,6 +204,7 @@ export declare class DocumentSkeleton extends Skeleton {
      * @returns view model: skeleton
      */
     private _createSkeleton;
+    private _createSkeletonPass;
     private _addNewSectionByContinuous;
     private _addNewSectionByNextColumn;
     private _restoreContinuousSection;

package/lib/types/components/docs/layout/document-layout-page-patch.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDocDrawingBase, IDocumentData, ITable, ITableRow } from '@univerjs/core';
+import type { IDocumentSkeletonCached, IDocumentSkeletonColumn, IDocumentSkeletonColumnGroup, IDocumentSkeletonColumnGroupColumn, IDocumentSkeletonDivide, IDocumentSkeletonDrawing, IDocumentSkeletonGlyph, IDocumentSkeletonLine, IDocumentSkeletonNote, IDocumentSkeletonNoteDecoration, IDocumentSkeletonPage, IDocumentSkeletonRow, IDocumentSkeletonSection, IDocumentSkeletonTable } from '../../../basics/i-document-skeleton-cached';
+export type IDocumentSkeletonGlyphPatch = Omit<IDocumentSkeletonGlyph, 'parent'>;
+export interface IDocumentSkeletonDividePatch extends Omit<IDocumentSkeletonDivide, 'glyphGroup' | 'parent'> {
+    glyphGroup: IDocumentSkeletonGlyphPatch[];
+}
+export interface IDocumentSkeletonLinePatch extends Omit<IDocumentSkeletonLine, 'divides' | 'parent'> {
+    divides: IDocumentSkeletonDividePatch[];
+}
+export interface IDocumentSkeletonColumnPatch extends Omit<IDocumentSkeletonColumn, 'lines' | 'parent'> {
+    lines: IDocumentSkeletonLinePatch[];
+}
+export interface IDocumentSkeletonSectionPatch extends Omit<IDocumentSkeletonSection, 'columns' | 'parent'> {
+    columns: IDocumentSkeletonColumnPatch[];
+}
+export interface IDocumentSkeletonDrawingPatch extends Omit<IDocumentSkeletonDrawing, 'drawingOrigin'> {
+    drawingOrigin?: IDocDrawingBase;
+}
+export interface IDocumentSkeletonRowPatch extends Omit<IDocumentSkeletonRow, 'cells' | 'parent' | 'rowSource'> {
+    cells: IDocumentSkeletonPagePatch[];
+    rowSource?: ITableRow;
+    rowSourceIndex?: number;
+}
+export interface IDocumentSkeletonTablePatch extends Omit<IDocumentSkeletonTable, 'rows' | 'parent' | 'tableSource'> {
+    rows: IDocumentSkeletonRowPatch[];
+    tableSource?: ITable;
+    tableSourceId?: string;
+}
+export interface IDocumentSkeletonColumnGroupColumnPatch extends Omit<IDocumentSkeletonColumnGroupColumn, 'page' | 'parent'> {
+    page: IDocumentSkeletonPagePatch;
+}
+export interface IDocumentSkeletonColumnGroupPatch extends Omit<IDocumentSkeletonColumnGroup, 'columns' | 'parent'> {
+    columns: IDocumentSkeletonColumnGroupColumnPatch[];
+}
+export interface IDocumentSkeletonPagePatch extends Omit<IDocumentSkeletonPage, 'sections' | 'skeDrawings' | 'skeTables' | 'skeColumnGroups' | 'notes' | 'noteDecorations' | 'parent'> {
+    sections: IDocumentSkeletonSectionPatch[];
+    skeDrawings: Array<[string, IDocumentSkeletonDrawingPatch]>;
+    skeTables: Array<[string, IDocumentSkeletonTablePatch]>;
+    skeColumnGroups: Array<[string, IDocumentSkeletonColumnGroupPatch]>;
+    noteDecorations?: Array<Omit<IDocumentSkeletonNoteDecoration, 'page'> & {
+        page: IDocumentSkeletonPagePatch;
+    }>;
+    notes?: Array<Omit<IDocumentSkeletonNote, 'page' | 'parent'> & {
+        page: IDocumentSkeletonPagePatch;
+    }>;
+}
+export type IDocumentSkeletonPageGeometryPatch = Omit<IDocumentSkeletonPagePatch, 'sections' | 'skeDrawings' | 'skeTables' | 'skeColumnGroups' | 'notes' | 'noteDecorations'>;
+export type IDocumentSkeletonSectionGeometryPatch = Omit<IDocumentSkeletonSectionPatch, 'columns'>;
+export type IDocumentSkeletonColumnGeometryPatch = Omit<IDocumentSkeletonColumnPatch, 'lines'>;
+export interface IDocumentSkeletonContinuousFlowPatch {
+    sectionIndex: number;
+    section: IDocumentSkeletonSectionGeometryPatch;
+    columnIndex: number;
+    column: IDocumentSkeletonColumnGeometryPatch;
+    lineIndex: number;
+    lines: IDocumentSkeletonLinePatch[];
+    trailingColumns: IDocumentSkeletonColumnPatch[];
+    trailingSections: IDocumentSkeletonSectionPatch[];
+}
+export interface IDocumentSkeletonContinuousBlockPatch {
+    pageIndex: number;
+    page: IDocumentSkeletonPageGeometryPatch;
+    flow: IDocumentSkeletonContinuousFlowPatch;
+    skeDrawings: Array<[string, IDocumentSkeletonDrawingPatch]>;
+    skeTables: Array<[string, IDocumentSkeletonTablePatch]>;
+    skeColumnGroups: Array<[string, IDocumentSkeletonColumnGroupPatch]>;
+    previousHeight: number;
+    heightDelta: number;
+}
+export interface IDocumentSkeletonContinuousSnapshot {
+    height: number;
+    lineEnds: number[];
+}
+export declare function serializeDocumentSkeletonLine(source: IDocumentSkeletonLine): IDocumentSkeletonLinePatch;
+export declare function serializeDocumentSkeletonPage(source: IDocumentSkeletonPage, omitResourceSources?: boolean): IDocumentSkeletonPagePatch;
+export declare function hydrateDocumentSkeletonLine(source: IDocumentSkeletonLinePatch, parent: IDocumentSkeletonColumn): IDocumentSkeletonLine;
+export declare function hydrateDocumentSkeletonPage(source: IDocumentSkeletonPagePatch, parent?: IDocumentSkeletonCached | IDocumentSkeletonRow | IDocumentSkeletonColumnGroupColumn, snapshot?: IDocumentData): IDocumentSkeletonPage;
+export declare function hydrateDocumentSkeletonPagePlaceholder(source: IDocumentSkeletonPagePatch, parent?: IDocumentSkeletonCached): IDocumentSkeletonPage;
+export declare function hydrateDocumentSkeletonPageMaterializationPlaceholder(source: IDocumentSkeletonPagePatch, parent?: IDocumentSkeletonCached): IDocumentSkeletonPage;
+/**
+ * Serializes only the changed suffix of a continuous document's logical page.
+ * The boundary line is deliberately republished because paragraph spacing can
+ * alter it when the next block is appended.
+ */
+export declare function serializeDocumentSkeletonContinuousBlock(currentPage: IDocumentSkeletonPage, previousSnapshot: IDocumentSkeletonContinuousSnapshot | null, replacementOffset?: number, omitResourceSources?: boolean): {
+    block: IDocumentSkeletonContinuousBlockPatch;
+    snapshot: IDocumentSkeletonContinuousSnapshot;
+};
+export declare function applyDocumentSkeletonContinuousBlock(target: IDocumentSkeletonCached, patch: IDocumentSkeletonContinuousBlockPatch, snapshot?: IDocumentData): IDocumentSkeletonPage;

package/lib/types/components/docs/layout/document-layout-publication.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDocumentSkeletonDrawingAnchor, IParagraphList } from '../../../basics/i-document-skeleton-cached';
+import type { IDocumentSkeletonContinuousBlockPatch, IDocumentSkeletonPagePatch } from './document-layout-page-patch';
+export type IDocumentLayoutListLevelPublication = Array<[string, IParagraphList[][]]>;
+export type IDocumentLayoutDrawingAnchorPublication = Array<[
+    string,
+    Array<[number, Omit<IDocumentSkeletonDrawingAnchor, 'elements'>]>
+]>;
+export interface IDocumentLayoutPagePublication {
+    pageIndex: number;
+    page: IDocumentSkeletonPagePatch;
+}
+export interface IDocumentLayoutResourcePublication {
+    reset: boolean;
+    skeHeaders: Array<[string, Array<[number, IDocumentSkeletonPagePatch]>]>;
+    skeFooters: Array<[string, Array<[number, IDocumentSkeletonPagePatch]>]>;
+    skeListLevel: IDocumentLayoutListLevelPublication | null;
+    drawingAnchor: IDocumentLayoutDrawingAnchorPublication | null;
+}
+interface IDocumentLayoutGeometryPublicationBase {
+    left: number;
+    top: number;
+    st: number;
+    ed?: number;
+    resources: IDocumentLayoutResourcePublication;
+}
+export interface IDocumentLayoutPageGeometryPublication extends IDocumentLayoutGeometryPublicationBase {
+    kind: 'page';
+    pages: IDocumentLayoutPagePublication[];
+}
+export interface IDocumentLayoutBlockGeometryPublication extends IDocumentLayoutGeometryPublicationBase {
+    kind: 'block';
+    block: IDocumentSkeletonContinuousBlockPatch;
+}
+export type IDocumentLayoutGeometryPublication = IDocumentLayoutPageGeometryPublication | IDocumentLayoutBlockGeometryPublication;
+export {};

package/lib/types/components/docs/layout/document-layout-types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export type DocumentLayoutMode = 'paginated' | 'continuous';
+export type DocumentLayoutReason = 'initial' | 'edit';
+export interface IDocumentLayoutInvalidation {
+    /** First offset changed in the pre-mutation document. */
+    oldStart: number;
+    /** Exclusive end of the changed range in the pre-mutation document. */
+    oldEnd: number;
+    /** Exclusive end of the changed range in the post-mutation document. */
+    newEnd: number;
+}
+export interface IDocumentLayoutProtectedPageRange {
+    mode: 'paginated';
+    startPageIndex: number;
+    endPageIndex: number;
+}
+export type IDocumentLayoutPageRange = Pick<IDocumentLayoutProtectedPageRange, 'startPageIndex' | 'endPageIndex'>;
+export interface IDocumentLayoutProtectedContinuousRange {
+    mode: 'continuous';
+    startOffset: number;
+    endOffset: number;
+}
+export type IDocumentLayoutProtectedRange = IDocumentLayoutProtectedPageRange | IDocumentLayoutProtectedContinuousRange;
+export interface IDocumentLayoutApplyResult {
+    didReplaceProtectedPages: boolean;
+}
+export interface IDocumentLayoutProgress {
+    generation: number;
+    publicationRevision: number;
+    didPublish: boolean;
+    /** The publication atomically replaced the page containing the edit anchor. */
+    didPublishAnchor: boolean;
+    publishedPageCount: number;
+    reason: DocumentLayoutReason;
+    mode: DocumentLayoutMode;
+    complete: boolean;
+    cancelled: boolean;
+    anchorReady: boolean;
+    laidOutThrough: number;
+    /** Last logical offset whose exit geometry cannot be changed by the next block. */
+    stableLaidOutThrough: number;
+    pageCount: number;
+    processedBlockCount: number;
+    totalBlockCount: number;
+    estimatedPageCount: number;
+    estimatedHeight: number;
+    elapsedTime: number;
+    maxBlockDuration: number;
+    /** Main has sealed the protected interaction page and should hand the remaining suffix to Worker. */
+    interactionWindowComplete?: boolean;
+}

package/lib/types/components/docs/layout/endnote-layout.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDocumentSkeletonPage } from '../../../basics/i-document-skeleton-cached';
+import type { ISectionBreakConfig } from '../../../basics/interfaces';
+import type { ILayoutContext } from './tools';
+/** Endnotes occupy document flow after a section or the final body section. */
+export declare class DocumentEndnoteLayout {
+    private readonly _ctx;
+    constructor(_ctx: ILayoutContext);
+    finishSection(pages: IDocumentSkeletonPage[], sectionIndex: number, config: ISectionBreakConfig): void;
+    private _layoutDecoration;
+}
+export declare function getEndnoteFlowBottom(page: IDocumentSkeletonPage): number;

package/lib/types/components/docs/layout/footnote-layout.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IDocumentBody } from '@univerjs/core';
+import type { IDocumentSkeletonGlyph, IDocumentSkeletonPage, IDocumentSkeletonTable } from '../../../basics/i-document-skeleton-cached';
+import type { IParagraphConfig, ISectionBreakConfig } from '../../../basics/interfaces';
+import type { INoteReferenceLayout } from './note-numbering';
+import type { ILayoutContext } from './tools';
+import { DocumentViewModel } from '../view-model/document-view-model';
+export interface INoteLayoutConstraints {
+    width: number;
+    firstPageHeight: number;
+    continuationPageHeight: number;
+    columnCount?: number;
+    firstColumn?: {
+        index: number;
+        top: number;
+    };
+}
+/** Uses the body layout pipeline, including table row splitting and inline drawing metrics. */
+export declare function layoutNoteBody(parentContext: ILayoutContext, reference: INoteReferenceLayout, sectionConfig: ISectionBreakConfig, constraints: INoteLayoutConstraints): IDocumentSkeletonPage[];
+export declare function layoutNoteSegment(parentContext: ILayoutContext, viewModel: DocumentViewModel, reference: Pick<INoteReferenceLayout, 'noteId' | 'sectionId'> & {
+    label?: string;
+}, sectionConfig: ISectionBreakConfig, constraints: INoteLayoutConstraints): IDocumentSkeletonPage[];
+export declare function defaultSeparatorBody(continued: boolean): IDocumentBody;
+/** Per-layout state, shared by synchronous and sliced body pagination. */
+export declare class DocumentFootnoteLayout {
+    private readonly _ctx;
+    private readonly _pages;
+    private readonly _inherited;
+    private readonly _references;
+    private readonly _referencePageBreaks;
+    private readonly _decorations;
+    constructor(_ctx: ILayoutContext);
+    updateReferenceGlyphs(page: IDocumentSkeletonPage, glyphs: IDocumentSkeletonGlyph[], config: ISectionBreakConfig, paragraph: IParagraphConfig): void;
+    private _updateReferenceLabels;
+    getTableBodyLimit(page: IDocumentSkeletonPage, currentPages: IDocumentSkeletonPage[], config: ISectionBreakConfig, table: IDocumentSkeletonTable): number;
+    /** Measure table slices without publishing speculative notes on body pages. */
+    createTablePagination(page: IDocumentSkeletonPage, config: ISectionBreakConfig, availableHeight: number): {
+        renumberWholeRow: (table: IDocumentSkeletonTable, rows: IDocumentSkeletonTable["rows"], remainingHeight: number) => boolean;
+        measureRow: (table: IDocumentSkeletonTable, rows: IDocumentSkeletonTable["rows"], previousHeights?: readonly number[]) => number[] | undefined;
+        append: (table: IDocumentSkeletonTable, row: IDocumentSkeletonTable["rows"][number]) => number | undefined;
+        hasContinuation: () => boolean;
+        nextPage: () => void;
+    } | undefined;
+    getBodyLimit(page: IDocumentSkeletonPage, currentPages: IDocumentSkeletonPage[], config: ISectionBreakConfig, bodyBottom: number, incoming?: IDocumentSkeletonGlyph[]): number;
+    finish(pages: IDocumentSkeletonPage[], config: ISectionBreakConfig): void;
+    getReferencePageBreaks(paragraphIndex: number): readonly number[] | undefined;
+    /** Re-shape moved text while retaining the page boundary chosen by keep/widow control. */
+    queueReferenceRelayout(pages: IDocumentSkeletonPage[]): void;
+    /** Rebuild reservations after keep-lines or widow control relocates shaped lines. */
+    reconcilePages(pages: IDocumentSkeletonPage[], config: ISectionBreakConfig): boolean;
+    private _layoutPageNotes;
+    private _layoutDecoration;
+    private _appendFollowing;
+    private _getInherited;
+    private _position;
+}

package/lib/types/components/docs/layout/hyphenation/hyphen.d.ts

@@ -18,12 +18,14 @@ import { Lang } from './lang';
 export declare class Hyphen implements IDisposable {
     private _patterns;
     private _hyphenCache;
+    private _patternLoads;
     private static _instance;
     static getInstance(): Hyphen;
     constructor();
     private _preloadPatterns;
     private _loadExceptionsToCache;
     loadPattern(lang: Lang): Promise<void>;
+    private _loadPattern;
     fetchHyphenCache(lang: Lang): Map<string, string[]> | undefined;
     hasPattern(lang: Lang): boolean;
     hyphenate(word: string, lang: Lang): string[] | undefined;

package/lib/types/components/docs/layout/model/line.d.ts

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 import type { Nullable } from '@univerjs/core';
-import type { IParagraphConfig } from '../../../../basics';
 import type { IDocumentSkeletonDivide, IDocumentSkeletonDrawingAnchor, IDocumentSkeletonLine, IDocumentSkeletonPage, LineType } from '../../../../basics/i-document-skeleton-cached';
+import type { IParagraphConfig } from '../../../../basics/interfaces';
 import type { IFloatObject } from '../tools';
+export declare const TRADITIONAL_TABLE_WRAP_MIN_WIDTH = 24;
 interface ILineBoundingBox {
     lineHeight: number;
     lineTop: number;
@@ -29,7 +30,7 @@ interface ILineBoundingBox {
     spaceBelowApply?: number;
 }
 export declare function createSkeletonLine(paragraphIndex: number, lineType: LineType, lineBoundingBox: ILineBoundingBox, columnWidth: number, lineIndex: number | undefined, isParagraphStart: boolean | undefined, paragraphConfig: IParagraphConfig, page: IDocumentSkeletonPage, headerPage: Nullable<IDocumentSkeletonPage>, footerPage: Nullable<IDocumentSkeletonPage>, columnLeft?: number, sectionTop?: number): IDocumentSkeletonLine;
-export declare function calculateLineTopByDrawings(lineHeight: number | undefined, lineTop: number | undefined, page: IDocumentSkeletonPage, headerPage: Nullable<IDocumentSkeletonPage>, footerPage: Nullable<IDocumentSkeletonPage>, columnLeft?: number, columnWidth?: number, sectionTop?: number): number;
+export declare function calculateLineTopByDrawings(lineHeight: number | undefined, lineTop: number | undefined, page: IDocumentSkeletonPage, headerPage: Nullable<IDocumentSkeletonPage>, footerPage: Nullable<IDocumentSkeletonPage>, columnLeft?: number, columnWidth?: number, sectionTop?: number, minimumTableWrapWidth?: number): number;
 export declare function updateDivideInfo(divide: IDocumentSkeletonDivide, states: Partial<IDocumentSkeletonDivide>): void;
 export declare function setLineMarginBottom(line: IDocumentSkeletonLine, marginBottom: number): void;
 export declare function collisionDetection(floatObject: IFloatObject, lineHeight: number, lineTop: number, columnLeft: number, columnWidth: number): boolean;

package/lib/types/components/docs/layout/model/page.d.ts

@@ -21,10 +21,27 @@ import type { DocumentViewModel } from '../../view-model/document-view-model';
 import type { ILayoutContext } from '../tools';
 import { BreakType } from '../../../../basics/i-document-skeleton-cached';
 export declare function createSkeletonPage(ctx: ILayoutContext, sectionBreakConfig: ISectionBreakConfig, skeletonResourceReference: ISkeletonResourceReference, pageNumber?: number, breakType?: BreakType): IDocumentSkeletonPage;
-export declare function createNullCellPage(ctx: ILayoutContext, sectionBreakConfig: ISectionBreakConfig, tableConfig: ITable, row: number, col: number, availableHeight?: number, maxCellPageHeight?: number): {
+export declare function createNullCellPage(ctx: ILayoutContext, sectionBreakConfig: ISectionBreakConfig, tableConfig: ITable, row: number, col: number, availableHeight?: number, maxCellPageHeight?: number, inheritDocumentLinePitch?: boolean, enableDocumentTableLineGrid?: boolean, cellPageHeights?: readonly number[]): {
     page: IDocumentSkeletonPage;
     sectionBreakConfig: ISectionBreakConfig;
 };
-export declare function createSkeletonCellPages(ctx: ILayoutContext, viewModel: DocumentViewModel, cellNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, tableConfig: ITable, row: number, col: number, availableHeight?: number, maxCellPageHeight?: number): IDocumentSkeletonPage[];
+export declare function createSkeletonCellPages(ctx: ILayoutContext, viewModel: DocumentViewModel, cellNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, tableConfig: ITable, row: number, col: number, availableHeight?: number, maxCellPageHeight?: number, cellPageHeights?: readonly number[]): IDocumentSkeletonPage[];
+export interface ICellSkeletonBuildState {
+    ctx: ILayoutContext;
+    viewModel: DocumentViewModel;
+    cellNode: DataStreamTreeNode;
+    sectionNode: DataStreamTreeNode;
+    sectionBreakConfig: ISectionBreakConfig;
+    cellSectionBreakConfig: ISectionBreakConfig;
+    tableConfig: ITable;
+    paragraphIndex: number;
+    layoutAnchor: Nullable<number>;
+    pages: IDocumentSkeletonPage[];
+    complete: boolean;
+    requiresSyncFallback: boolean;
+}
+export declare function startSkeletonCellPagesBuild(ctx: ILayoutContext, viewModel: DocumentViewModel, cellNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, tableConfig: ITable, row: number, col: number, availableHeight?: number, maxCellPageHeight?: number, cellPageHeights?: readonly number[]): ICellSkeletonBuildState;
+export declare function stepSkeletonCellPagesBuild(state: ICellSkeletonBuildState): boolean;
 export declare function expandCellPageHeightForInlineDrawings(pages: IDocumentSkeletonPage[]): void;
+export declare function expandCellPageHeightForFlowTables(pages: IDocumentSkeletonPage[]): void;
 export declare function applyTrailingBlockRangeSpaceBelow(pages: IDocumentSkeletonPage[], body: Nullable<IDocumentBody>, containerEndIndex: number): void;

package/lib/types/components/docs/layout/note-numbering.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { DocumentNoteType, IDocumentData, IFootnoteProperties, ISectionBreak } from '@univerjs/core';
+export interface INoteLayoutProperties extends Omit<IFootnoteProperties, 'position'> {
+    position?: 'pageBottom' | 'beneathText' | 'docEnd' | 'sectEnd';
+}
+export interface INoteReferenceLayout {
+    noteId: string;
+    type: DocumentNoteType;
+    referenceIndex: number;
+    sectionId: string;
+    label: string;
+    number?: number;
+    properties: INoteLayoutProperties;
+}
+export declare function formatNoteNumber(number: number, format?: string): string;
+/** Page keys are physical page indices, independent of the printed page-number format. */
+/** Cell section sentinels cannot own document-level note numbering or placement. */
+export declare function getNoteSections(snapshot: Pick<IDocumentData, 'body'>): ISectionBreak[];
+export declare function resolveNoteReferences(snapshot: Pick<IDocumentData, 'body' | 'notes' | 'noteSettings'>, referencePages?: ReadonlyMap<string, number>): Map<number, INoteReferenceLayout>;

package/lib/types/components/docs/layout/shaping-engine/font-cache.d.ts

@@ -23,12 +23,16 @@ export interface IMeasureTextCache {
     actualBoundingBoxDescent: number;
     width: number;
 }
+/** Invalidates selected CSS font keys in both measurement caches; registered font data is retained. */
+export declare function invalidateDocumentFontMetrics(matches: (fontStyle: string) => boolean): boolean;
 export declare class FontCache {
+    private static _normalLineHeightCache;
     private static _getTextHeightCache;
     private static _context;
     private static _fontDataMap;
     private static _globalFontMeasureCache;
     static get globalFontMeasureCache(): Map<string, Map<string, IMeasureTextCache>>;
+    static invalidateMetrics(matches: (fontStyle: string) => boolean): boolean;
     static setFontMeasureCache(fontStyle: string, content: string, tm: IMeasureTextCache): void;
     static clearFontMeasureCache(path: string): boolean;
     static getFontMeasureCache(fontStyle: string, content: string): Nullable<IMeasureTextCache>;
@@ -43,7 +47,12 @@ export declare class FontCache {
         width: number;
         height: number;
     };
-    static getTextSize(content: string, fontStyle: IDocumentSkeletonFontStyle): IDocumentSkeletonBoundingBox;
+    /** CSS normal spacing includes font leading that Canvas bounding boxes omit. */
+    static getNormalLineHeight(fontStyle: IDocumentSkeletonFontStyle): number | undefined;
+    /** Transfers browser-only normal spacing measurements to the document layout Worker. */
+    static getNormalLineHeightCache(): Record<string, number>;
+    static setNormalLineHeightCache(metrics: Record<string, number>): void;
+    static getTextSize(content: string, fontStyle: IDocumentSkeletonFontStyle, includeNormalFontLeading?: boolean): IDocumentSkeletonBoundingBox;
     /**
      * Measure text on another canvas.
      * @param content
@@ -51,6 +60,8 @@ export declare class FontCache {
      * @returns IMeasureTextCache
      */
     static getMeasureText(content: string, fontString: string): IMeasureTextCache;
+    private static _createMeasureContext;
+    private static _getFontSizeFromStyle;
     private static _clearMeasureCache;
     /**
      * Vertical Metrics https://glyphsapp.com/learn/vertical-metrics

package/lib/types/components/docs/layout/style/color.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { IColorStyle, Nullable } from '@univerjs/core';
+export declare function getColorStyleForCanvas(color: Nullable<IColorStyle>): Nullable<string>;