three-text 0.5.0 → 0.5.2

package/dist/vector/index.d.ts

@@ -1,8 +1,35 @@
-import { Text as Text$1 } from '../core/Text';
-import { VectorGlyphInfo, TextQueryOptions, TextRange, LoadedFont, TextOptions } from '../core/types';
+import { VectorGlyphInfo, TextQueryOptions, TextRange, LoadedFont as LoadedFont$1, TextOptions as TextOptions$1 } from '../core/types';
 export { LoadedFont, TextOptions, VectorGlyphInfo } from '../core/types';
 import * as THREE from 'three';
 
+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;
@@ -16,6 +43,274 @@ interface BoundingBox {
     };
 }
 
+interface HarfBuzzGlyph {
+    g: number;
+    cl: number;
+    ax: number;
+    ay: number;
+    dx: number;
+    dy: number;
+    x?: number;
+    y?: number;
+    lineIndex: number;
+    absoluteTextIndex: 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 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 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 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 QuadraticSegment {
     p0x: number;
     p0y: number;
@@ -83,30 +378,50 @@ interface LoopBlinnInput {
 declare function extractContours(segments: QuadraticSegment[]): VectorContour[];
 declare function buildVectorGeometry(input: LoopBlinnInput): VectorGeometryData;
 
-interface HyphenationTrieNode {
-    patterns: number[] | null;
-    children: {
-        [char: string]: HyphenationTrieNode;
-    };
+interface VectorTextResult {
+    glyphs: VectorGlyphInfo[];
+    geometryData: VectorGeometryData;
+    query(options: TextQueryOptions): TextRange[];
+    getLoadedFont(): LoadedFont$1 | undefined;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    update(options: Partial<TextOptions$1>): Promise<VectorTextResult>;
+    dispose(): void;
 }
 
+interface VectorMeshOptions {
+    color?: THREE.ColorRepresentation;
+    positionNode?: any;
+    colorNode?: any;
+    center?: boolean;
+}
 interface VectorMeshes {
-    interiorMesh: THREE.Mesh;
-    curveMesh: THREE.Mesh;
+    group: THREE.Group;
+    interiorMesh: THREE.Object3D;
+    curveMesh: THREE.Object3D;
     fillMesh: THREE.Mesh;
+    interiorGeometry: THREE.BufferGeometry;
+    curveGeometry: THREE.BufferGeometry;
+    fillGeometry: THREE.BufferGeometry;
     setOffset(x: number, y: number, z?: number): void;
+    updateMaterials(options?: VectorMeshOptions): void;
     dispose(): void;
 }
-declare function createVectorMeshes(data: VectorGeometryData, color?: THREE.ColorRepresentation): VectorMeshes;
+declare const loopBlinnFragment: any;
+declare function createVectorMeshes(data: VectorGeometryData, options?: VectorMeshOptions | THREE.ColorRepresentation): VectorMeshes;
 
-interface VectorTextResult {
-    glyphs: VectorGlyphInfo[];
-    geometryData: VectorGeometryData;
-    query(options: TextQueryOptions): TextRange[];
-    getLoadedFont(): LoadedFont | undefined;
-    measureTextWidth(text: string, letterSpacing?: number): number;
-    update(options: Partial<TextOptions>): Promise<VectorTextResult>;
-    dispose(): void;
+interface VectorTextOptions extends TextOptions$1 {
+    color?: any;
+    positionNode?: any;
+    colorNode?: any;
+    center?: boolean;
+}
+interface VectorResult extends VectorTextResult {
+    group: THREE.Group;
+    interiorGeometry: THREE.BufferGeometry;
+    curveGeometry: THREE.BufferGeometry;
+    fillGeometry: THREE.BufferGeometry;
+    updateMaterials(options?: VectorMeshOptions): void;
+    update(newOptions: Partial<VectorTextOptions>): Promise<VectorResult>;
 }
 declare class Text {
     static setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;
@@ -116,7 +431,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: VectorTextOptions): Promise<VectorResult>;
 }
 
-export { GlyphRange, HyphenationTrieNode, LoopBlinnGlyphInput, LoopBlinnInput, QuadraticSegment, Text, VectorTextResult as TextGeometryInfo, VectorContour, VectorGeometryData, VectorGlyphAttributes, VectorMeshes, VectorTextResult, buildVectorGeometry, createVectorMeshes, extractContours };
+export { GlyphRange, HyphenationTrieNode, LoopBlinnGlyphInput, LoopBlinnInput, QuadraticSegment, Text, VectorContour, VectorGeometryData, VectorGlyphAttributes, VectorMeshOptions, VectorMeshes, VectorResult, VectorTextOptions, VectorTextResult, buildVectorGeometry, createVectorMeshes, extractContours, loopBlinnFragment };