three-text 0.4.8 → 0.4.9

package/dist/core/shaping/fontFeatures.d.ts

@@ -0,0 +1,3 @@
+export declare function convertFontFeaturesToString(features?: {
+    [tag: string]: boolean | number;
+}): string | undefined;

package/dist/core/types.d.ts

@@ -0,0 +1,354 @@
+import type { HyphenationTrieNode } from '../hyphenation';
+import type { CacheStats } from '../utils/Cache';
+import type { Vec2, Vec3, BoundingBox } from '../utils/vectors';
+export type { HyphenationTrieNode };
+export interface Path {
+    points: Vec2[];
+    glyphIndex: number;
+    bounds?: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+export interface HarfBuzzGlyph {
+    g: number;
+    cl: number;
+    ax: number;
+    ay: number;
+    dx: number;
+    dy: number;
+    x?: number;
+    y?: number;
+    lineIndex: number;
+    absoluteTextIndex: number;
+}
+export interface GlyphCluster {
+    text: string;
+    glyphs: HarfBuzzGlyph[];
+    position: Vec3;
+}
+export interface GlyphContours {
+    glyphId: number;
+    paths: Path[];
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+        };
+        max: {
+            x: number;
+            y: number;
+        };
+    };
+}
+export type TextAlign = 'left' | 'center' | 'right' | 'justify';
+export type TextDirection = 'ltr' | 'rtl';
+export interface LineInfo {
+    text: string;
+    originalStart: number;
+    originalEnd: number;
+    xOffset: number;
+    adjustmentRatio?: number;
+    isLastLine?: boolean;
+    naturalWidth?: number;
+    endedWithHyphen?: boolean;
+}
+export 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;
+}
+export interface HarfBuzzModule {
+    addFunction: (func: Function, signature: string) => number;
+    exports: any;
+    removeFunction: (ptr: number) => void;
+}
+export interface VariationAxis {
+    min: number;
+    default: number;
+    max: number;
+    name?: string;
+}
+export 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;
+}
+export interface HarfBuzzBlob {
+    destroy: () => void;
+}
+export interface HarfBuzzFace {
+    destroy: () => void;
+    getAxisInfos: () => {
+        [tag: string]: VariationAxis;
+    };
+}
+export interface HarfBuzzFont {
+    ptr: number;
+    destroy: () => void;
+    setScale: (xScale: number, yScale: number) => void;
+    setVariations: (variations: {
+        [key: string]: number;
+    }) => void;
+}
+export interface HarfBuzzBuffer {
+    addText: (text: string) => void;
+    guessSegmentProperties: () => void;
+    setDirection: (direction: string) => void;
+    json: (font: HarfBuzzFont) => any[];
+    destroy: () => void;
+}
+export interface HarfBuzzInstance {
+    hb: HarfBuzzAPI;
+    module: HarfBuzzModule;
+}
+export 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;
+}
+export interface VerticalMetrics {
+    ascender: number;
+    descender: number;
+    lineGap: number;
+}
+export interface FontMetrics {
+    ascender: number;
+    descender: number;
+    lineGap: number;
+    unitsPerEm: number;
+    naturalLineHeight: number;
+}
+export interface ProcessedPath {
+    outer: Path;
+    holes: Path[];
+}
+export interface Triangles {
+    vertices: number[];
+    indices: number[];
+}
+export interface ProcessedGeometry {
+    triangles: Triangles;
+    contours: number[][];
+    contoursAreBoundary?: boolean;
+}
+export interface GlyphData {
+    geometry: ProcessedGeometry;
+    vertices: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    useCount: number;
+}
+export interface PathInfo {
+    start: number;
+    count: number;
+}
+export interface GlyphGeometryInfo {
+    textIndex: number;
+    lineIndex: number;
+    vertexStart: number;
+    vertexCount: number;
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    paths?: PathInfo[];
+}
+export 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[];
+}
+export interface TextQueryOptions {
+    byText?: string[];
+    byCharRange?: {
+        start: number;
+        end: number;
+    }[];
+}
+export interface TextGeometryInfo {
+    vertices: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    colors?: Float32Array;
+    glyphAttributes?: {
+        glyphCenter: Float32Array;
+        glyphIndex: Float32Array;
+        glyphLineIndex: Float32Array;
+        glyphProgress: Float32Array;
+        glyphBaselineY: Float32Array;
+    };
+    glyphs: GlyphGeometryInfo[];
+    planeBounds: BoundingBox;
+    stats: {
+        trianglesGenerated: number;
+        verticesGenerated: number;
+        pointsRemovedByVisvalingam: number;
+        originalPointCount: number;
+    } & Partial<CacheStats & {
+        hitRate: number;
+        memoryUsageMB: number;
+    }>;
+    query(options: TextQueryOptions): TextRange[];
+    coloredRanges?: ColoredRange[];
+}
+export interface TextHandle extends TextGeometryInfo {
+    getLoadedFont(): LoadedFont | undefined;
+    getCacheSize(): number;
+    clearCache(): void;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    update(options: Partial<TextOptions>): Promise<TextHandle>;
+}
+export interface ColorByRange {
+    start: number;
+    end: number;
+    color: [number, number, number];
+}
+export interface ColorOptions {
+    default?: [number, number, number];
+    byText?: {
+        [text: string]: [number, number, number];
+    };
+    byCharRange?: ColorByRange[];
+}
+export interface ColoredRange {
+    start: number;
+    end: number;
+    originalText: string;
+    color: [number, number, number];
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }[];
+    glyphs: GlyphGeometryInfo[];
+    lineIndices: number[];
+}
+export 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;
+}
+export interface HyphenationPatternsMap {
+    [language: string]: HyphenationTrieNode;
+}
+export interface CurveFidelityConfig {
+    distanceTolerance?: number;
+    angleTolerance?: number;
+}
+export interface GeometryOptimizationOptions {
+    enabled?: boolean;
+    areaThreshold?: number;
+}
+export 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;
+}

package/dist/hyphenation/HyphenationPatternLoader.d.ts

@@ -0,0 +1,2 @@
+import { HyphenationTrieNode } from './types';
+export declare function loadPattern(language: string, patternsPath?: string): Promise<HyphenationTrieNode>;

package/dist/hyphenation/index.d.ts

@@ -0,0 +1,7 @@
+export interface HyphenationTrieNode {
+    patterns: number[] | null;
+    children: {
+        [char: string]: HyphenationTrieNode;
+    };
+}
+export { loadPattern } from './HyphenationPatternLoader';

package/dist/hyphenation/types.d.ts

@@ -0,0 +1,6 @@
+export interface HyphenationTrieNode {
+    patterns: number[] | null;
+    children: {
+        [key: string]: HyphenationTrieNode;
+    };
+}

package/dist/index.cjs

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.4.8
+ * three-text v0.4.9
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -2005,7 +2005,7 @@ class WoffConverter {
         }
         if (!woff2Decoder) {
             throw new Error('WOFF2 fonts require enabling the decoder. Add to your code:\n' +
-                "  import { woff2Decode } from 'woff2-decode';\n" +
+                "  import { woff2Decode } from 'woff-lib/woff2/decode';\n" +
                 '  Text.enableWoff2(woff2Decode);');
         }
         const decoded = await woff2Decoder(woff2Buffer);
@@ -5602,8 +5602,7 @@ class Text {
     static { this.fontCacheMemoryBytes = 0; }
     static { this.maxFontCacheMemoryBytes = Infinity; }
     static { this.fontIdCounter = 0; }
-    // Enable WOFF2 font support (adds ~45KB to bundle if imported)
-    // Usage: import { woff2Decode } from 'woff2-decode'; Text.enableWoff2(woff2Decode);
+    // Enable WOFF2 font support
     static enableWoff2(decoder) {
         setWoff2Decoder(decoder);
     }

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.4.8
+ * three-text v0.4.9
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -2002,7 +2002,7 @@ class WoffConverter {
         }
         if (!woff2Decoder) {
             throw new Error('WOFF2 fonts require enabling the decoder. Add to your code:\n' +
-                "  import { woff2Decode } from 'woff2-decode';\n" +
+                "  import { woff2Decode } from 'woff-lib/woff2/decode';\n" +
                 '  Text.enableWoff2(woff2Decode);');
         }
         const decoded = await woff2Decoder(woff2Buffer);
@@ -5599,8 +5599,7 @@ class Text {
     static { this.fontCacheMemoryBytes = 0; }
     static { this.maxFontCacheMemoryBytes = Infinity; }
     static { this.fontIdCounter = 0; }
-    // Enable WOFF2 font support (adds ~45KB to bundle if imported)
-    // Usage: import { woff2Decode } from 'woff2-decode'; Text.enableWoff2(woff2Decode);
+    // Enable WOFF2 font support
     static enableWoff2(decoder) {
         setWoff2Decoder(decoder);
     }

package/dist/index.min.cjs

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.4.8
+ * three-text v0.4.9
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -307,7 +307,7 @@ if(n.byteLength!==t.Be)throw Error(`Decompression failed: expected ${t.Be} bytes
 return new Uint8Array(n)}))
 for(let t=0;s>t;t++){const e=l[t],i=12+16*t
 a.setUint32(i,e.tag),a.setUint32(i+4,e.t),a.setUint32(i+8,c),a.setUint32(i+12,e.Be),o.set(u[t],c),c+=e.Be,c+=(4-e.Be%4)%4}return o.buffer.slice(0,c)}static async Ne(t){if(new DataView(t).getUint32(0)!==C)throw Error("Not a valid WOFF2 font")
-if(!V)throw Error("WOFF2 fonts require enabling the decoder. Add to your code:\n  import { woff2Decode } from 'woff2-decode';\n  Text.enableWoff2(woff2Decode);")
+if(!V)throw Error("WOFF2 fonts require enabling the decoder. Add to your code:\n  import { woff2Decode } from 'woff-lib/woff2/decode';\n  Text.enableWoff2(woff2Decode);")
 return(await V(t)).buffer}static async Ue(t){const e=new ReadableStream({start(e){e.enqueue(t),e.close()}}).pipeThrough(new DecompressionStream("deflate"))
 return new Response(e).arrayBuffer()}}class Y{constructor(t){this.$e=t}async Pe(t,e){if(!t||12>t.byteLength)throw Error("Invalid font buffer: too small to be a valid font file")
 const i=q.ke(t)

package/dist/index.min.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.4.8
+ * three-text v0.4.9
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -306,7 +306,7 @@ if(n.byteLength!==t.Be)throw Error(`Decompression failed: expected ${t.Be} bytes
 return new Uint8Array(n)}))
 for(let t=0;s>t;t++){const e=l[t],i=12+16*t
 a.setUint32(i,e.tag),a.setUint32(i+4,e.t),a.setUint32(i+8,c),a.setUint32(i+12,e.Be),o.set(u[t],c),c+=e.Be,c+=(4-e.Be%4)%4}return o.buffer.slice(0,c)}static async Ue(t){if(new DataView(t).getUint32(0)!==C)throw Error("Not a valid WOFF2 font")
-if(!V)throw Error("WOFF2 fonts require enabling the decoder. Add to your code:\n  import { woff2Decode } from 'woff2-decode';\n  Text.enableWoff2(woff2Decode);")
+if(!V)throw Error("WOFF2 fonts require enabling the decoder. Add to your code:\n  import { woff2Decode } from 'woff-lib/woff2/decode';\n  Text.enableWoff2(woff2Decode);")
 return(await V(t)).buffer}static async Ne(t){const e=new ReadableStream({start(e){e.enqueue(t),e.close()}}).pipeThrough(new DecompressionStream("deflate"))
 return new Response(e).arrayBuffer()}}class Y{constructor(t){this.$e=t}async Pe(t,e){if(!t||12>t.byteLength)throw Error("Invalid font buffer: too small to be a valid font file")
 const i=q.ke(t)

package/dist/index.umd.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.4.8
+ * three-text v0.4.9
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -12,10 +12,10 @@
  * This software includes third-party code - see LICENSE_THIRD_PARTY for details.
  */
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ThreeText = {}));
-})(this, (function (exports) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('three')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'three'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ThreeText = {}, global.THREE));
+})(this, (function (exports, three) {
     // Cached flag check at module load time for zero-cost logging
     const isLogEnabled = (() => {
         if (typeof window !== 'undefined' && window.THREE_TEXT_LOG) {
@@ -2007,7 +2007,7 @@
             }
             if (!woff2Decoder) {
                 throw new Error('WOFF2 fonts require enabling the decoder. Add to your code:\n' +
-                    "  import { woff2Decode } from 'woff2-decode';\n" +
+                    "  import { woff2Decode } from 'woff-lib/woff2/decode';\n" +
                     '  Text.enableWoff2(woff2Decode);');
             }
             const decoded = await woff2Decoder(woff2Buffer);
@@ -2434,9 +2434,6 @@
         return `${fontId}_${glyphId}_${roundedDepth}_${removeOverlaps}`;
     }
     const globalGlyphCache = new Cache();
-    function createGlyphCache() {
-        return new Cache();
-    }
     const globalContourCache = new Cache();
     const globalWordCache = new Cache();
     const globalClusteringCache = new Cache();
@@ -5599,15 +5596,14 @@
 
     const DEFAULT_MAX_TEXT_LENGTH = 100000;
     const DEFAULT_FONT_SIZE = 72;
-    class Text {
+    let Text$1 = class Text {
         static { this.patternCache = new Map(); }
         static { this.hbInitPromise = null; }
         static { this.fontCache = new Map(); }
         static { this.fontCacheMemoryBytes = 0; }
         static { this.maxFontCacheMemoryBytes = Infinity; }
         static { this.fontIdCounter = 0; }
-        // Enable WOFF2 font support (adds ~45KB to bundle if imported)
-        // Usage: import { woff2Decode } from 'woff2-decode'; Text.enableWoff2(woff2Decode);
+        // Enable WOFF2 font support
         static enableWoff2(decoder) {
             setWoff2Decoder(decoder);
         }
@@ -6348,12 +6344,63 @@
                 this.textShaper = undefined;
             }
         }
+    };
+
+    // Three.js adapter - wraps core text processing and returns BufferGeometry
+    // This is a thin convenience layer for Three.js users
+    function convertToThree(result) {
+        // Create BufferGeometry from raw arrays
+        const geometry = new three.BufferGeometry();
+        geometry.setAttribute('position', new three.Float32BufferAttribute(result.vertices, 3));
+        geometry.setAttribute('normal', new three.Float32BufferAttribute(result.normals, 3));
+        geometry.setIndex(new three.Uint32BufferAttribute(result.indices, 1));
+        // Add optional color attribute (only if provided)
+        if (result.colors) {
+            geometry.setAttribute('color', new three.Float32BufferAttribute(result.colors, 3));
+        }
+        if (result.glyphAttributes) {
+            geometry.setAttribute('glyphCenter', new three.Float32BufferAttribute(result.glyphAttributes.glyphCenter, 3));
+            geometry.setAttribute('glyphIndex', new three.Float32BufferAttribute(result.glyphAttributes.glyphIndex, 1));
+            geometry.setAttribute('glyphLineIndex', new three.Float32BufferAttribute(result.glyphAttributes.glyphLineIndex, 1));
+            geometry.setAttribute('glyphProgress', new three.Float32BufferAttribute(result.glyphAttributes.glyphProgress, 1));
+            geometry.setAttribute('glyphBaselineY', new three.Float32BufferAttribute(result.glyphAttributes.glyphBaselineY, 1));
+        }
+        geometry.computeBoundingBox();
+        // Return Three.js specific interface with utility methods
+        return {
+            geometry,
+            glyphs: result.glyphs,
+            planeBounds: result.planeBounds,
+            stats: result.stats,
+            query: result.query,
+            coloredRanges: result.coloredRanges,
+            // Pass through utility methods from core
+            getLoadedFont: result.getLoadedFont,
+            getCacheSize: result.getCacheSize,
+            clearCache: result.clearCache,
+            measureTextWidth: result.measureTextWidth,
+            update: async (newOptions) => {
+                const newCoreResult = await result.update(newOptions);
+                return convertToThree(newCoreResult);
+            }
+        };
+    }
+    class Text {
+        // Delegate static methods to core
+        static { this.setHarfBuzzPath = Text$1.setHarfBuzzPath; }
+        static { this.setHarfBuzzBuffer = Text$1.setHarfBuzzBuffer; }
+        static { this.init = Text$1.init; }
+        static { this.registerPattern = Text$1.registerPattern; }
+        static { this.preloadPatterns = Text$1.preloadPatterns; }
+        static { this.setMaxFontCacheMemoryMB = Text$1.setMaxFontCacheMemoryMB; }
+        static { this.enableWoff2 = Text$1.enableWoff2; }
+        // Main API - wraps core result in BufferGeometry
+        static async create(options) {
+            const coreResult = await Text$1.create(options);
+            return convertToThree(coreResult);
+        }
     }
 
-    exports.DEFAULT_CURVE_FIDELITY = DEFAULT_CURVE_FIDELITY;
-    exports.FontMetadataExtractor = FontMetadataExtractor;
     exports.Text = Text;
-    exports.createGlyphCache = createGlyphCache;
-    exports.globalGlyphCache = globalGlyphCache;
 
 }));