three-text 0.5.2 → 0.6.0

package/dist/vector/core.d.ts

@@ -1,7 +1,31 @@
-import { Text as Text$1 } from '../core/Text';
-import { VectorGlyphInfo, TextQueryOptions, TextRange, LoadedFont, TextOptions } from '../core/types';
-export { LoadedFont, TextOptions, VectorGlyphInfo } from '../core/types';
+interface HyphenationTrieNode {
+    patterns: number[] | null;
+    children: {
+        [char: string]: HyphenationTrieNode;
+    };
+}
 
+declare class Vec3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    set(x: number, y: number, z: number): Vec3;
+    clone(): Vec3;
+    copy(v: Vec3): Vec3;
+    add(v: Vec3): Vec3;
+    sub(v: Vec3): Vec3;
+    multiply(scalar: number): Vec3;
+    divide(scalar: number): Vec3;
+    length(): number;
+    lengthSq(): number;
+    normalize(): Vec3;
+    dot(v: Vec3): number;
+    cross(v: Vec3): Vec3;
+    distanceTo(v: Vec3): number;
+    distanceToSquared(v: Vec3): number;
+    equals(v: Vec3): boolean;
+}
 interface BoundingBox {
     min: {
         x: number;
@@ -15,87 +39,353 @@ interface BoundingBox {
     };
 }
 
-interface QuadraticSegment {
-    p0x: number;
-    p0y: number;
-    p1x: number;
-    p1y: number;
-    p2x: number;
-    p2y: number;
-}
-interface ContourVertex {
-    x: number;
-    y: number;
+interface HarfBuzzGlyph {
+    g: number;
+    cl: number;
+    ax: number;
+    ay: number;
+    dx: number;
+    dy: number;
+    x?: number;
+    y?: number;
+    lineIndex: number;
+    absoluteTextIndex: number;
 }
-interface VectorContour {
-    vertices: ContourVertex[];
-    segments: QuadraticSegment[];
-}
-interface VectorGlyphAttributes {
-    glyphCenter: Float32Array;
-    glyphIndex: Float32Array;
-    glyphProgress: Float32Array;
-    glyphLineIndex: Float32Array;
-    glyphBaselineY: Float32Array;
-}
-interface GlyphRange {
-    interiorIndexStart: number;
-    interiorIndexCount: number;
-    curveVertexStart: number;
-    curveVertexCount: number;
-}
-interface VectorGeometryData {
-    interiorPositions: Float32Array;
-    interiorIndices: Uint32Array;
-    curvePositions: Float32Array;
-    fillPositions: Float32Array;
-    fillIndices: Uint32Array;
-    glyphRanges: GlyphRange[];
-    interiorGlyphAttrs?: VectorGlyphAttributes;
-    curveGlyphAttrs?: VectorGlyphAttributes;
-    fillGlyphAttrs?: VectorGlyphAttributes;
-    planeBounds: BoundingBox;
-    stats: {
-        glyphCount: number;
-        contourCount: number;
-        interiorTriangleCount: number;
-        curveTriangleCount: number;
+interface GlyphCluster {
+    text: string;
+    glyphs: HarfBuzzGlyph[];
+    position: Vec3;
+}
+type TextAlign = 'left' | 'center' | 'right' | 'justify';
+type TextDirection = 'ltr' | 'rtl';
+interface LineInfo {
+    text: string;
+    originalStart: number;
+    originalEnd: number;
+    xOffset: number;
+    adjustmentRatio?: number;
+    isLastLine?: boolean;
+    naturalWidth?: number;
+    endedWithHyphen?: boolean;
+}
+interface LoadedFont {
+    hb: HarfBuzzAPI;
+    fontBlob: HarfBuzzBlob;
+    face: HarfBuzzFace;
+    font: HarfBuzzFont;
+    module: HarfBuzzModule;
+    upem: number;
+    metrics: ExtractedMetrics;
+    fontVariations?: {
+        [key: string]: number;
+    };
+    fontFeatures?: {
+        [tag: string]: boolean | number;
     };
+    isVariable?: boolean;
+    variationAxes?: {
+        [key: string]: VariationAxis;
+    };
+    availableFeatures?: string[];
+    featureNames?: {
+        [tag: string]: string;
+    };
+    _buffer?: ArrayBuffer;
 }
-interface LoopBlinnGlyphInput {
-    offsetX: number;
-    offsetY: number;
-    segments: QuadraticSegment[];
-    bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
+interface HarfBuzzModule {
+    addFunction: (func: Function, signature: string) => number;
+    exports: any;
+    removeFunction: (ptr: number) => void;
+}
+interface VariationAxis {
+    min: number;
+    default: number;
+    max: number;
+    name?: string;
+}
+interface HarfBuzzAPI {
+    createBlob: (data: Uint8Array) => HarfBuzzBlob;
+    createFace: (blob: HarfBuzzBlob, index: number) => HarfBuzzFace;
+    createFont: (face: HarfBuzzFace) => HarfBuzzFont;
+    createBuffer: () => HarfBuzzBuffer;
+    shape: (font: HarfBuzzFont, buffer: HarfBuzzBuffer, features?: string) => void;
+}
+interface HarfBuzzBlob {
+    destroy: () => void;
+}
+interface HarfBuzzFace {
+    destroy: () => void;
+    getAxisInfos: () => {
+        [tag: string]: VariationAxis;
     };
+}
+interface HarfBuzzFont {
+    ptr: number;
+    destroy: () => void;
+    setScale: (xScale: number, yScale: number) => void;
+    setVariations: (variations: {
+        [key: string]: number;
+    }) => void;
+}
+interface HarfBuzzBuffer {
+    addText: (text: string) => void;
+    guessSegmentProperties: () => void;
+    setDirection: (direction: string) => void;
+    json: (font: HarfBuzzFont) => any[];
+    destroy: () => void;
+}
+interface HarfBuzzInstance {
+    hb: HarfBuzzAPI;
+    module: HarfBuzzModule;
+}
+interface ExtractedMetrics {
+    isCFF: boolean;
+    unitsPerEm: number;
+    hheaAscender: number | null;
+    hheaDescender: number | null;
+    hheaLineGap: number | null;
+    typoAscender: number | null;
+    typoDescender: number | null;
+    typoLineGap: number | null;
+    winAscent: number | null;
+    winDescent: number | null;
+    axisNames: {
+        [tag: string]: string;
+    } | null;
+}
+interface FontMetrics {
+    ascender: number;
+    descender: number;
+    lineGap: number;
+    unitsPerEm: number;
+    naturalLineHeight: number;
+}
+interface PathInfo {
+    start: number;
+    count: number;
+}
+interface GlyphGeometryInfo {
+    textIndex: number;
     lineIndex: number;
-    baselineY: number;
+    vertexStart: number;
+    vertexCount: number;
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    paths?: PathInfo[];
 }
-interface LoopBlinnInput {
-    glyphs: LoopBlinnGlyphInput[];
-    planeBounds: BoundingBox;
+interface TextRange {
+    start: number;
+    end: number;
+    originalText: string;
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }[];
+    glyphs: GlyphGeometryInfo[];
+    lineIndices: number[];
+}
+interface TextQueryOptions {
+    byText?: string[];
+    byCharRange?: {
+        start: number;
+        end: number;
+    }[];
+}
+interface VectorGlyphInfo extends GlyphGeometryInfo {
+    segmentStart: number;
+    segmentCount: number;
+}
+interface TextLayoutData {
+    lines: LineInfo[];
+    scaledLineHeight: number;
+    letterSpacing: number;
+    align: string;
+    direction: TextDirection;
+    depth: number;
+    size: number;
+    pixelsPerFontUnit: number;
+}
+interface TextLayoutResult {
+    clustersByLine: GlyphCluster[][];
+    layoutData: TextLayoutData;
+    options: TextOptions;
+    loadedFont: LoadedFont;
+    fontId: string;
+}
+interface TextLayoutHandle extends TextLayoutResult {
+    getLoadedFont(): LoadedFont | undefined;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    update(options: Partial<TextOptions>): Promise<TextLayoutHandle>;
+    dispose(): void;
+}
+interface ColorByRange {
+    start: number;
+    end: number;
+    color: [number, number, number];
+}
+interface ColorOptions {
+    default?: [number, number, number];
+    byText?: {
+        [text: string]: [number, number, number];
+    };
+    byCharRange?: ColorByRange[];
+}
+interface TextOptions {
+    text: string;
+    font: string | ArrayBuffer;
+    size?: number;
+    depth?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    perGlyphAttributes?: boolean;
+    fontVariations?: {
+        [key: string]: number;
+    };
+    fontFeatures?: {
+        [tag: string]: boolean | number;
+    };
+    maxTextLength?: number;
+    removeOverlaps?: boolean;
+    curveSteps?: number;
+    curveFidelity?: CurveFidelityConfig;
+    geometryOptimization?: GeometryOptimizationOptions;
+    layout?: LayoutOptions;
+    color?: [number, number, number] | ColorOptions;
+}
+interface HyphenationPatternsMap {
+    [language: string]: HyphenationTrieNode;
+}
+interface CurveFidelityConfig {
+    distanceTolerance?: number;
+    angleTolerance?: number;
+    cuspLimit?: number;
+    collinearityEpsilon?: number;
+    recursionLimit?: number;
+}
+interface GeometryOptimizationOptions {
+    enabled?: boolean;
+    areaThreshold?: number;
+}
+interface LayoutOptions {
+    width?: number;
+    align?: TextAlign;
+    direction?: TextDirection;
+    respectExistingBreaks?: boolean;
+    hyphenate?: boolean;
+    language?: string;
+    patternsPath?: string;
+    tolerance?: number;
+    pretolerance?: number;
+    emergencyStretch?: number;
+    autoEmergencyStretch?: number;
+    hyphenationPatterns?: HyphenationPatternsMap;
+    lefthyphenmin?: number;
+    righthyphenmin?: number;
+    linepenalty?: number;
+    adjdemerits?: number;
+    hyphenpenalty?: number;
+    exhyphenpenalty?: number;
+    doublehyphendemerits?: number;
 }
-declare function extractContours(segments: QuadraticSegment[]): VectorContour[];
-declare function buildVectorGeometry(input: LoopBlinnInput): VectorGeometryData;
 
-interface HyphenationTrieNode {
-    patterns: number[] | null;
-    children: {
-        [char: string]: HyphenationTrieNode;
+declare global {
+    interface Window {
+        hbjs?: any;
+        createHarfBuzz?: () => Promise<any>;
+    }
+}
+declare class Text$1 {
+    private static patternCache;
+    private static hbInitPromise;
+    private static fontCache;
+    private static fontLoadPromises;
+    private static fontRefCounts;
+    private static fontCacheMemoryBytes;
+    private static maxFontCacheMemoryBytes;
+    private static fontIdCounter;
+    static enableWoff2(decoder: (data: ArrayBuffer | Uint8Array) => Uint8Array | Promise<Uint8Array>): void;
+    private static stableStringify;
+    private fontLoader;
+    private loadedFont?;
+    private currentFontId;
+    private currentFontCacheKey?;
+    private textShaper?;
+    private textLayout?;
+    private constructor();
+    static setHarfBuzzPath(path: string): void;
+    static setHarfBuzzBuffer(wasmBuffer: ArrayBuffer): void;
+    static init(): Promise<HarfBuzzInstance>;
+    static create(options: TextOptions): Promise<TextLayoutHandle>;
+    private static retainFont;
+    private static releaseFont;
+    private static resolveFont;
+    private static loadAndCacheFont;
+    private static trackFontCacheAdd;
+    private static trackFontCacheRemove;
+    private static enforceFontCacheMemoryLimit;
+    private static generateFontContentHash;
+    private setLoadedFont;
+    private releaseCurrentFont;
+    private loadFont;
+    private createLayout;
+    private prepareHyphenation;
+    private validateOptions;
+    private updateFontVariations;
+    private prepareLayout;
+    getFontMetrics(): FontMetrics;
+    static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
+    static registerPattern(language: string, pattern: HyphenationTrieNode): void;
+    static setMaxFontCacheMemoryMB(limitMB: number): void;
+    getLoadedFont(): LoadedFont | undefined;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    private resetHelpers;
+    destroy(): void;
+}
+
+interface SlugPackedTexture {
+    data: Float32Array | Uint32Array;
+    width: number;
+    height: number;
+}
+interface SlugGPUData {
+    curveTexture: SlugPackedTexture & {
+        data: Float32Array;
     };
+    bandTexture: SlugPackedTexture & {
+        data: Uint32Array;
+    };
+    /** 5 attribs x 4 components x 4 verts per shape, tightly packed per-shape */
+    vertices: Float32Array;
+    indices: Uint16Array;
+    shapeCount: number;
 }
 
-interface VectorTextResult {
+interface VectorCoreResult {
+    gpuData: SlugGPUData;
     glyphs: VectorGlyphInfo[];
-    geometryData: VectorGeometryData;
+    planeBounds: BoundingBox;
     query(options: TextQueryOptions): TextRange[];
     getLoadedFont(): LoadedFont | undefined;
     measureTextWidth(text: string, letterSpacing?: number): number;
-    update(options: Partial<TextOptions>): Promise<VectorTextResult>;
+    update(options: Partial<TextOptions>): Promise<VectorCoreResult>;
     dispose(): void;
 }
 declare class Text {
@@ -106,7 +396,7 @@ declare class Text {
     static preloadPatterns: typeof Text$1.preloadPatterns;
     static setMaxFontCacheMemoryMB: typeof Text$1.setMaxFontCacheMemoryMB;
     static enableWoff2: typeof Text$1.enableWoff2;
-    static create(options: TextOptions): Promise<VectorTextResult>;
+    static create(options: TextOptions): Promise<VectorCoreResult>;
 }
 
-export { GlyphRange, HyphenationTrieNode, LoopBlinnGlyphInput, LoopBlinnInput, QuadraticSegment, Text, VectorTextResult as TextGeometryInfo, VectorContour, VectorGeometryData, VectorGlyphAttributes, VectorTextResult, buildVectorGeometry, extractContours };
+export { HyphenationTrieNode, LoadedFont, SlugGPUData, Text, VectorCoreResult as TextGeometryInfo, TextOptions, VectorCoreResult, VectorGlyphInfo };