@mlightcad/mtext-renderer 0.2.0

package/dist/font/fontManager.d.ts

@@ -0,0 +1,128 @@
+import { BaseFont } from './baseFont';
+import { BaseTextShape } from './baseTextShape';
+import { EventManager } from '../common';
+import { FontLoadStatus } from './fontLoader';
+import { FontType } from './font';
+
+/**
+ * Font mappings configuration.
+ * Maps original font names to their replacement font names.
+ * - The key is the original font name
+ * - The value is the mapped font name
+ */
+export type FontMapping = Record<string, string>;
+/**
+ * Event arguments for font-related events.
+ */
+export interface FontManagerEventArgs {
+    /** Name of font which can't be found */
+    fontName: string;
+    /** The number of characters which use this font. This is only used when the font is not found. */
+    count?: number;
+}
+/**
+ * Manages font loading, caching, and text rendering.
+ * This class is responsible for:
+ * - Loading fonts from URLs or cache
+ * - Managing font mappings and replacements
+ * - Providing text shapes for rendering
+ * - Tracking unsupported characters and missed fonts
+ */
+export declare class FontManager {
+    private static _instance;
+    /** THREE.js file loader for loading font files */
+    private loader;
+    /** Mapping of original font names to their replacements */
+    protected fontMapping: FontMapping;
+    /** Map of loaded fonts, keyed by font name */
+    protected fontMap: Map<string, BaseFont>;
+    /** List of font file names that have been loaded */
+    protected fileNames: string[];
+    /** Record of characters that are not supported by any loaded font */
+    unsupportedChars: Record<string, number>;
+    /** Record of fonts that were requested but not found */
+    missedFonts: Record<string, number>;
+    /** Flag to enable/disable font caching */
+    enableFontCache: boolean;
+    /** Default font to use when a requested font is not found */
+    defaultFont: string;
+    /** Event managers for font-related events */
+    readonly events: {
+        /** Event triggered when a font cannot be found */
+        fontNotFound: EventManager<FontManagerEventArgs>;
+        /** Event triggered when a font is successfully loaded */
+        fontLoaded: EventManager<FontManagerEventArgs>;
+    };
+    private constructor();
+    /**
+     * Gets the singleton instance of the FontManager
+     * @returns The FontManager instance
+     */
+    static get instance(): FontManager;
+    /**
+     * Sets the font mapping configuration
+     * @param mapping - The font mapping to set
+     */
+    setFontMapping(mapping: FontMapping): void;
+    /**
+     * Loads the specified fonts from URLs
+     * @param urls - URLs of font files to load. The order represents the priority
+     * @returns Promise that resolves to an array of font load statuses
+     */
+    loadFonts(urls: string | string[]): Promise<FontLoadStatus[]>;
+    /**
+     * Tries to find the specified font. If not found, uses a replacement font and returns its name.
+     * @param fontName - The font name to find
+     * @returns The original font name if found, or the replacement font name if not found
+     */
+    findAndReplaceFont(fontName: string): string;
+    /**
+     * Gets the text shape for a specific character with the specified font and size
+     * @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
+     */
+    getCharShape(char: string, fontName: string, size: number): BaseTextShape | undefined;
+    /**
+     * Gets the scale factor for a specific font
+     * @param fontName - The name of the font
+     * @returns The scale factor for the font, or 1 if the font is not found
+     */
+    getFontScaleFactor(fontName: string): number;
+    /**
+     * Gets type of the specific font
+     * @param fontName - The name of the font
+     * @returns The type of the font. If the specified font can't be found, `undefined` is returned
+     */
+    getFontType(fontName: string): FontType | undefined;
+    /**
+     * Gets the shape to display when a character is not found
+     * @param size - The size of the shape
+     * @returns The shape for the not found indicator, or undefined if not available
+     */
+    getNotFoundTextShape(size: number): BaseTextShape | undefined;
+    /**
+     * Records a font that was requested but not found
+     * @param fontName - The name of the font that was not found
+     */
+    private recordMissedFonts;
+    /**
+     * Loads a single font from a URL
+     * @param url - The URL of the font file to load
+     */
+    private loadFont;
+    /**
+     * Loads all fonts from the cache
+     */
+    getAllFontsFromCache(): Promise<void>;
+    /**
+     * Gets a record of all unsupported characters across all loaded fonts
+     * @returns A record mapping unsupported characters to their occurrence count
+     */
+    getUnsupportedChar(): Record<string, number>;
+    /**
+     * Releases all loaded fonts and clears the font map
+     */
+    release(): void;
+}

package/dist/font/index.d.ts

@@ -0,0 +1,6 @@
+export * from './baseFont';
+export * from './baseTextShape';
+export * from './font';
+export * from './fontFactory';
+export * from './fontLoader';
+export * from './fontManager';

package/dist/font/meshFont.d.ts

@@ -0,0 +1,59 @@
+import { Font, FontData } from 'three/examples/jsm/loaders/FontLoader.js';
+import { BaseFont } from './baseFont';
+import { MeshTextShape } from './meshTextShape';
+
+/**
+ * Represents the data structure for mesh-based fonts.
+ * Extends the base FontData interface with additional properties specific to mesh fonts.
+ */
+export interface MeshFontData extends FontData {
+    /** Scale factor used to adjust the size of characters when rendering */
+    scaleFactor: number;
+}
+/**
+ * Represents a mesh-based font (e.g., TTF, OTF, WOFF).
+ * This class extends BaseFont to provide specific functionality for mesh fonts,
+ * including character shape generation and scale factor management.
+ */
+export declare class MeshFont extends BaseFont {
+    /** Scale factor used to adjust the size of characters */
+    protected scaleFactor?: number;
+    /** Three.js font instance used for rendering */
+    readonly font: Font;
+    /** The type of font (always 'mesh' for this class) */
+    readonly type = "mesh";
+    /** The parsed font data */
+    readonly data: MeshFontData;
+    /**
+     * Creates a new instance of MeshFont.
+     * @param data - Either a MeshFontData object containing font information or an ArrayBuffer containing raw font data
+     */
+    constructor(data: MeshFontData | ArrayBuffer);
+    /**
+     * Generates shapes for a text string
+     * @param text - The text to generate shapes for
+     * @param size - The size of the text
+     * @returns Array of shapes representing the text
+     */
+    generateShapes(text: string, size: number): import('three').Shape[];
+    /**
+     * Gets the shape data for a specific character at a given size.
+     * @param char - The character to get the shape for
+     * @param size - The desired size of the character
+     * @returns The shape data for the character, or undefined if not found
+     */
+    getCharShape(char: string, size: number): MeshTextShape | undefined;
+    /**
+     * Gets the scale factor for this font.
+     * This is used to adjust the size of characters when rendering.
+     * @returns The scale factor as a number
+     */
+    getScaleFactor(): number;
+    /**
+     * Gets the shape to display when a character is not found in the font.
+     * Uses "?" as a replacement character.
+     * @param size - The desired size of the not found shape
+     * @returns The shape data for the not found indicator
+     */
+    getNotFoundTextShape(size: number): MeshTextShape;
+}

package/dist/font/meshFontParser.d.ts

@@ -0,0 +1,11 @@
+import { MeshFontData } from './meshFont';
+
+/**
+ * Parses a mesh font from raw binary data.
+ * This function converts raw font data (e.g., TTF, OTF, WOFF) into a MeshFontData object
+ * that can be used by the MeshFont class.
+ *
+ * @param data - The raw font data as an ArrayBuffer
+ * @returns A MeshFontData object containing the parsed font information
+ */
+export declare function parseMeshFont(data: ArrayBuffer): MeshFontData;

package/dist/font/meshTextShape.d.ts

@@ -0,0 +1,32 @@
+import { BaseTextShape } from './baseTextShape';
+import { MeshFont } from './meshFont';
+import * as THREE from 'three';
+/**
+ * Represents a text shape for mesh-based fonts (e.g., TTF, OTF, WOFF).
+ * This class extends BaseTextShape to provide specific functionality for mesh fonts,
+ * including 3D geometry generation and character width calculation.
+ */
+export declare class MeshTextShape extends BaseTextShape {
+    /**
+     * Flag to indicate whether the character is found in the font.
+     * Used to track if the character exists in the font's glyph set.
+     */
+    isFound: boolean;
+    private readonly font;
+    private readonly fontSize;
+    constructor(char: string, fontSize: number, font: MeshFont);
+    /**
+     * Converts the text shape to a THREE.js geometry.
+     * This is used for 3D rendering of the text.
+     * @returns A THREE.js BufferGeometry representing the text shape
+     */
+    toGeometry(): THREE.BufferGeometry;
+    /**
+     * Calculates the width of a character in the font.
+     * @param char - The character to calculate width for
+     * @param fontSize - The size of the font in pixels
+     * @param font - The mesh font to use
+     * @returns The width of the character in pixels
+     */
+    private getCharWidth;
+}

package/dist/font/shxFont.d.ts

@@ -0,0 +1,33 @@
+import { ShxFontData } from '@mlightcad/shx-parser';
+import { BaseFont } from './baseFont';
+import { ShxTextShape } from './shxTextShape';
+
+/**
+ * ShxFont is a class that extends BaseFont and represents a SHX font.
+ * It provides methods to generate shapes for text and retrieve character shapes.
+ */
+export declare class ShxFont extends BaseFont {
+    /** Internal shx font instance */
+    private readonly font;
+    readonly type = "shx";
+    readonly data: ShxFontData;
+    constructor(data: ShxFontData | ArrayBuffer);
+    generateShapes(text: string, size: number): ShxTextShape[];
+    /**
+     * SHX font always has fixed scale factor 1.
+     * @returns Always return value 1
+     */
+    getScaleFactor(): number;
+    /**
+     * Gets the shape data for a specific character at a given size.
+     * @param char - The character to get the shape for
+     * @param size - The desired size of the character
+     * @returns The shape data for the character, or undefined if not found
+     */
+    getCharShape(char: string, size: number): ShxTextShape | undefined;
+    /**
+     * For an unsupported char, use "？" as a replacement.
+     */
+    getNotFoundTextShape(size: number): ShxTextShape | undefined;
+    private getCode;
+}

package/dist/font/shxTextShape.d.ts

@@ -0,0 +1,26 @@
+import { Point, ShxShape } from '@mlightcad/shx-parser';
+import { BaseTextShape } from './baseTextShape';
+
+import * as THREE from 'three';
+/**
+ * Represents a text shape for SHX fonts.
+ * This class extends BaseTextShape to provide specific functionality for SHX fonts,
+ * including shape data management and dimension calculations.
+ */
+export declare class ShxTextShape extends BaseTextShape {
+    /** The shape data for this character */
+    private readonly shape;
+    /**
+     * 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);
+    protected calcWidth(): number;
+    offset(offset: Point): ShxTextShape;
+    /**
+     * Converts the text shape to a THREE.js geometry
+     * @returns A THREE.js BufferGeometry representing the text shape
+     */
+    toGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+}

package/dist/index.d.ts

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