three-text 0.5.0 → 0.5.2

package/dist/three/index.cjs

@@ -55,7 +55,8 @@ function buildThreeResult(layoutHandle, meshPipeline, options) {
         getCacheSize: () => meshPipeline.getCacheSize(),
         clearCache: () => meshPipeline.clearCache(),
         measureTextWidth: (text, letterSpacing) => layoutHandle.measureTextWidth(text, letterSpacing),
-        update
+        update,
+        dispose: () => layoutHandle.dispose()
     };
 }
 class Text {

package/dist/three/index.d.ts

@@ -17,6 +17,7 @@ interface ThreeTextGeometryInfo extends Omit<TextGeometryInfo, 'vertices' | 'nor
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<ThreeTextGeometryInfo>;
+    dispose(): void;
 }
 declare class Text {
     static setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;

package/dist/three/index.js

@@ -53,7 +53,8 @@ function buildThreeResult(layoutHandle, meshPipeline, options) {
         getCacheSize: () => meshPipeline.getCacheSize(),
         clearCache: () => meshPipeline.clearCache(),
         measureTextWidth: (text, letterSpacing) => layoutHandle.measureTextWidth(text, letterSpacing),
-        update
+        update,
+        dispose: () => layoutHandle.dispose()
     };
 }
 class Text {

package/dist/three/react.cjs

@@ -69,7 +69,12 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
     const { children, font, material, position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1], onLoad, onError, vertexColors = true, ...restOptions } = props;
     const [geometry, setGeometry] = react.useState(null);
     const [error, setError] = react.useState(null);
-    const geometryRef = react.useRef(null);
+    const textRef = react.useRef(null);
+    const opRef = react.useRef(Promise.resolve(null));
+    const onLoadRef = react.useRef(onLoad);
+    const onErrorRef = react.useRef(onError);
+    onLoadRef.current = onLoad;
+    onErrorRef.current = onError;
     const defaultMaterial = react.useMemo(() => {
         return new THREE__namespace.MeshBasicMaterial({
             color: 0xffffff,
@@ -86,29 +91,42 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
                 setError(null);
                 if (cancelled)
                     return;
-                const text = await index.Text.create({
-                    text: children,
-                    font,
-                    ...memoizedTextOptions
+                const textPromise = opRef.current.catch(() => null).then(() => {
+                    if (cancelled)
+                        return null;
+                    return textRef.current
+                        ? textRef.current.update({
+                            text: children,
+                            font,
+                            ...memoizedTextOptions
+                        })
+                        : index.Text.create({
+                            text: children,
+                            font,
+                            ...memoizedTextOptions
+                        });
                 });
+                opRef.current = textPromise.catch(() => null);
+                const text = await textPromise;
+                if (!text)
+                    return;
                 if (cancelled) {
-                    // If a newer render superseded this request, avoid leaking geometry
-                    text.geometry.dispose();
+                    text.dispose();
                     return;
                 }
-                // Dispose previous geometry (if any) before swapping
-                geometryRef.current?.dispose();
-                geometryRef.current = text.geometry;
+                const prev = textRef.current;
+                textRef.current = text;
                 setGeometry(text.geometry);
-                if (onLoad)
-                    onLoad(text.geometry, text);
+                if (onLoadRef.current)
+                    onLoadRef.current(text.geometry, text);
+                requestAnimationFrame(() => prev?.dispose());
             }
             catch (err) {
                 const error = err;
                 if (!cancelled) {
                     setError(error);
-                    if (onError)
-                        onError(error);
+                    if (onErrorRef.current)
+                        onErrorRef.current(error);
                     else
                         console.error('ThreeText error:', error);
                 }
@@ -118,12 +136,12 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
         return () => {
             cancelled = true;
         };
-    }, [font, children, memoizedTextOptions, onLoad, onError]);
+    }, [font, children, memoizedTextOptions]);
     // Cleanup geometry on unmount
     react.useEffect(() => {
         return () => {
-            geometryRef.current?.dispose();
-            geometryRef.current = null;
+            textRef.current?.dispose();
+            textRef.current = null;
         };
     }, []);
     // Cleanup default material when it changes or on unmount

package/dist/three/react.d.ts

@@ -255,6 +255,8 @@ 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;
@@ -263,6 +265,7 @@ declare class Text$1 {
     private fontLoader;
     private loadedFont?;
     private currentFontId;
+    private currentFontCacheKey?;
     private textShaper?;
     private textLayout?;
     private constructor();
@@ -270,6 +273,8 @@ declare class Text$1 {
     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;
@@ -277,6 +282,7 @@ declare class Text$1 {
     private static enforceFontCacheMemoryLimit;
     private static generateFontContentHash;
     private setLoadedFont;
+    private releaseCurrentFont;
     private loadFont;
     private createLayout;
     private prepareHyphenation;

package/dist/three/react.js

@@ -48,7 +48,12 @@ const Text$1 = forwardRef(function Text(props, ref) {
     const { children, font, material, position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1], onLoad, onError, vertexColors = true, ...restOptions } = props;
     const [geometry, setGeometry] = useState(null);
     const [error, setError] = useState(null);
-    const geometryRef = useRef(null);
+    const textRef = useRef(null);
+    const opRef = useRef(Promise.resolve(null));
+    const onLoadRef = useRef(onLoad);
+    const onErrorRef = useRef(onError);
+    onLoadRef.current = onLoad;
+    onErrorRef.current = onError;
     const defaultMaterial = useMemo(() => {
         return new THREE.MeshBasicMaterial({
             color: 0xffffff,
@@ -65,29 +70,42 @@ const Text$1 = forwardRef(function Text(props, ref) {
                 setError(null);
                 if (cancelled)
                     return;
-                const text = await Text$2.create({
-                    text: children,
-                    font,
-                    ...memoizedTextOptions
+                const textPromise = opRef.current.catch(() => null).then(() => {
+                    if (cancelled)
+                        return null;
+                    return textRef.current
+                        ? textRef.current.update({
+                            text: children,
+                            font,
+                            ...memoizedTextOptions
+                        })
+                        : Text$2.create({
+                            text: children,
+                            font,
+                            ...memoizedTextOptions
+                        });
                 });
+                opRef.current = textPromise.catch(() => null);
+                const text = await textPromise;
+                if (!text)
+                    return;
                 if (cancelled) {
-                    // If a newer render superseded this request, avoid leaking geometry
-                    text.geometry.dispose();
+                    text.dispose();
                     return;
                 }
-                // Dispose previous geometry (if any) before swapping
-                geometryRef.current?.dispose();
-                geometryRef.current = text.geometry;
+                const prev = textRef.current;
+                textRef.current = text;
                 setGeometry(text.geometry);
-                if (onLoad)
-                    onLoad(text.geometry, text);
+                if (onLoadRef.current)
+                    onLoadRef.current(text.geometry, text);
+                requestAnimationFrame(() => prev?.dispose());
             }
             catch (err) {
                 const error = err;
                 if (!cancelled) {
                     setError(error);
-                    if (onError)
-                        onError(error);
+                    if (onErrorRef.current)
+                        onErrorRef.current(error);
                     else
                         console.error('ThreeText error:', error);
                 }
@@ -97,12 +115,12 @@ const Text$1 = forwardRef(function Text(props, ref) {
         return () => {
             cancelled = true;
         };
-    }, [font, children, memoizedTextOptions, onLoad, onError]);
+    }, [font, children, memoizedTextOptions]);
     // Cleanup geometry on unmount
     useEffect(() => {
         return () => {
-            geometryRef.current?.dispose();
-            geometryRef.current = null;
+            textRef.current?.dispose();
+            textRef.current = null;
         };
     }, []);
     // Cleanup default material when it changes or on unmount

package/dist/types/core/Text.d.ts

@@ -10,6 +10,8 @@ export declare class Text {
     private static patternCache;
     private static hbInitPromise;
     private static fontCache;
+    private static fontLoadPromises;
+    private static fontRefCounts;
     private static fontCacheMemoryBytes;
     private static maxFontCacheMemoryBytes;
     private static fontIdCounter;
@@ -18,6 +20,7 @@ export declare class Text {
     private fontLoader;
     private loadedFont?;
     private currentFontId;
+    private currentFontCacheKey?;
     private textShaper?;
     private textLayout?;
     private constructor();
@@ -25,6 +28,8 @@ export declare class Text {
     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;
@@ -32,6 +37,7 @@ export declare class Text {
     private static enforceFontCacheMemoryLimit;
     private static generateFontContentHash;
     private setLoadedFont;
+    private releaseCurrentFont;
     private loadFont;
     private createLayout;
     private prepareHyphenation;

package/dist/types/three/index.d.ts

@@ -9,6 +9,7 @@ export interface ThreeTextGeometryInfo extends Omit<CoreTextGeometryInfo, 'verti
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<ThreeTextGeometryInfo>;
+    dispose(): void;
 }
 export declare class Text {
     static setHarfBuzzPath: typeof TextCore.setHarfBuzzPath;

package/dist/types/vector/core.d.ts

@@ -0,0 +1,27 @@
+import { Text as TextCore } from '../core/Text';
+import type { TextOptions, VectorGlyphInfo, LoadedFont, TextQueryOptions, TextRange } from '../core/types';
+import type { VectorGeometryData } from './LoopBlinnGeometry';
+import type { HyphenationTrieNode } from '../hyphenation';
+export 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;
+}
+export declare class Text {
+    static setHarfBuzzPath: typeof TextCore.setHarfBuzzPath;
+    static setHarfBuzzBuffer: typeof TextCore.setHarfBuzzBuffer;
+    static init: typeof TextCore.init;
+    static registerPattern: typeof TextCore.registerPattern;
+    static preloadPatterns: typeof TextCore.preloadPatterns;
+    static setMaxFontCacheMemoryMB: typeof TextCore.setMaxFontCacheMemoryMB;
+    static enableWoff2: typeof TextCore.enableWoff2;
+    static create(options: TextOptions): Promise<VectorTextResult>;
+}
+export type { TextOptions, VectorTextResult as TextGeometryInfo, VectorGlyphInfo, LoadedFont };
+export type { HyphenationTrieNode };
+export { buildVectorGeometry, extractContours } from './LoopBlinnGeometry';
+export type { VectorGeometryData, VectorGlyphAttributes, GlyphRange, VectorContour, LoopBlinnInput, LoopBlinnGlyphInput, QuadraticSegment } from './LoopBlinnGeometry';

package/dist/types/vector/index.d.ts

@@ -1,29 +1,35 @@
-import { Text as TextCore } from '../core/Text';
-import type { TextOptions, VectorGlyphInfo, LoadedFont, TextQueryOptions, TextRange } from '../core/types';
-import type { VectorGeometryData } from './LoopBlinnGeometry';
-import type { HyphenationTrieNode } from '../hyphenation';
-export 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;
+import { type VectorTextResult } from './core';
+import { createVectorMeshes, loopBlinnFragment, type VectorMeshes, type VectorMeshOptions } from './loopBlinnTSL';
+import type { TextOptions } from '../core/types';
+export interface VectorTextOptions extends TextOptions {
+    color?: any;
+    positionNode?: any;
+    colorNode?: any;
+    center?: boolean;
+}
+export interface VectorResult extends VectorTextResult {
+    group: import('three').Group;
+    interiorGeometry: import('three').BufferGeometry;
+    curveGeometry: import('three').BufferGeometry;
+    fillGeometry: import('three').BufferGeometry;
+    updateMaterials(options?: VectorMeshOptions): void;
+    update(newOptions: Partial<VectorTextOptions>): Promise<VectorResult>;
 }
 export declare class Text {
-    static setHarfBuzzPath: typeof TextCore.setHarfBuzzPath;
-    static setHarfBuzzBuffer: typeof TextCore.setHarfBuzzBuffer;
-    static init: typeof TextCore.init;
-    static registerPattern: typeof TextCore.registerPattern;
-    static preloadPatterns: typeof TextCore.preloadPatterns;
-    static setMaxFontCacheMemoryMB: typeof TextCore.setMaxFontCacheMemoryMB;
-    static enableWoff2: typeof TextCore.enableWoff2;
-    static create(options: TextOptions): Promise<VectorTextResult>;
+    static setHarfBuzzPath: typeof import("..").Text.setHarfBuzzPath;
+    static setHarfBuzzBuffer: typeof import("..").Text.setHarfBuzzBuffer;
+    static init: typeof import("..").Text.init;
+    static registerPattern: typeof import("..").Text.registerPattern;
+    static preloadPatterns: typeof import("..").Text.preloadPatterns;
+    static setMaxFontCacheMemoryMB: typeof import("..").Text.setMaxFontCacheMemoryMB;
+    static enableWoff2: typeof import("..").Text.enableWoff2;
+    static create(options: VectorTextOptions): Promise<VectorResult>;
 }
-export type { TextOptions, VectorTextResult as TextGeometryInfo, VectorGlyphInfo, LoadedFont };
-export type { HyphenationTrieNode };
+export { createVectorMeshes, loopBlinnFragment };
+export type { VectorMeshes, VectorMeshOptions };
+export type { VectorTextResult } from './core';
 export { buildVectorGeometry, extractContours } from './LoopBlinnGeometry';
+export type { TextOptions } from '../core/types';
 export type { VectorGeometryData, VectorGlyphAttributes, GlyphRange, VectorContour, LoopBlinnInput, LoopBlinnGlyphInput, QuadraticSegment } from './LoopBlinnGeometry';
-export { createVectorMeshes } from './loopBlinnTSL';
-export type { VectorMeshes } from './loopBlinnTSL';
+export type { VectorGlyphInfo, LoadedFont } from '../core/types';
+export type { HyphenationTrieNode } from '../hyphenation';

package/dist/types/vector/loopBlinnTSL.d.ts

@@ -1,11 +1,22 @@
 import * as THREE from 'three';
 import type { VectorGeometryData } from './LoopBlinnGeometry';
+export interface VectorMeshOptions {
+    color?: THREE.ColorRepresentation;
+    positionNode?: any;
+    colorNode?: any;
+    center?: boolean;
+}
 export 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;
 }
 export declare const loopBlinnFragment: any;
-export declare function createVectorMeshes(data: VectorGeometryData, color?: THREE.ColorRepresentation): VectorMeshes;
+export declare function createVectorMeshes(data: VectorGeometryData, options?: VectorMeshOptions | THREE.ColorRepresentation): VectorMeshes;

package/dist/types/vector/react.d.ts

@@ -1,15 +1,13 @@
 import * as THREE from 'three';
-import { Text as VectorTextCore } from './index';
-import type { VectorTextResult } from './index';
-import type { TextOptions } from '../core/types';
-export interface TextProps extends Omit<TextOptions, 'text' | 'color'> {
+import { Text as VectorText, type VectorResult, type VectorTextOptions } from './index';
+export interface TextProps extends Omit<VectorTextOptions, 'text' | 'color'> {
     children: string;
     font: string | ArrayBuffer;
     fillColor?: THREE.ColorRepresentation;
     position?: [number, number, number];
     rotation?: [number, number, number];
     scale?: [number, number, number];
-    onLoad?: (result: VectorTextResult) => void;
+    onLoad?: (result: VectorResult) => void;
     onError?: (error: Error) => void;
 }
 export declare const Text: import("react").ForwardRefExoticComponent<TextProps & import("react").RefAttributes<THREE.Group<THREE.Object3DEventMap>>> & {
@@ -20,5 +18,5 @@ export declare const Text: import("react").ForwardRefExoticComponent<TextProps &
     preloadPatterns: typeof import("..").Text.preloadPatterns;
     setMaxFontCacheMemoryMB: typeof import("..").Text.setMaxFontCacheMemoryMB;
     enableWoff2: typeof import("..").Text.enableWoff2;
-    create: typeof VectorTextCore.create;
+    create: typeof VectorText.create;
 };

package/dist/vector/all.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var index = require('./index.cjs');
+var loopBlinnTSL = require('./loopBlinnTSL.cjs');
+
+
+
+Object.defineProperty(exports, 'createVectorMeshes', {
+	enumerable: true,
+	get: function () { return loopBlinnTSL.createVectorMeshes; }
+});
+Object.defineProperty(exports, 'loopBlinnFragment', {
+	enumerable: true,
+	get: function () { return loopBlinnTSL.loopBlinnFragment; }
+});
+Object.keys(index).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return index[k]; }
+	});
+});

package/dist/vector/all.d.ts

@@ -0,0 +1,134 @@
+import { Text as Text$1 } from '../core/Text';
+import { VectorGlyphInfo, TextQueryOptions, TextRange, LoadedFont, TextOptions } from '../core/types';
+export { LoadedFont, TextOptions, VectorGlyphInfo } from '../core/types';
+import * as THREE from 'three';
+
+interface BoundingBox {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+
+interface QuadraticSegment {
+    p0x: number;
+    p0y: number;
+    p1x: number;
+    p1y: number;
+    p2x: number;
+    p2y: number;
+}
+interface ContourVertex {
+    x: number;
+    y: 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 LoopBlinnGlyphInput {
+    offsetX: number;
+    offsetY: number;
+    segments: QuadraticSegment[];
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    lineIndex: number;
+    baselineY: number;
+}
+interface LoopBlinnInput {
+    glyphs: LoopBlinnGlyphInput[];
+    planeBounds: BoundingBox;
+}
+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 | undefined;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    update(options: Partial<TextOptions>): Promise<VectorTextResult>;
+    dispose(): void;
+}
+declare class Text {
+    static setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;
+    static setHarfBuzzBuffer: typeof Text$1.setHarfBuzzBuffer;
+    static init: typeof Text$1.init;
+    static registerPattern: typeof Text$1.registerPattern;
+    static preloadPatterns: typeof Text$1.preloadPatterns;
+    static setMaxFontCacheMemoryMB: typeof Text$1.setMaxFontCacheMemoryMB;
+    static enableWoff2: typeof Text$1.enableWoff2;
+    static create(options: TextOptions): Promise<VectorTextResult>;
+}
+
+interface VectorMeshOptions {
+    color?: THREE.ColorRepresentation;
+    positionNode?: any;
+    colorNode?: any;
+    center?: boolean;
+}
+interface VectorMeshes {
+    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 const loopBlinnFragment: any;
+declare function createVectorMeshes(data: VectorGeometryData, options?: VectorMeshOptions | THREE.ColorRepresentation): VectorMeshes;
+
+export { GlyphRange, HyphenationTrieNode, LoopBlinnGlyphInput, LoopBlinnInput, QuadraticSegment, Text, VectorTextResult as TextGeometryInfo, VectorContour, VectorGeometryData, VectorGlyphAttributes, VectorMeshOptions, VectorMeshes, VectorTextResult, buildVectorGeometry, createVectorMeshes, extractContours, loopBlinnFragment };

package/dist/vector/all.js

@@ -0,0 +1,2 @@
+export * from './index.js';
+export { createVectorMeshes, loopBlinnFragment } from './loopBlinnTSL.js';