@mlightcad/mtext-renderer 0.4.4 → 0.4.6

package/{dist → lib}/font/baseFont.d.ts

@@ -1,4 +1,5 @@
 import { BaseTextShape } from './baseTextShape';
+import { CharGeometryCache } from './charGeometryCache';
 import { FontType } from './font';
 
 /**
@@ -14,6 +15,17 @@ export declare abstract class BaseFont {
      * This data is used to render characters and calculate metrics.
      */
     abstract readonly data: unknown;
+    /**
+     * Caching of font character geometries to improve text rendering performance.
+     */
+    cache: CharGeometryCache;
+    constructor();
+    /**
+     * Return true if this font contains glyph of the specified character. Otherwise, return false.
+     * @param char - The character to check
+     * @returns True if this font contains glyph of the specified character. Otherwise, return false.
+     */
+    abstract hasChar(char: string): boolean;
     /**
      * Record of characters that are not supported by this font.
      * Maps character strings to their occurrence count.

package/lib/font/charGeometryCache.d.ts

@@ -0,0 +1,43 @@
+import * as THREE from 'three';
+/**
+ * Manages caching of font character geometries to improve text rendering performance.
+ */
+export declare class CharGeometryCache {
+    private cache;
+    constructor();
+    /**
+     * Returns true if the geometry of the specified character exists in the cache.
+     * Otherwise, returns false.
+     * @param char One character.
+     * @param size The font size.
+     * @returns True if the geometry of the specified character exists in the cache.
+     * Otherwise, returns false.
+     */
+    hasGeometry(char: string, size: number): boolean;
+    /**
+     * Get the geometry for a single character from cache if available.
+     * The cache key includes both character and size.
+     * @param char The character to get geometry from cache.
+     * @param size The font size.
+     * @returns The geometry for a single character from cache if avaiable.
+     * Return undefined if the character not found in cache.
+     */
+    getGeometry(char: string, size: number): THREE.BufferGeometry | undefined;
+    /**
+     * Set the geometry to cache for a single character.
+     * @param char The character to set geometry for.
+     * @param size The font size.
+     * @param geometry The geometry to set.
+     */
+    setGeometry(char: string, size: number, geometry: THREE.BufferGeometry): void;
+    /**
+     * Dispose all cached geometries.
+     */
+    dispose(): void;
+    /**
+     * Generates cache key by character and font size.
+     * @param char One character.
+     * @param size The font size.
+     */
+    private generateKey;
+}

package/{dist → lib}/font/fontManager.d.ts

@@ -76,6 +76,22 @@ export declare class FontManager {
      * @returns The original font name if found, or the replacement font name if not found
      */
     findAndReplaceFont(fontName: string): string;
+    /**
+     * Gets font by font name. Return undefined if not found.
+     * @param fontName - The font name to find
+     * @param recordMissedFonts - Record the font name to property `missedFonts` in this class
+     * if the specified font name not found.
+     * @returns The font with the specified font name, or undefined if not found
+     */
+    getFontByName(fontName: string, recordMissedFonts?: boolean): BaseFont | undefined;
+    /**
+     * Gets the first font which contains the specified character.
+     * @param char - The character to get the shape for
+     * @param fontName - The name of the font to use
+     * @param size - The size of the character
+     * @returns The text shape for the character, or undefined if not found
+     */
+    getFontByChar(char: string): BaseFont | undefined;
     /**
      * Gets the text shape for a specific character with the specified font and size
      * @param char - The character to get the shape for

package/{dist → lib}/font/meshFont.d.ts

@@ -29,6 +29,12 @@ export declare class MeshFont extends BaseFont {
      * @param data - Either a MeshFontData object containing font information or an ArrayBuffer containing raw font data
      */
     constructor(data: MeshFontData | ArrayBuffer);
+    /**
+     * Return true if this font contains glyph of the specified character. Otherwise, return false.
+     * @param char - The character to check
+     * @returns True if this font contains glyph of the specified character. Otherwise, return false.
+     */
+    hasChar(char: string): boolean;
     /**
      * Generates shapes for a text string
      * @param text - The text to generate shapes for

package/{dist → lib}/font/shxFont.d.ts

@@ -12,6 +12,12 @@ export declare class ShxFont extends BaseFont {
     readonly type = "shx";
     readonly data: ShxFontData;
     constructor(data: ShxFontData | ArrayBuffer);
+    /**
+     * Return true if this font contains glyph of the specified character. Otherwise, return false.
+     * @param char - The character to check
+     * @returns True if this font contains glyph of the specified character. Otherwise, return false.
+     */
+    hasChar(char: string): boolean;
     generateShapes(text: string, size: number): ShxTextShape[];
     /**
      * SHX font always has fixed scale factor 1.

package/{dist → lib}/font/shxTextShape.d.ts

@@ -1,5 +1,6 @@
 import { Point, ShxShape } from '@mlightcad/shx-parser';
 import { BaseTextShape } from './baseTextShape';
+import { ShxFont } from './shxFont';
 
 import * as THREE from 'three';
 /**
@@ -10,12 +11,14 @@ import * as THREE from 'three';
 export declare class ShxTextShape extends BaseTextShape {
     /** The shape data for this character */
     private readonly shape;
+    private readonly font;
+    private readonly fontSize;
     /**
      * Creates a new instance of ShxTextShape
      * @param char - The character this shape represents
      * @param shape - The shape data for this character
      */
-    constructor(char: string, shape: ShxShape);
+    constructor(char: string, fontSize: number, shape: ShxShape, font: ShxFont);
     protected calcWidth(): number;
     offset(offset: Point): ShxTextShape;
     /**

package/{dist → lib}/index.d.ts

@@ -1,3 +1,4 @@
 export * from './common/eventManager';
 export * from './font';
 export * from './renderer';
+export * from './worker';

package/lib/worker/base-renderer.d.ts

@@ -0,0 +1,50 @@
+import { MTextData, TextStyle, ColorSettings } from '../renderer/types';
+import * as THREE from 'three';
+/**
+ * Defines the common rendering contract for producing Three.js objects from MText content.
+ *
+ * Implementations may render on the main thread or delegate work to a Web Worker,
+ * but they must expose the same high-level API so callers can switch strategies
+ * without changing usage.
+ */
+export interface MTextBaseRenderer {
+    /**
+     * Render the provided MText content into a Three.js object hierarchy.
+     *
+     * The returned root object contains meshes/lines for glyphs and exposes a
+     * bounding box on `object.box` if available.
+     *
+     * @param mtextContent Structured MText input (text, height, width, position).
+     * @param textStyle Text style to apply (font, width factor, oblique, etc.).
+     * @param colorSettings Optional color context (ByLayer, ByBlock colors).
+     * @returns A Promise resolving to a populated `THREE.Object3D` ready to add to a scene.
+     */
+    renderMText(mtextContent: MTextData, textStyle: TextStyle, colorSettings?: ColorSettings): Promise<THREE.Object3D>;
+    /**
+     * Ensure the specified fonts are available to the renderer.
+     *
+     * Implementations should load and cache missing fonts; repeated calls should be cheap.
+     *
+     * @param fonts Font names to load (without extension for built-ins).
+     * @returns A Promise with the list of fonts that were processed.
+     */
+    loadFonts(fonts: string[]): Promise<{
+        loaded: string[];
+    }>;
+    /**
+     * Retrieve the list of fonts that can be used by the renderer.
+     *
+     * The shape of each font entry is implementation-defined but should include a displayable name.
+     *
+     * @returns A Promise with available font metadata.
+     */
+    getAvailableFonts(): Promise<{
+        fonts: any[];
+    }>;
+    /**
+     * Release any resources owned by the renderer (e.g., terminate Web Workers).
+     *
+     * Safe to call multiple times.
+     */
+    destroy(): void;
+}

package/lib/worker/baseRenderer.d.ts

@@ -0,0 +1,64 @@
+import { MTextData, TextStyle, ColorSettings } from '../renderer/types';
+import * as THREE from 'three';
+/**
+ * Represents a rendered MText object that extends THREE.Object3D with additional MText-specific properties.
+ * This interface defines the contract for objects returned by MText renderers.
+ */
+export interface MTextObject extends THREE.Object3D {
+    /**
+     * The bounding box of the MText object in local coordinates.
+     * This box represents the bounds of the text content without considering transformations.
+     * To get the world-space bounding box, apply the object's world matrix to this box.
+     */
+    box: THREE.Box3;
+}
+/**
+ * Defines the common rendering contract for producing Three.js objects from MText content.
+ *
+ * Implementations may render on the main thread or delegate work to a Web Worker,
+ * but they must expose the same high-level API so callers can switch strategies
+ * without changing usage.
+ */
+export interface MTextBaseRenderer {
+    /**
+     * Render the provided MText content into a Three.js object hierarchy.
+     *
+     * The returned root object contains meshes/lines for glyphs and exposes a
+     * bounding box on `object.box`.
+     *
+     * @param mtextContent Structured MText input (text, height, width, position).
+     * @param textStyle Text style to apply (font, width factor, oblique, etc.).
+     * @param colorSettings Optional color context (ByLayer, ByBlock colors).
+     * @returns A Promise resolving to a populated `MTextObject` ready to add to a scene.
+     */
+    renderMText(mtextContent: MTextData, textStyle: TextStyle, colorSettings?: ColorSettings): Promise<MTextObject>;
+    /**
+     * Ensure the specified fonts are available to the renderer.
+     *
+     * Implementations should load and cache missing fonts; repeated calls should be cheap.
+     *
+     * @param fonts Font names to load (without extension for built-ins).
+     * @returns A Promise with the list of fonts that were processed.
+     */
+    loadFonts(fonts: string[]): Promise<{
+        loaded: string[];
+    }>;
+    /**
+     * Retrieve the list of fonts that can be used by the renderer.
+     *
+     * The shape of each font entry is implementation-defined but should include a displayable name.
+     *
+     * @returns A Promise with available font metadata.
+     */
+    getAvailableFonts(): Promise<{
+        fonts: Array<{
+            name: string[];
+        }>;
+    }>;
+    /**
+     * Release any resources owned by the renderer (e.g., terminate Web Workers).
+     *
+     * Safe to call multiple times.
+     */
+    destroy(): void;
+}

package/lib/worker/index.d.ts

@@ -0,0 +1,6 @@
+export { WebWorkerRenderer as MTextWorkerManager } from './webWorkerRenderer';
+export { MainThreadRenderer } from './mainThreadRenderer';
+export { UnifiedRenderer } from './unifiedRenderer';
+export type { RenderMode } from './unifiedRenderer';
+export type { MTextBaseRenderer as MTextRendererAdapter } from './baseRenderer';
+export type { MTextData, TextStyle, ColorSettings } from '../renderer/types';

package/lib/worker/main-thread-renderer.d.ts

@@ -0,0 +1,30 @@
+import { MTextData, TextStyle, ColorSettings } from '../renderer/types';
+import { MTextBaseRenderer } from './base-renderer';
+import * as THREE from 'three';
+/**
+ * Main thread renderer for MText objects
+ * This provides the same interface as the worker but runs in the main thread
+ */
+export declare class MainThreadRenderer implements MTextBaseRenderer {
+    private fontManager;
+    private styleManager;
+    private fontLoader;
+    constructor();
+    /**
+     * Render MText directly in the main thread
+     */
+    renderMText(mtextContent: MTextData, textStyle: TextStyle, colorSettings?: ColorSettings): Promise<THREE.Object3D>;
+    /**
+     * Load fonts in the main thread
+     */
+    loadFonts(fonts: string[]): Promise<{
+        loaded: string[];
+    }>;
+    /**
+     * Get available fonts from the main thread
+     */
+    getAvailableFonts(): Promise<{
+        fonts: any[];
+    }>;
+    destroy(): void;
+}

package/lib/worker/mainThreadRenderer.d.ts

@@ -0,0 +1,32 @@
+import { MTextData, TextStyle, ColorSettings } from '../renderer/types';
+import { MTextBaseRenderer, MTextObject } from './baseRenderer';
+
+/**
+ * Main thread renderer for MText objects
+ * This provides the same interface as the worker but runs in the main thread
+ */
+export declare class MainThreadRenderer implements MTextBaseRenderer {
+    private fontManager;
+    private styleManager;
+    private fontLoader;
+    constructor();
+    /**
+     * Render MText directly in the main thread
+     */
+    renderMText(mtextContent: MTextData, textStyle: TextStyle, colorSettings?: ColorSettings): Promise<MTextObject>;
+    /**
+     * Load fonts in the main thread
+     */
+    loadFonts(fonts: string[]): Promise<{
+        loaded: string[];
+    }>;
+    /**
+     * Get available fonts from the main thread
+     */
+    getAvailableFonts(): Promise<{
+        fonts: Array<{
+            name: string[];
+        }>;
+    }>;
+    destroy(): void;
+}

package/lib/worker/mtext-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/worker/mtextWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/worker/unified-renderer.d.ts

@@ -0,0 +1,41 @@
+import { MTextData, TextStyle, ColorSettings } from '../renderer/types';
+import * as THREE from 'three';
+export type RenderMode = 'main' | 'worker';
+/**
+ * Unified renderer that can work in both main thread and web worker modes
+ */
+export declare class UnifiedRenderer {
+    private workerManager;
+    private mainThreadRenderer;
+    private adapter;
+    private currentMode;
+    constructor(mode?: RenderMode);
+    /**
+     * Switch between main thread and worker rendering modes
+     */
+    switchMode(mode: RenderMode): void;
+    /**
+     * Get current rendering mode
+     */
+    getMode(): RenderMode;
+    /**
+     * Render MText using the current mode
+     */
+    renderMText(mtextContent: MTextData, textStyle: TextStyle, colorSettings?: ColorSettings): Promise<THREE.Object3D>;
+    /**
+     * Load fonts using the current mode
+     */
+    loadFonts(fonts: string[]): Promise<{
+        loaded: string[];
+    }>;
+    /**
+     * Get available fonts using the current mode
+     */
+    getAvailableFonts(): Promise<{
+        fonts: any[];
+    }>;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+}

package/lib/worker/unifiedRenderer.d.ts

@@ -0,0 +1,44 @@
+import { MTextData, TextStyle, ColorSettings } from '../renderer/types';
+import { MTextObject } from './baseRenderer';
+
+export type RenderMode = 'main' | 'worker';
+/**
+ * Unified renderer that can work in both main thread and web worker modes
+ */
+export declare class UnifiedRenderer {
+    private workerManager;
+    private mainThreadRenderer;
+    private adapter;
+    private currentMode;
+    constructor(mode?: RenderMode);
+    /**
+     * Switch between main thread and worker rendering modes
+     */
+    switchMode(mode: RenderMode): void;
+    /**
+     * Get current rendering mode
+     */
+    getMode(): RenderMode;
+    /**
+     * Render MText using the current mode
+     */
+    renderMText(mtextContent: MTextData, textStyle: TextStyle, colorSettings?: ColorSettings): Promise<MTextObject>;
+    /**
+     * Load fonts using the current mode
+     */
+    loadFonts(fonts: string[]): Promise<{
+        loaded: string[];
+    }>;
+    /**
+     * Get available fonts using the current mode
+     */
+    getAvailableFonts(): Promise<{
+        fonts: Array<{
+            name: string[];
+        }>;
+    }>;
+    /**
+     * Clean up resources
+     */
+    destroy(): void;
+}

package/lib/worker/web-worker-renderer.d.ts

@@ -0,0 +1,115 @@
+import { MTextData, TextStyle, ColorSettings } from '../renderer/types';
+import { MTextBaseRenderer } from './base-renderer';
+import * as THREE from 'three';
+interface SerializedMText {
+    type: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    box: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    children: SerializedChild[];
+}
+interface SerializedChild {
+    type: 'mesh' | 'line';
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    geometry: {
+        attributes: {
+            [key: string]: {
+                arrayBuffer: ArrayBuffer;
+                byteOffset: number;
+                length: number;
+                itemSize: number;
+                normalized: boolean;
+            };
+        };
+        index: {
+            arrayBuffer: ArrayBuffer;
+            byteOffset: number;
+            length: number;
+        } | null;
+    };
+    material: {
+        type: string;
+        color: number;
+        transparent: boolean;
+        opacity: number;
+        side?: number;
+        linewidth?: number;
+    };
+}
+/**
+ * Manages communication with the MText web worker
+ */
+export declare class WebWorkerRenderer implements MTextBaseRenderer {
+    private worker;
+    private pendingRequests;
+    private requestId;
+    constructor();
+    private handleWorkerMessage;
+    private sendMessage;
+    /**
+     * Render MText in the worker and return serialized data
+     */
+    renderMText(mtextContent: MTextData, textStyle: TextStyle, colorSettings?: ColorSettings): Promise<THREE.Object3D>;
+    /**
+     * Load fonts in the worker
+     */
+    loadFonts(fonts: string[]): Promise<{
+        loaded: string[];
+    }>;
+    /**
+     * Get available fonts from the worker
+     */
+    getAvailableFonts(): Promise<{
+        fonts: any[];
+    }>;
+    /**
+     * Reconstruct MText object from JSON serialized data
+     */
+    reconstructMText(serializedData: SerializedMText): THREE.Object3D;
+    /**
+     * Terminate the worker
+     */
+    terminate(): void;
+    destroy(): void;
+}
+export {};

package/lib/worker/webWorkerRenderer.d.ts

@@ -0,0 +1,124 @@
+import { MTextData, TextStyle, ColorSettings } from '../renderer/types';
+import { MTextBaseRenderer, MTextObject } from './baseRenderer';
+
+interface SerializedMText {
+    type: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    box: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    children: SerializedChild[];
+}
+interface SerializedChild {
+    type: 'mesh' | 'line';
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    geometry: {
+        attributes: {
+            [key: string]: {
+                arrayBuffer: ArrayBuffer;
+                byteOffset: number;
+                length: number;
+                itemSize: number;
+                normalized: boolean;
+            };
+        };
+        index: {
+            arrayBuffer: ArrayBuffer;
+            byteOffset: number;
+            length: number;
+            componentType?: 'uint16' | 'uint32';
+        } | null;
+    };
+    material: {
+        type: string;
+        color: number;
+        transparent: boolean;
+        opacity: number;
+        side?: number;
+        linewidth?: number;
+    };
+}
+/**
+ * Manages communication with the MText web worker
+ */
+export declare class WebWorkerRenderer implements MTextBaseRenderer {
+    private workers;
+    private inFlightPerWorker;
+    private pendingRequests;
+    private requestId;
+    private poolSize;
+    private readyPromise;
+    constructor(poolSize?: number);
+    private handleWorkerMessage;
+    private attachWorkerHandlers;
+    private pickLeastLoadedWorker;
+    private sendMessage;
+    private ensureInitialized;
+    /**
+     * Render MText in the worker and return serialized data
+     */
+    renderMText(mtextContent: MTextData, textStyle: TextStyle, colorSettings?: ColorSettings): Promise<MTextObject>;
+    /**
+     * Load fonts in the worker
+     */
+    loadFonts(fonts: string[]): Promise<{
+        loaded: string[];
+    }>;
+    /**
+     * Get available fonts from the worker
+     */
+    getAvailableFonts(): Promise<{
+        fonts: Array<{
+            name: string[];
+        }>;
+    }>;
+    /**
+     * Reconstruct MText object from JSON serialized data
+     */
+    reconstructMText(serializedData: SerializedMText): MTextObject;
+    /**
+     * Terminate the worker
+     */
+    terminate(): void;
+    destroy(): void;
+}
+export {};