modern-text 2.0.8 → 2.1.0

package/dist/shared/{modern-text.DPlppHEM.d.ts → modern-text.DG27jpKj.d.mts}

@@ -1,6 +1,6 @@
 import { NormalizedStyle, NormalizedFill, NormalizedOutline, FullStyle, TextObject, ReactivableEvents, Reactivable, NormalizedText, NormalizedEffect, LinearGradientWithType, RadialGradientWithType, NormalizedShadow } from 'modern-idoc';
 import { BoundingBox, Path2D, Vector2, Vector2Like, Path2DSet, Path2DStyle } from 'modern-path2d';
-import { Fonts, SFNT } from 'modern-font';
+import { SFNT, Fonts } from 'modern-font';
 
 declare class Fragment {
     readonly content: string;
@@ -20,22 +20,21 @@ declare class Fragment {
     initCharacters(): this;
 }
 
-declare class Character {
-    content: string;
-    index: number;
-    parent: Fragment;
-    path: Path2D<Character>;
-    lineBox: BoundingBox;
-    inlineBox: BoundingBox;
+interface GlyphTemplate {
+    path: Path2D;
     glyphBox?: BoundingBox;
-    advanceWidth: number;
+}
+interface FontMetrics {
+    sfnt: SFNT;
+    unitsPerEm: number;
     advanceHeight: number;
+    baseline: number;
+    ascender: number;
+    descender: number;
     underlinePosition: number;
     underlineThickness: number;
     strikeoutPosition: number;
     strikeoutSize: number;
-    ascender: number;
-    descender: number;
     typoAscender: number;
     typoDescender: number;
     typoLineGap: number;
@@ -43,9 +42,47 @@ declare class Character {
     winDescent: number;
     xHeight: number;
     capHeight: number;
-    baseline: number;
     centerDiviation: number;
     fontStyle?: 'bold' | 'italic';
+}
+declare class Character {
+    content: string;
+    index: number;
+    parent: Fragment;
+    protected _path?: Path2D<Character>;
+    protected _lazyPath?: {
+        tmpl: GlyphTemplate;
+        x: number;
+        y: number;
+        style: any;
+    };
+    get path(): Path2D<Character>;
+    set path(value: Path2D<Character>);
+    inlineBox: BoundingBox;
+    get lineBox(): BoundingBox;
+    glyphBox?: BoundingBox;
+    advanceWidth: number;
+    kerningBefore: number;
+    protected _glyphIndex?: number;
+    protected _metrics?: FontMetrics;
+    get advanceHeight(): number;
+    get baseline(): number;
+    get ascender(): number;
+    get descender(): number;
+    get underlinePosition(): number;
+    get underlineThickness(): number;
+    get strikeoutPosition(): number;
+    get strikeoutSize(): number;
+    get typoAscender(): number;
+    get typoDescender(): number;
+    get typoLineGap(): number;
+    get winAscent(): number;
+    get winDescent(): number;
+    get xHeight(): number;
+    get capHeight(): number;
+    get centerDiviation(): number;
+    get fontStyle(): 'bold' | 'italic' | undefined;
+    translateY(dy: number): void;
     get compatibleGlyphBox(): BoundingBox;
     get center(): Vector2;
     get computedFill(): NormalizedFill | undefined;
@@ -57,17 +94,18 @@ declare class Character {
     constructor(content: string, index: number, parent: Fragment);
     protected _getFontSFNT(fonts?: Fonts): SFNT | undefined;
     updateGlyph(sfnt?: SFNT | undefined): this;
+    computeKerningBefore(prev?: Character): number;
     /**
      * Populate glyph metrics only (advance width/height, ascender/descender,
      * baseline, …) without building the glyph `path` or touching boxes.
      *
-     * The DOM {@link DomMeasurer} never needs this — it reads positions back from the
-     * browser. A pure-JS measurer (e.g. `FontMeasurer`) must know advances *before*
-     * it can place characters, so it calls this ahead of layout. `update()` later
-     * recomputes the same metrics while building the path, so this is idempotent.
+     * The pure-JS `Measurer` must know advances *before* it can place characters,
+     * so it calls this ahead of layout. `update()` later recomputes the same metrics
+     * while building the path, so this is idempotent.
      */
     measureGlyph(fonts?: Fonts): this;
     update(fonts?: Fonts): this;
+    protected _updateFromCache(sfnt: SFNT, style: FullStyle): void;
     protected _italic(path: Path2D, startPoint?: Vector2Like): void;
     getGlyphMinMax(min?: Vector2, max?: Vector2, withStyle?: boolean): {
         min: Vector2;
@@ -76,97 +114,24 @@ declare class Character {
     getGlyphBoundingBox(withStyle?: boolean): BoundingBox | undefined;
 }
 
-interface MeasuredParagraph {
-    paragraphIndex: number;
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-}
-interface MeasuredFragment {
-    paragraphIndex: number;
-    fragmentIndex: number;
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-}
-interface MeasuredCharacter {
-    paragraphIndex: number;
-    fragmentIndex: number;
-    characterIndex: number;
-    newParagraphIndex: number;
-    content: string;
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-    textHeight: number;
-    textWidth: number;
-}
-interface MeasuredCharacterRect {
-    content: string;
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-}
-interface MeasureDomResult {
+/**
+ * A measurer's output: the paragraphs with their four-level boxes filled in place,
+ * plus the overall bounding box. (Formerly `MeasureDomResult`; layout is now
+ * DOM-free via {@link import('./Measurer').Measurer}.)
+ */
+interface MeasurerResult {
     paragraphs: Paragraph[];
     boundingBox: BoundingBox;
 }
-interface RootDomStyles {
-    section: Record<string, any>;
-    ul: Record<string, any>;
-}
-declare class DomMeasurer {
-    static notZeroStyles: Set<string>;
-    static pxStyles: Set<string>;
-    protected _styleCache: WeakMap<object, Record<string, any>>;
-    protected _mountedDom?: HTMLElement;
-    protected _mountedSignature?: string;
-    protected _toDomStyle(style: Record<string, any>): Record<string, any>;
-    protected _resolveRootStyles(rootStyle: FullStyle): RootDomStyles;
-    protected _applyRootStyle(section: HTMLElement, ul: HTMLElement, rootStyle: FullStyle): void;
-    protected _applyLiStyle(li: HTMLElement, paragraph: Paragraph): void;
-    protected _applySpanStyle(span: HTMLElement, fragment: Fragment): void;
-    protected _applyFragmentContent(span: HTMLElement, fragment: Fragment): void;
-    protected _hide(element: HTMLElement): void;
-    protected _signature(paragraphs: Paragraph[]): string;
-    /**
-     * <section style="...">
-     *   <ul>
-     *     <li style="...">
-     *       <span style="...">...</span>
-     *       <span>...</span>
-     *     </li>
-     *   </ul>
-     * </section>
-     */
-    createDom(paragraphs: Paragraph[], rootStyle: FullStyle): HTMLElement;
-    protected _patchDom(dom: HTMLElement, paragraphs: Paragraph[], rootStyle: FullStyle, hidden: boolean): void;
-    measureDomText(text: Text): MeasuredCharacterRect[];
-    measureDom(dom: HTMLElement): {
-        paragraphs: MeasuredParagraph[];
-        fragments: MeasuredFragment[];
-        characters: MeasuredCharacter[];
-    };
-    measureParagraphDom(paragraphs: Paragraph[], dom: HTMLElement): MeasureDomResult;
-    measure(paragraphs: Paragraph[], rootStyle: FullStyle, dom?: HTMLElement): MeasureDomResult;
-    protected _mount(paragraphs: Paragraph[], rootStyle: FullStyle): HTMLElement;
-    protected _unmount(): void;
-    dispose(): void;
-}
-
 interface Plugin {
     name: string;
     pathSet?: Path2DSet;
-    getBoundingBox?: (text: Text$1) => BoundingBox | undefined;
-    update?: (text: Text$1) => void;
+    getBoundingBox?: (text: Text) => BoundingBox | undefined;
+    update?: (text: Text) => void;
     updateOrder?: number;
     render?: (renderer: Canvas2DRenderer) => void;
     renderOrder?: number;
-    load?: (text: Text$1) => Promise<void>;
+    load?: (text: Text) => Promise<void>;
     context?: Record<string, any>;
 }
 /**
@@ -174,34 +139,32 @@ interface Plugin {
  * (`character.inlineBox`/`lineBox`, `fragment.inlineBox`, `paragraph.lineBox`)
  * in place and return the overall bounding box.
  *
- * - `DomMeasurer` — DOM-based, uses the browser as ground truth (default).
- * - `FontMeasurer` — pure-JS, DOM-free; needs `fonts` to resolve glyph advances.
- *
- * `fonts` is passed positionally by `Text.measure()`; DOM-based measurers ignore
- * it (a method may safely declare fewer parameters than the interface).
+ * The built-in backend is the pure-JS, DOM-free {@link import('./Measurer').Measurer},
+ * which resolves glyph advances/kerning from `modern-font` — it runs in Node/SSR/Worker
+ * and measures the exact font that is rendered. `fonts` is passed positionally by
+ * `Text.measure()`.
  */
 interface TextMeasurer {
-    measure: (paragraphs: Paragraph[], rootStyle: FullStyle, dom?: HTMLElement, fonts?: Fonts) => MeasureDomResult;
-    createDom?: (paragraphs: Paragraph[], rootStyle: FullStyle) => HTMLElement;
+    measure: (paragraphs: Paragraph[], rootStyle: FullStyle, dom?: HTMLElement, fonts?: Fonts) => MeasurerResult;
     dispose?: () => void;
 }
-/** Built-in layout backends. `'font'` → `FontMeasurer`, `'dom'` → `DomMeasurer`. */
-type MeasurerKind = 'dom' | 'font';
 interface Options extends TextObject {
     debug?: boolean;
     measureDom?: HTMLElement;
     fonts?: Fonts;
     plugins?: Plugin[];
-    /**
-     * Layout backend: `'font'` (pure-JS) or `'dom'` (browser), or a custom
-     * `TextMeasurer`. Defaults to `'font'`.
-     */
-    measurer?: MeasurerKind | TextMeasurer;
 }
 
 interface RenderOptions {
     view: HTMLCanvasElement;
     pixelRatio?: number;
+    /** 只渲染 boundingBox 内的这一子块（相对偏移 + 尺寸），用于超大文字按 GPU 上限分块栅格。 */
+    region?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
     onContext?: (context: CanvasRenderingContext2D) => void;
 }
 interface MeasureResult {
@@ -215,25 +178,25 @@ interface MeasureResult {
 declare const textDefaultStyle: FullStyle;
 interface TextEvents extends ReactivableEvents {
     update: [ctx: {
-        text: Text$1;
+        text: Text;
     }];
     measure: [ctx: {
-        text: Text$1;
+        text: Text;
         result: MeasureResult;
     }];
     render: [ctx: {
-        text: Text$1;
+        text: Text;
         view: HTMLCanvasElement;
         pixelRatio: number;
     }];
 }
-interface Text$1 {
+interface Text {
     on: <K extends keyof TextEvents & string>(event: K, listener: (...args: TextEvents[K]) => void) => this;
     once: <K extends keyof TextEvents & string>(event: K, listener: (...args: TextEvents[K]) => void) => this;
     off: <K extends keyof TextEvents & string>(event: K, listener: (...args: TextEvents[K]) => void) => this;
     emit: <K extends keyof TextEvents & string>(event: K, ...args: TextEvents[K]) => this;
 }
-declare class Text$1 extends Reactivable {
+declare class Text extends Reactivable {
     debug: boolean;
     content: NormalizedText['content'];
     style?: NormalizedText['style'];
@@ -259,6 +222,14 @@ declare class Text$1 extends Reactivable {
     pathSets: Path2DSet[];
     protected _paragraphs: Paragraph[];
     protected _cachedCharacters?: Character[];
+    incrementalLayout: boolean;
+    protected _prevParagraphs: Paragraph[];
+    protected _prevContentKeys: string[];
+    protected _prevStyleKey: string;
+    protected _prevFonts: unknown;
+    protected _prevFontsSet: boolean;
+    protected _pendingContentKeys: string[];
+    protected _pendingStyleKey: string;
     protected _pluginsByUpdateOrder: Plugin[];
     protected _pluginsByRenderOrder: Plugin[];
     protected _renderer?: Canvas2DRenderer;
@@ -287,7 +258,7 @@ declare class Text$1 extends Reactivable {
      *
      * No-op for already-decoded fonts and for formats without async decoding.
      */
-    protected _decodeFonts(): Promise<void>;
+    protected _decodeFonts(): Promise<number>;
     /**
      * Coerce numeric style fields to finite numbers.
      *
@@ -301,10 +272,13 @@ declare class Text$1 extends Reactivable {
      * numerics like `parseFloat`, matching the normalized path).
      */
     protected _normalizeComputedStyle(style: FullStyle): FullStyle;
+    protected _buildParagraph(p: NormalizedText['content'][number], pIndex: number): Paragraph;
+    protected _canReuseLayout(styleKey: string): boolean;
     protected _update(): this;
-    createDom(): HTMLElement;
     measure(dom?: HTMLElement | undefined): MeasureResult;
     getGlyphBox(): BoundingBox;
+    protected _paragraphGlyphBox(paragraph: Paragraph): BoundingBox | undefined;
+    protected _computeGlyphBox(): BoundingBox;
     protected _updateInlineBox(): this;
     protected _updatePathBox(): this;
     protected _updateBoundingBox(): this;
@@ -319,15 +293,21 @@ declare class Text$1 extends Reactivable {
 declare class Paragraph {
     readonly style: NormalizedStyle;
     readonly index: number;
-    readonly parent: Text$1;
+    readonly parent: Text;
     lineBox: BoundingBox;
     fragments: Fragment[];
     fill?: NormalizedFill;
     outline?: NormalizedOutline;
+    _layoutDirty: boolean;
+    _layoutTop: number;
+    _layoutHeight: number;
+    _layoutRight: number;
+    _glyphBox?: BoundingBox;
+    _layoutValid: boolean;
     computedStyle: FullStyle;
     computedFill: NormalizedFill | undefined;
     computedOutline: NormalizedOutline | undefined;
-    constructor(style: NormalizedStyle, index: number, parent: Text$1);
+    constructor(style: NormalizedStyle, index: number, parent: Text);
     update(): this;
 }
 
@@ -335,10 +315,16 @@ interface DrawShapePathsOptions extends Partial<Path2DStyle> {
     clipRect?: BoundingBox;
 }
 declare class Canvas2DRenderer {
-    text: Text$1;
+    text: Text;
     context: CanvasRenderingContext2D;
     pixelRatio: number;
-    constructor(text: Text$1, context: CanvasRenderingContext2D);
+    region?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    constructor(text: Text, context: CanvasRenderingContext2D);
     protected _setupView: () => void;
     protected _setupColors: () => void;
     setup: () => this;
@@ -359,5 +345,5 @@ declare class Canvas2DRenderer {
     drawCharacter: (character: Character, effect?: NormalizedEffect) => void;
 }
 
-export { Canvas2DRenderer as C, DomMeasurer as D, Fragment as F, Paragraph as P, Text$1 as T, Character as a, textDefaultStyle as t };
-export type { MeasureDomResult as M, Options as O, RenderOptions as R, DrawShapePathsOptions as b, MeasureResult as c, MeasuredCharacter as d, MeasuredCharacterRect as e, MeasuredFragment as f, MeasuredParagraph as g, MeasurerKind as h, Plugin as i, TextEvents as j, TextMeasurer as k };
+export { Canvas2DRenderer as C, Fragment as F, Paragraph as P, Text as T, Character as a, textDefaultStyle as t };
+export type { DrawShapePathsOptions as D, MeasureResult as M, Options as O, RenderOptions as R, MeasurerResult as b, Plugin as c, TextEvents as d, TextMeasurer as e };