@univerjs/engine-render 1.0.0-insiders.20260813-7c9aa50 → 1.0.0

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/line-breaker/enhancers/link-enhancer.d.ts

@@ -18,6 +18,7 @@ import type { IBreakPoints } from '../line-breaker';
 import { Break } from '../break';
 export declare class LineBreakerLinkEnhancer implements IBreakPoints {
     private _lineBreaker;
+    private readonly _allowLinkBreaks;
     private _curBreak;
     private _nextBreak;
     private _isInLink;
@@ -25,6 +26,6 @@ export declare class LineBreakerLinkEnhancer implements IBreakPoints {
     private _index;
     private _linkSlice;
     content: string;
-    constructor(_lineBreaker: IBreakPoints);
+    constructor(_lineBreaker: IBreakPoints, _allowLinkBreaks?: boolean);
     nextBreakPoint(): Nullable<Break>;
 }

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

@@ -13,12 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IAdjustability, IDocumentSkeletonBullet, IDocumentSkeletonDivide, IDocumentSkeletonGlyph } from '../../../../basics/i-document-skeleton-cached';
+import type { IAdjustability, IDocumentSkeletonBullet, IDocumentSkeletonDivide, IDocumentSkeletonFontStyle, IDocumentSkeletonGlyph } from '../../../../basics/i-document-skeleton-cached';
 import type { IFontCreateConfig } from '../../../../basics/interfaces';
+import type { IDocumentCompatibilityPolicy } from '../../document-compatibility';
 import { GlyphType } from '../../../../basics/i-document-skeleton-cached';
 export declare function isSpace(char: string): boolean;
+export declare function getGlyphGroupFontBoundingBox(policy: IDocumentCompatibilityPolicy | undefined, ...glyphGroups: IDocumentSkeletonGlyph[][]): {
+    boundingBoxAscent: number;
+    boundingBoxDescent: number;
+    normalLineHeight: number;
+};
+export declare function getTextHorizontalScale(percent?: number): number;
 export declare function isJustifiable(content: string): boolean;
-export declare function baseAdjustability(content: string, width: number): IAdjustability;
+export declare function baseAdjustability(content: string, width: number, emWidth?: number): IAdjustability;
+export declare function getGlyphGroupStretchability(glyphGroup: IDocumentSkeletonGlyph[]): number;
+export declare function getGlyphGroupShrinkability(glyphGroup: IDocumentSkeletonGlyph[], punctuationOnly?: boolean): number;
 export declare function createSkeletonWordGlyph(content: string, config: IFontCreateConfig, glyphWidth?: number): IDocumentSkeletonGlyph;
 export declare function createSkeletonLetterGlyph(content: string, config: IFontCreateConfig, glyphMetrics?: number | {
     ascent?: number;
@@ -41,10 +50,25 @@ export declare function createSkeletonWholeEntityGlyph(raw: string, config: IFon
 export declare function createSkeletonTabGlyph(config: IFontCreateConfig, glyphWidth?: number): IDocumentSkeletonGlyph;
 export declare function createHyphenDashGlyph(config: IFontCreateConfig): IDocumentSkeletonGlyph;
 export declare function createSkeletonCustomBlockGlyph(config: IFontCreateConfig, glyphWidth?: number, glyphHeight?: number, drawingId?: string): IDocumentSkeletonGlyph;
-export declare function _createSkeletonWordOrLetter(glyphType: GlyphType, content: string, config: IFontCreateConfig, glyphWidth?: number): IDocumentSkeletonGlyph;
-export declare function createSkeletonBulletGlyph(glyph: IDocumentSkeletonGlyph, bulletSkeleton: IDocumentSkeletonBullet, charSpaceApply: number): IDocumentSkeletonGlyph;
+export declare function getPairKerningAdjustment(left: string, right: string, font: IDocumentSkeletonFontStyle): number;
+export declare function applyGlyphKerning(glyphs: IDocumentSkeletonGlyph[]): void;
+export declare function getGlyphPairKerningAdjustment(left?: IDocumentSkeletonGlyph, right?: IDocumentSkeletonGlyph): number;
+/** Shared by skeleton layout and lightweight host measurement; offsets also drive painting. */
+export declare function measureTextWithCharacterSpacing(content: string, spacing: number | undefined, measure: (text: string) => number, pairAdjustment?: (left: string, right: string) => number): {
+    content: string;
+    width: number;
+    inkWidth: number;
+    segments: Array<{
+        content: string;
+        left: number;
+    }>;
+} | undefined;
+export declare function _createSkeletonWordOrLetter(glyphType: GlyphType, raw: string, config: IFontCreateConfig, glyphWidth?: number): IDocumentSkeletonGlyph;
+export declare function createSkeletonBulletGlyph(glyph: IDocumentSkeletonGlyph, bulletSkeleton: IDocumentSkeletonBullet, charSpaceApply: number, documentCompatibilityPolicy?: IDocumentCompatibilityPolicy): IDocumentSkeletonGlyph;
 export declare function setGlyphGroupLeft(glyphGroup: IDocumentSkeletonGlyph[], left?: number): void;
 export declare function setGlyphLeft(glyph: IDocumentSkeletonGlyph, left?: number): void;
 export declare function addGlyphToDivide(divide: IDocumentSkeletonDivide, glyphGroup: IDocumentSkeletonGlyph[], offsetLeft?: number): void;
+export declare function removeGlyphAutoSpacing(glyph: IDocumentSkeletonGlyph, side: 0 | 1): void;
 export declare function glyphShrinkRight(glyph: IDocumentSkeletonGlyph, amount: number): void;
 export declare function glyphShrinkLeft(glyph: IDocumentSkeletonGlyph, amount: number): void;
+export declare function preserveLineStartPunctuationSpace(glyph: IDocumentSkeletonGlyph): void;

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

@@ -13,19 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IDocumentBody, ITable, Nullable } from '@univerjs/core';
+import type { IDocumentBody, ITable, ITableCellBorder, ITableRow, Nullable } from '@univerjs/core';
 import type { IDocumentSkeletonPage, ISkeletonResourceReference } from '../../../../basics/i-document-skeleton-cached';
 import type { ISectionBreakConfig } from '../../../../basics/interfaces';
 import type { DataStreamTreeNode } from '../../view-model/data-stream-tree-node';
 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, inheritDocumentLinePitch?: boolean, enableDocumentTableLineGrid?: boolean): {
+export declare function createSkeletonPage(ctx: ILayoutContext, sectionBreakConfig: ISectionBreakConfig, skeletonResourceReference: ISkeletonResourceReference, pageNumber?: number, breakType?: BreakType, pageContext?: Pick<IDocumentSkeletonPage, 'type' | 'segmentId'>): IDocumentSkeletonPage;
+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;
+    verticalCellWidth: number | undefined;
 };
-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 getCellBorderWidth(border: ITableCellBorder | undefined): number;
+export declare function getRowBorderInset(row: ITableRow, edge: 'borderTop' | 'borderBottom', tableBoundary?: boolean): number;
+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;
+    verticalCellWidth?: number;
+    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,14 +47,21 @@ 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, useUnhintedMetrics?: boolean): IDocumentSkeletonBoundingBox;
     /**
      * Measure text on another canvas.
      * @param content
      * @param fontString
      * @returns IMeasureTextCache
      */
-    static getMeasureText(content: string, fontString: string): IMeasureTextCache;
+    static getMeasureText(content: string, fontString: string, kerning?: CanvasFontKerning): 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>;

package/lib/types/components/docs/layout/tools.d.ts

@@ -13,15 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { DocumentDataModel, ICustomRangeForInterceptor, INumberUnit, IObjectPositionH, IObjectPositionV, IParagraph, IParagraphStyle, ITextStyle, Nullable, PositionedObjectLayoutType } from '@univerjs/core';
-import type { IDocumentSkeletonCached, IDocumentSkeletonColumn, IDocumentSkeletonDivide, IDocumentSkeletonFontStyle, IDocumentSkeletonGlyph, IDocumentSkeletonLine, IDocumentSkeletonPage, IDocumentSkeletonRow, IDocumentSkeletonSection, IDocumentSkeletonTable, ISkeletonResourceReference } from '../../../basics/i-document-skeleton-cached';
+import type { DocumentDataModel, ICustomRangeForInterceptor, IDocDrawingBase, INumberUnit, IObjectPositionH, IObjectPositionV, Nullable, PositionedObjectLayoutType } from '@univerjs/core';
+import type { IDocumentSkeletonCached, IDocumentSkeletonColumn, IDocumentSkeletonDivide, IDocumentSkeletonFontStyle, IDocumentSkeletonGlyph, IDocumentSkeletonLine, IDocumentSkeletonPage, IDocumentSkeletonParagraphBorders, IDocumentSkeletonRow, IDocumentSkeletonSection, IDocumentSkeletonTable, ISkeletonResourceReference } from '../../../basics/i-document-skeleton-cached';
 import type { IDocsConfig, IParagraphConfig, ISectionBreakConfig } from '../../../basics/interfaces';
 import type { IBoundRectNoAngle } from '../../../basics/vector2';
 import type { IDocumentCompatibilityPolicy } from '../document-compatibility';
+import type { IDocumentLayoutParagraph, IDocumentLayoutParagraphStyle, IDocumentLayoutTextStyle } from '../document-layout-presentation';
 import type { DataStreamTreeNode } from '../view-model/data-stream-tree-node';
 import type { DocumentViewModel } from '../view-model/document-view-model';
+import type { DocumentEndnoteLayout } from './endnote-layout';
+import type { DocumentFootnoteLayout } from './footnote-layout';
 import type { Hyphen } from './hyphenation/hyphen';
 import type { LanguageDetector } from './hyphenation/language-detector';
+import type { INoteReferenceLayout } from './note-numbering';
 import { BooleanNumber, GridType, SpacingRule } from '@univerjs/core';
 export declare function getLastPage(pages: IDocumentSkeletonPage[]): IDocumentSkeletonPage;
 export declare function getLastSection(page: IDocumentSkeletonPage): IDocumentSkeletonSection;
@@ -67,8 +71,13 @@ export declare function getCharSpaceConfig(sectionBreakConfig: ISectionBreakConf
     gridType: GridType;
     snapToGrid: BooleanNumber;
 };
+export declare function getLineMetricGlyphs(glyphGroup: IDocumentSkeletonGlyph[], documentCompatibilityPolicy?: IDocumentCompatibilityPolicy, previousGlyphs?: IDocumentSkeletonGlyph[]): IDocumentSkeletonGlyph[];
+export declare function getDrawingMLLineBaseline(lineHeight: number, ascent: number, descent: number): number;
 export declare function updateBlockIndex(pages: IDocumentSkeletonPage[], start?: number, documentCompatibilityPolicy?: IDocumentCompatibilityPolicy): void;
+export declare function isParagraphEnd(line: IDocumentSkeletonLine): boolean;
+export declare function hasSameParagraphBorderSet(first: IDocumentSkeletonParagraphBorders, second: IDocumentSkeletonParagraphBorders): boolean;
 export declare function updateInlineDrawingCoordsAndBorder(ctx: ILayoutContext, pages: IDocumentSkeletonPage[]): void;
+export declare function updateParagraphBorders(ctx: ILayoutContext, pages: IDocumentSkeletonPage[], targetPages?: IDocumentSkeletonPage[]): void;
 export declare function glyphIterator(pages: IDocumentSkeletonPage[], cb: (glyph: IDocumentSkeletonGlyph, divide: IDocumentSkeletonDivide, line: IDocumentSkeletonLine, column: IDocumentSkeletonColumn, section: IDocumentSkeletonSection, page: IDocumentSkeletonPage) => void): void;
 export declare function lineIterator(pagesOrCells: (IDocumentSkeletonPage)[], cb: (line: IDocumentSkeletonLine, column: IDocumentSkeletonColumn, section: IDocumentSkeletonSection, page: IDocumentSkeletonPage) => void): void;
 export type DocumentSkeletonLineSource = 'page' | 'table-cell' | 'column';
@@ -93,7 +102,7 @@ export interface IDocumentSkeletonLineContext {
     visualLeft?: number;
     visualWidth?: number;
 }
-export type DocumentSkeletonTableSource = 'page' | 'column' | 'header' | 'footer';
+export type DocumentSkeletonTableSource = 'page' | 'table-cell' | 'column' | 'header' | 'footer';
 type HeaderFooterSkeletonMap = Map<string, Map<number, IDocumentSkeletonPage>>;
 export interface IDocumentSkeletonTableCellGeometry {
     cell: IDocumentSkeletonPage;
@@ -153,25 +162,29 @@ export declare function compareDocumentSkeletonNestedPagePathOrder(pos1: {
 export declare function columnIterator(pages: IDocumentSkeletonPage[], iteratorFunction: (column: IDocumentSkeletonColumn) => void): void;
 export declare function getPositionHorizon(positionH: IObjectPositionH, column: IDocumentSkeletonColumn, page: IDocumentSkeletonPage, objectWidth: number, isPageBreak?: boolean): number | undefined;
 export declare function getPositionVertical(positionV: IObjectPositionV, page: IDocumentSkeletonPage, lineTop: number, lineHeight: number, objectHeight: number, blockAnchorTop?: number, isPageBreak?: boolean): number | undefined;
-export declare function getGlyphGroupWidth(divide: IDocumentSkeletonDivide): number;
+export declare function getGlyphGroupWidth(divide: IDocumentSkeletonDivide, excludeTrailingSpaces?: boolean): number;
 interface IFontCreateConfig {
+    documentCompatibilityPolicy?: IDocumentCompatibilityPolicy;
     fontStyle: IDocumentSkeletonFontStyle;
-    textStyle: ITextStyle;
+    textStyle: IDocumentLayoutTextStyle;
     charSpace: number;
     gridType: GridType;
     snapToGrid: BooleanNumber;
     pageWidth: number;
+    balanceSingleByteDoubleByteWidth?: BooleanNumber;
 }
 export declare function clearFontCreateConfigCache(): void;
-export declare function getFontConfigFromLastGlyph(glyph: IDocumentSkeletonGlyph, sectionBreakConfig: ISectionBreakConfig, paragraphStyle: IParagraphStyle): {
+export declare function getFontConfigFromLastGlyph(glyph: IDocumentSkeletonGlyph, sectionBreakConfig: ISectionBreakConfig, paragraphStyle: IDocumentLayoutParagraphStyle): {
+    documentCompatibilityPolicy: IDocumentCompatibilityPolicy;
     fontStyle: IDocumentSkeletonFontStyle;
-    textStyle: ITextStyle;
+    textStyle: IDocumentLayoutTextStyle;
+    balanceSingleByteDoubleByteWidth: BooleanNumber | undefined;
     charSpace: number;
     gridType: GridType;
     snapToGrid: BooleanNumber;
     pageWidth: number;
 };
-export declare function getFontCreateConfig(index: number, viewModel: DocumentViewModel, paragraphNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, paragraph: IParagraph): IFontCreateConfig;
+export declare function getFontCreateConfig(index: number, viewModel: DocumentViewModel, paragraphNode: DataStreamTreeNode, sectionBreakConfig: ISectionBreakConfig, paragraph: IDocumentLayoutParagraph): IFontCreateConfig;
 export declare function getCustomRangeGlyphWidth(index: number, viewModel: DocumentViewModel, paragraphNode: DataStreamTreeNode, config: IFontCreateConfig): number | undefined;
 /**
  * Returns whether a custom range should occupy one measured glyph in the
@@ -207,6 +220,7 @@ export interface IFloatObject {
     angle: number;
     behindDoc?: BooleanNumber;
     layoutType?: PositionedObjectLayoutType;
+    effectExtent?: IDocDrawingBase['effectExtent'];
     type: FloatObjectType;
     positionV: IObjectPositionV;
 }
@@ -227,9 +241,23 @@ export interface IDocumentPaginationMetrics {
     peakCheckpointLineCount: number;
 }
 export interface ILayoutContext {
+    noteReferences?: ReadonlyMap<number, INoteReferenceLayout>;
+    footnoteLayout?: DocumentFootnoteLayout;
+    endnoteLayout?: DocumentEndnoteLayout;
+    /** Virtual marker in a note body; it never consumes a persisted character. */
+    noteLabel?: string;
+    noteReferenceTextStyle?: IDocumentLayoutTextStyle;
+    /** Preserve the local note segment when the paragraph/table pipeline opens a continuation page. */
+    noteSegmentId?: string;
+    footnoteFirstColumn?: {
+        index: number;
+        top: number;
+    };
     viewModel: DocumentViewModel;
     dataModel: DocumentDataModel;
     docsConfig: IDocsConfig;
+    modernPageWidth?: number;
+    modernHorizontalMargin?: number;
     skeleton: IDocumentSkeletonCached;
     layoutStartPointer: Record<string, Nullable<number>>;
     isDirty: boolean;
@@ -243,6 +271,18 @@ export interface ILayoutContext {
     sectionBreakConfigCache: Map<number, ISectionBreakConfig>;
     paragraphsOpenNewPage: Set<number>;
     paginationMetrics?: IDocumentPaginationMetrics;
+    /**
+     * Incremental layout may defer an expensive split-table calculation after
+     * the normal line-layout path has resolved its exact pagination context.
+     * Synchronous callers leave this unset.
+     */
+    deferSlicedTableLayout?: (request: {
+        curPage: IDocumentSkeletonPage;
+        viewModel: DocumentViewModel;
+        tableNode: DataStreamTreeNode;
+        sectionBreakConfig: ISectionBreakConfig;
+        availableHeight: number;
+    }) => boolean;
     hyphen: Hyphen;
     languageDetector: LanguageDetector;
 }

package/lib/types/components/docs/page-borders.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { IPageBorders } from '@univerjs/core';
+import type { IDocumentSkeletonPage } from '../../basics/i-document-skeleton-cached';
+import type { UniverRenderingContext } from '../../context';
+/** Draws section page borders without contributing to text/table layout. */
+export declare function drawPageBorders(ctx: UniverRenderingContext, page: IDocumentSkeletonPage, borders: IPageBorders | undefined, pageLeft: number, pageTop: number, firstPageInSection: boolean): void;

package/lib/types/components/docs/table-hit-test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare function getTopmostDocsTableHit<T>(tables: readonly T[], hitBody: (table: T) => boolean, hitControls: (table: T) => boolean, isNestedTable?: (outer: T, inner: T) => boolean): T | undefined;

package/lib/types/components/docs/table-render-viewport.d.ts

@@ -13,6 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { DocumentFlavor } from '@univerjs/core';
+import type { IDocumentSkeletonPage } from '../../basics/i-document-skeleton-cached';
+/** Shared by the canvas renderer and interactive table viewport provider. */
+export declare function getDocsTableLayoutViewportWidth(page: Pick<IDocumentSkeletonPage, 'pageWidth' | 'marginLeft' | 'marginRight'> & Partial<Pick<IDocumentSkeletonPage, 'type'>>, tableLeft: number, tableSource: unknown, documentFlavor?: DocumentFlavor): number;
 export interface IDocsTableRenderViewport {
     contentWidth: number;
     leadingInsetLeft?: number;

package/lib/types/components/docs/view-model/data-stream-tree-node.d.ts

@@ -25,6 +25,7 @@ export declare class DataStreamTreeNode {
     blocks: number[];
     constructor(nodeType: DataStreamTreeNodeType, content?: string | undefined);
     static create(nodeType: DataStreamTreeNodeType, content?: string): DataStreamTreeNode;
+    get contentStartIndex(): number;
     dispose(): void;
     getProps(): {
         children: DataStreamTreeNode[];

package/lib/types/components/docs/view-model/document-view-model.d.ts

@@ -13,7 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { DocumentDataModel, IColumnGroup, ICustomBlock, ICustomColumnGroup, ICustomDecorationForInterceptor, ICustomRangeForInterceptor, ICustomTable, IDisposable, IParagraph, ISectionBreak, ITable, ITextRun, Nullable } from '@univerjs/core';
+import type { DocumentDataModel, ICustomBlock, ICustomDecorationForInterceptor, ICustomRangeForInterceptor, ICustomTable, IDisposable, ITable, JSONXActions, Nullable } from '@univerjs/core';
+import type { IDocumentLayoutBody, IDocumentLayoutColumnGroup, IDocumentLayoutCustomColumnGroup, IDocumentLayoutParagraph, IDocumentLayoutSectionBreak, IDocumentLayoutSnapshot, IDocumentLayoutTextRun } from '../document-layout-presentation';
 import { DataStreamTreeNode } from './data-stream-tree-node';
 interface ITableNodeCache {
     table: DataStreamTreeNode;
@@ -36,8 +37,8 @@ interface ITableCoupleCache {
     tableSource: ITable;
 }
 interface IColumnGroupCoupleCache {
-    columnGroup: ICustomColumnGroup;
-    columnGroupSource: IColumnGroup;
+    columnGroup: IDocumentLayoutCustomColumnGroup;
+    columnGroupSource: IDocumentLayoutColumnGroup;
 }
 export declare class DocumentViewModel implements IDisposable {
     private _documentDataModel;
@@ -52,11 +53,23 @@ export declare class DocumentViewModel implements IDisposable {
     private _columnGroupCache;
     private _tableNodeCache;
     private _children;
+    private _treeNodes;
+    private _treeNodesByStartIndex;
+    private _plainTopLevelParagraphNodes;
+    private _metadataCachesDirty;
+    private _textRunsOrderedAndDisjoint;
+    private _paragraphsOrdered;
+    private _sectionBreaksOrdered;
+    private _customBlocksOrdered;
+    private _tablesOrdered;
+    private _columnGroupsOrdered;
+    private _lastTextRun;
     private _editArea;
     private readonly _editAreaChange$;
     readonly editAreaChange$: import("rxjs").Observable<Nullable<DocumentEditArea>>;
     private _headerTreeMap;
     private _footerTreeMap;
+    private _noteTreeMap;
     private readonly _segmentViewModels$;
     readonly segmentViewModels$: import("rxjs").Observable<DocumentViewModel[]>;
     constructor(_documentDataModel: DocumentDataModel, _tableSource?: Record<string, ITable> | undefined);
@@ -66,17 +79,20 @@ export declare class DocumentViewModel implements IDisposable {
         headerTreeMap: Map<string, DocumentViewModel>;
         footerTreeMap: Map<string, DocumentViewModel>;
     };
+    getNoteTreeMap(): ReadonlyMap<string, DocumentViewModel>;
     getEditArea(): DocumentEditArea;
     setEditArea(editArea: DocumentEditArea): void;
     getChildren(): DataStreamTreeNode[];
-    getBody(): import("@univerjs/core").IDocumentBody | undefined;
-    getSnapshot(): import("@univerjs/core").IDocumentData;
+    getBody(): IDocumentLayoutBody | undefined;
+    getSnapshot(): IDocumentLayoutSnapshot;
     getDataModel(): DocumentDataModel;
     getSelfOrHeaderFooterViewModel(segmentId?: string): DocumentViewModel;
     reset(documentDataModel: DocumentDataModel): void;
-    getSectionBreak(index: number): ISectionBreak | undefined;
-    getParagraph(index: number): IParagraph | undefined;
-    getTextRun(index: number): Nullable<ITextRun>;
+    resetByValidatedTextMutation(documentDataModel: DocumentDataModel, actions: JSONXActions): boolean;
+    resetByValidatedMetadataMutation(documentDataModel: DocumentDataModel, actions: JSONXActions): boolean;
+    getSectionBreak(index: number): IDocumentLayoutSectionBreak | undefined;
+    getParagraph(index: number): IDocumentLayoutParagraph | undefined;
+    getTextRun(index: number): Nullable<IDocumentLayoutTextRun>;
     getCustomBlock(index: number): ICustomBlock | undefined;
     getCustomBlockWithoutSetCurrentIndex(index: number): ICustomBlock | undefined;
     getTableByStartIndex(index: number): ITableCoupleCache | undefined;
@@ -87,6 +103,11 @@ export declare class DocumentViewModel implements IDisposable {
     getCustomDecorationRaw(index: number): import("@univerjs/core").ICustomDecoration | undefined;
     getCustomDecoration(index: number): Nullable<ICustomDecorationForInterceptor>;
     private _buildAllCache;
+    private _insertPlainText;
+    private _deletePlainText;
+    private _findParagraphNode;
+    private _rebuildTreeNodes;
+    private _collectNodePath;
     private _buildParagraphCache;
     private _buildSectionBreakCache;
     private _buildCustomBlockCache;

package/lib/types/components/extension.d.ts

@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IDocumentRenderConfig, IRange, IScale, Nullable } from '@univerjs/core';
+import type { IRange, IScale, Nullable } from '@univerjs/core';
 import type { BaseObject } from '../base-object';
 import type { IBoundRectNoAngle, Vector2 } from '../basics/vector2';
 import type { UniverRenderingContext } from '../context';
+import type { IDocumentLayoutRenderConfig } from './docs/document-layout-presentation';
 import { Registry } from '@univerjs/core';
 export interface IExtensionConfig {
     originTranslate?: Vector2;
@@ -24,7 +25,7 @@ export interface IExtensionConfig {
     spanPointWithFont?: Vector2;
     centerPoint?: Vector2;
     alignOffset?: Vector2;
-    renderConfig?: IDocumentRenderConfig;
+    renderConfig?: IDocumentLayoutRenderConfig;
 }
 export interface IDrawInfo {
     viewRanges: IRange[];

package/lib/types/components/sheets/extensions/sheet-extension.d.ts

@@ -17,7 +17,8 @@ import type { IRange } from '@univerjs/core';
 import type { SpreadsheetSkeleton } from '../sheet.render-skeleton';
 import { ComponentExtension } from '../../extension';
 export declare enum SHEET_EXTENSION_TYPE {
-    GRID = 0
+    BACKGROUND = 0,
+    GRID = 1
 }
 /**
  * for distinguish doc & slides extensions, now only used when metric performance.