@lightningjs/renderer 3.0.0-beta14 → 3.0.0-beta16

package/dist/src/core/text-rendering/CoreFont.d.ts

@@ -0,0 +1,33 @@
+import type { CoreTextNode } from '../CoreTextNode.js';
+import type { FontMetrics, NormalizedFontMetrics, TextRenderer } from './TextRenderer.js';
+import { EventEmitter } from '../../common/EventEmitter.js';
+export declare enum FontState {
+    Created = 0,
+    Loading = 1,
+    Loaded = 2,
+    Failed = 3
+}
+export interface CoreFontProps {
+    family: string;
+    metrics?: FontMetrics;
+}
+/**
+ * EventEmiter only intended to communicated with FontManager
+ */
+export declare abstract class CoreFont extends EventEmitter {
+    protected waitingNodes?: Record<number, CoreTextNode>;
+    protected normalizedMetrics?: Record<number, NormalizedFontMetrics>;
+    textRenderer: TextRenderer;
+    state: FontState;
+    family: string;
+    metrics?: FontMetrics;
+    constructor(textRenderer: TextRenderer, props: CoreFontProps);
+    protected onLoaded(): void;
+    waiting(node: CoreTextNode): void;
+    stopWaiting(node: CoreTextNode): void;
+    destroy(): void;
+    abstract type: string;
+    abstract load(): void;
+    abstract measureText(text: string, letterSpacing: number): number;
+    abstract getMetrics(fontSize: number): NormalizedFontMetrics;
+}

package/dist/src/core/text-rendering/CoreFont.js

@@ -0,0 +1,48 @@
+import { UpdateType } from '../CoreNode.js';
+import { EventEmitter } from '../../common/EventEmitter.js';
+export var FontState;
+(function (FontState) {
+    FontState[FontState["Created"] = 0] = "Created";
+    FontState[FontState["Loading"] = 1] = "Loading";
+    FontState[FontState["Loaded"] = 2] = "Loaded";
+    FontState[FontState["Failed"] = 3] = "Failed";
+})(FontState || (FontState = {}));
+/**
+ * EventEmiter only intended to communicated with FontManager
+ */
+export class CoreFont extends EventEmitter {
+    waitingNodes = Object.create(null);
+    normalizedMetrics = Object.create(null);
+    textRenderer;
+    state;
+    family;
+    metrics;
+    constructor(textRenderer, props) {
+        super();
+        this.family = props.family;
+        this.state = FontState.Created;
+        this.textRenderer = textRenderer;
+    }
+    onLoaded() {
+        const waitingNodes = this.waitingNodes;
+        for (let key in waitingNodes) {
+            waitingNodes[key].setUpdateType(UpdateType.Local);
+            delete waitingNodes[key];
+        }
+        this.state = FontState.Loaded;
+    }
+    waiting(node) {
+        this.waitingNodes[node.id] = node;
+    }
+    stopWaiting(node) {
+        if (this.waitingNodes[node.id]) {
+            delete this.waitingNodes[node.id];
+        }
+    }
+    destroy() {
+        delete this.waitingNodes;
+        delete this.normalizedMetrics;
+        delete this.metrics;
+    }
+}
+//# sourceMappingURL=CoreFont.js.map

package/dist/src/core/text-rendering/CoreFont.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoreFont.js","sourceRoot":"","sources":["../../../../src/core/text-rendering/CoreFont.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,MAAM,CAAN,IAAY,SAKX;AALD,WAAY,SAAS;IACnB,+CAAO,CAAA;IACP,+CAAO,CAAA;IACP,6CAAM,CAAA;IACN,6CAAM,CAAA;AACR,CAAC,EALW,SAAS,KAAT,SAAS,QAKpB;AAOD;;GAEG;AACH,MAAM,OAAgB,QAAS,SAAQ,YAAY;IACvC,YAAY,GAAkC,MAAM,CAAC,MAAM,CACnE,IAAI,CAC2B,CAAC;IACxB,iBAAiB,GACzB,MAAM,CAAC,MAAM,CAAC,IAAI,CAA0C,CAAC;IAExD,YAAY,CAAe;IAC3B,KAAK,CAAY;IACjB,MAAM,CAAS;IACf,OAAO,CAAe;IAE7B,YAAY,YAA0B,EAAE,KAAoB;QAC1D,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAES,QAAQ;QAChB,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACvC,KAAK,IAAI,GAAG,IAAI,YAAY,EAAE,CAAC;YAC7B,YAAY,CAAC,GAAG,CAAE,CAAC,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACnD,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC;QAC3B,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC;IAChC,CAAC;IAEM,OAAO,CAAC,IAAkB;QAC/B,IAAI,CAAC,YAAa,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;IACrC,CAAC;IAEM,WAAW,CAAC,IAAkB;QACnC,IAAI,IAAI,CAAC,YAAa,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC,YAAa,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IAEM,OAAO;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC;QACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC;QAC9B,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CAMF"}

package/dist/src/core/text-rendering/FontManager.d.ts

@@ -0,0 +1,11 @@
+import type { Stage } from '../Stage.js';
+import type { CoreFont } from './CoreFont.js';
+import type { FontLoadOptions, TextRenderer, TextRenderers } from './TextRenderer.js';
+export declare class CoreFontManager {
+    private fonts;
+    private renderers;
+    constructor(stage: Stage, textRenderers: TextRenderer[]);
+    loadFont(type: TextRenderers, options: FontLoadOptions): void;
+    unloadFont(fontFamily: string): void;
+    getFont(fontFamily: string): CoreFont | undefined;
+}

package/dist/src/core/text-rendering/FontManager.js

@@ -0,0 +1,42 @@
+export class CoreFontManager {
+    fonts = Object.create(null);
+    renderers = Object.create(null);
+    constructor(stage, textRenderers) {
+        for (let i = 0; i < textRenderers.length; i++) {
+            const renderer = textRenderers[i];
+            renderer.init(stage);
+            this.renderers[renderer.type] = renderer;
+        }
+    }
+    loadFont(type, options) {
+        const targetRenderer = this.renderers[type];
+        if (targetRenderer === undefined) {
+            console.error('renderer type for this font does not exist');
+            return;
+        }
+        console.log('loadFOnt', type, options);
+        const font = targetRenderer.createFont(options);
+        if (font === undefined) {
+            return;
+        }
+        font.load();
+        this.fonts[options.fontFamily] = font;
+    }
+    unloadFont(fontFamily) {
+        const targetFont = this.fonts[fontFamily];
+        if (targetFont === undefined) {
+            return;
+        }
+        targetFont.destroy();
+        delete this.fonts[fontFamily];
+    }
+    getFont(fontFamily) {
+        const font = this.fonts[fontFamily];
+        if (font === undefined) {
+            console.warn('fontFamily not registered');
+            return;
+        }
+        return font;
+    }
+}
+//# sourceMappingURL=FontManager.js.map

package/dist/src/core/text-rendering/FontManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontManager.js","sourceRoot":"","sources":["../../../../src/core/text-rendering/FontManager.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,eAAe;IAClB,KAAK,GAA6B,MAAM,CAAC,MAAM,CAAC,IAAI,CAG3D,CAAC;IACM,SAAS,GAAiC,MAAM,CAAC,MAAM,CAC7D,IAAI,CAC2B,CAAC;IAElC,YAAY,KAAY,EAAE,aAA6B;QACrD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,MAAM,QAAQ,GAAG,aAAa,CAAC,CAAC,CAAE,CAAC;YACnC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;QAC3C,CAAC;IACH,CAAC;IAED,QAAQ,CAAC,IAAmB,EAAE,OAAwB;QACpD,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YACjC,OAAO,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC;YAC5D,OAAO;QACT,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QACvC,MAAM,IAAI,GAAG,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IACxC,CAAC;IAED,UAAU,CAAC,UAAkB;QAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO;QACT,CAAC;QACD,UAAU,CAAC,OAAO,EAAE,CAAC;QACrB,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAChC,CAAC;IAED,OAAO,CAAC,UAAkB;QACxB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACpC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,CAAC,IAAI,CAAC,2BAA2B,CAAC,CAAC;YAC1C,OAAO;QACT,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/src/core/text-rendering/SdfFont.d.ts

@@ -0,0 +1,29 @@
+import type { Stage } from '../Stage.js';
+import type { ImageTexture } from '../textures/ImageTexture.js';
+import { CoreFont, type CoreFontProps } from './CoreFont.js';
+import { type SdfFontData } from './SdfFontHandler.js';
+import type { NormalizedFontMetrics, TextRenderer } from './TextRenderer.js';
+export type SdfFontProps = CoreFontProps & {
+    atlasUrl: string;
+    atlasDataUrl: string;
+};
+export declare class SdfFont extends CoreFont {
+    private stage;
+    type: string;
+    atlasUrl: string;
+    atlasDataUrl: string;
+    atlasTexture?: ImageTexture;
+    private glyphMap?;
+    private kerningTable?;
+    private data?;
+    constructor(textRenderer: TextRenderer, props: SdfFontProps, stage: Stage);
+    load(): void;
+    private hardFail;
+    private processFontData;
+    measureText(text: string, letterSpacing: number): number;
+    getMetrics(fontSize: number): NormalizedFontMetrics;
+    getGlyph(codepoint: number): import("./SdfFontHandler.js").SdfGlyph | null;
+    getKerning(firstGlyph: number, secondGlyph: number): number;
+    getAtlas(): ImageTexture;
+    getData(): SdfFontData;
+}

package/dist/src/core/text-rendering/SdfFont.js

@@ -0,0 +1,142 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2025 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CoreFont, FontState } from './CoreFont.js';
+import { buildGlyphMap, buildKerningTable, } from './SdfFontHandler.js';
+import { normalizeFontMetrics } from './TextLayoutEngine.js';
+import { hasZeroWidthSpace } from './Utils.js';
+export class SdfFont extends CoreFont {
+    stage;
+    type = 'sdf';
+    atlasUrl;
+    atlasDataUrl;
+    atlasTexture;
+    glyphMap;
+    kerningTable;
+    data;
+    constructor(textRenderer, props, stage) {
+        super(textRenderer, props);
+        this.stage = stage;
+        this.atlasUrl = props.atlasUrl;
+        this.atlasDataUrl = props.atlasDataUrl;
+    }
+    load() {
+        new Promise(async () => {
+            const atlasData = await fetch(this.atlasDataUrl);
+            if (atlasData.ok === false) {
+                this.hardFail(`Failed to load font data: ${atlasData.statusText}`);
+            }
+            const fontData = (await atlasData.json());
+            if (fontData.chars === undefined) {
+                this.hardFail('Invalid SDF font data format');
+            }
+            const atlasTexture = this.stage.txManager.createTexture('ImageTexture', {
+                src: this.atlasUrl,
+                premultiplyAlpha: false,
+            });
+            atlasTexture.setRenderableOwner(this.family, true);
+            atlasTexture.preventCleanup = true;
+            atlasTexture.on('loaded', () => {
+                this.onLoaded();
+            });
+            atlasTexture.on('failed', (error) => {
+                console.error(`Failed to load SDF font: ${this.family}`, error);
+                this.emit('failed');
+            });
+            this.atlasTexture = atlasTexture;
+            this.processFontData(fontData);
+        });
+    }
+    hardFail(message) {
+        this.state = FontState.Failed;
+        throw new Error(message);
+    }
+    processFontData(fontData) {
+        this.glyphMap = buildGlyphMap(fontData.chars);
+        this.kerningTable = buildKerningTable(fontData.kernings);
+        this.metrics = this.metrics ||
+            fontData.lightningMetrics || {
+            ascender: 800,
+            descender: -200,
+            lineGap: 200,
+            unitsPerEm: 1000,
+        };
+        this.data = fontData;
+    }
+    measureText(text, letterSpacing) {
+        if (text.length === 1) {
+            const char = text.charAt(0);
+            const codepoint = text.codePointAt(0);
+            if (codepoint === undefined)
+                return 0;
+            if (hasZeroWidthSpace(char) === true)
+                return 0;
+            const glyph = this.getGlyph(codepoint);
+            if (glyph === null)
+                return 0;
+            return glyph.xadvance + letterSpacing;
+        }
+        let width = 0;
+        let prevCodepoint = 0;
+        for (let i = 0; i < text.length; i++) {
+            const char = text.charAt(i);
+            const codepoint = text.codePointAt(i);
+            if (codepoint === undefined)
+                continue;
+            // Skip zero-width spaces in width calculations
+            if (hasZeroWidthSpace(char)) {
+                continue;
+            }
+            const glyph = this.getGlyph(codepoint);
+            if (glyph === null)
+                continue;
+            let advance = glyph.xadvance;
+            // Add kerning if there's a previous character
+            if (prevCodepoint !== 0) {
+                const kerning = this.getKerning(prevCodepoint, codepoint);
+                advance += kerning;
+            }
+            width += advance + letterSpacing;
+            prevCodepoint = codepoint;
+        }
+        return width;
+    }
+    getMetrics(fontSize) {
+        let m = this.normalizedMetrics[fontSize];
+        if (m !== undefined) {
+            return m;
+        }
+        m = this.normalizedMetrics[fontSize] = normalizeFontMetrics(this.metrics, fontSize);
+        return m;
+    }
+    getGlyph(codepoint) {
+        const gm = this.glyphMap;
+        return gm[codepoint] || gm[63] || null;
+    }
+    getKerning(firstGlyph, secondGlyph) {
+        const seconds = this.kerningTable[secondGlyph];
+        return (seconds !== undefined && seconds[firstGlyph]) || 0;
+    }
+    getAtlas() {
+        return this.atlasTexture;
+    }
+    getData() {
+        return this.data;
+    }
+}
+//# sourceMappingURL=SdfFont.js.map

package/dist/src/core/text-rendering/SdfFont.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdfFont.js","sourceRoot":"","sources":["../../../../src/core/text-rendering/SdfFont.ts"],"names":[],"mappings":"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"}

package/dist/src/core/text-rendering/SdfFontHandler.d.ts

@@ -57,6 +57,37 @@ export interface SdfFontData {
     };
     lightningMetrics?: FontMetrics;
 }
+/**
+ * @typedef {Object} SdfGlyph
+ * @property {number} id - Glyph ID
+ * @property {string} char - Character
+ * @property {number} x - Atlas x position
+ * @property {number} y - Atlas y position
+ * @property {number} width - Glyph width
+ * @property {number} height - Glyph height
+ * @property {number} xoffset - X offset
+ * @property {number} yoffset - Y offset
+ * @property {number} xadvance - Character advance width
+ * @property {number} page - Page number
+ * @property {number} chnl - Channel
+ */
+/**
+ * @typedef {Object} KerningTable
+ * Fast lookup table for kerning values
+ */
+type KerningTable = Record<number, Record<number, number | undefined> | undefined>;
+/**
+ * @typedef {Object} SdfFontCache
+ * Cached font data for performance
+ */
+export interface SdfFont {
+    data: SdfFontData;
+    glyphMap: Map<number, SdfFontData['chars'][0]>;
+    kernings: KerningTable;
+    atlasTexture: ImageTexture;
+    metrics: FontMetrics;
+    maxCharHeight: number;
+}
 /**
  * Check if the SDF font handler can render a font
  * @param {TrProps} trProps - Text rendering properties
@@ -103,10 +134,7 @@ export declare const isFontLoaded: (fontFamily: string) => boolean;
  * Get normalized font metrics for a font family
  */
 export declare const getFontMetrics: (fontFamily: string, fontSize: number) => NormalizedFontMetrics;
-/**
- * Set font metrics for a font family
- */
-export declare const setFontMetrics: (fontFamily: string, metrics: NormalizedFontMetrics) => void;
+export declare const processFontMetrics: (fontFamily: string, fontSize: number, metrics: FontMetrics) => NormalizedFontMetrics;
 /**
  * Get glyph data for a character in a specific font
  * @param {string} fontFamily - Font family name
@@ -133,7 +161,7 @@ export declare const getAtlas: (fontFamily: string) => ImageTexture | null;
  * @param {string} fontFamily - Font family name
  * @returns {SdfFontData|null} Font data or null
  */
-export declare const getFontData: (fontFamily: string) => SdfFontData | null;
+export declare const getFontData: (fontFamily: string) => SdfFont | undefined;
 /**
  * Get maximum character height for a font family
  * @param {string} fontFamily - Font family name
@@ -150,3 +178,5 @@ export declare const getLoadedFonts: () => string[];
  * @param {string} fontFamily - Font family name
  */
 export declare const unloadFont: (fontFamily: string) => void;
+export declare const measureText: (text: string, fontFamily: string, letterSpacing: number) => number;
+export {};

package/dist/src/core/text-rendering/SdfFontHandler.js

@@ -17,20 +17,14 @@
  * limitations under the License.
  */
 import { UpdateType } from '../CoreNode.js';
+import { hasZeroWidthSpace } from './Utils.js';
+import { normalizeFontMetrics } from './TextLayoutEngine.js';
 //global state variables for SdfFontHandler
-const fontCache = Object.create(null);
-const loadedFonts = new Set();
+const fontCache = new Map();
 const fontLoadPromises = new Map();
+const normalizedMetrics = new Map();
 const nodesWaitingForFont = Object.create(null);
 let initialized = false;
-/**
- * Normalize font metrics to be in the range of 0 to 1
- */
-const normalizeMetrics = (metrics) => ({
-    ascender: metrics.ascender / metrics.unitsPerEm,
-    descender: metrics.descender / metrics.unitsPerEm,
-    lineGap: metrics.lineGap / metrics.unitsPerEm,
-});
 /**
  * Build kerning lookup table for fast access
  * @param {Array} kernings - Kerning data from font
@@ -105,34 +99,27 @@ const processFontData = (fontFamily, fontData, atlasTexture, metrics) => {
         }
         i++;
     }
-    // Determine metrics
-    let normalizedMetrics;
-    if (metrics !== undefined) {
-        normalizedMetrics = normalizeMetrics(metrics);
-    }
-    else if (fontData.lightningMetrics !== undefined) {
-        normalizedMetrics = normalizeMetrics(fontData.lightningMetrics);
-    }
-    else {
+    if (metrics === undefined && fontData.lightningMetrics === undefined) {
         console.warn(`Font metrics not found for SDF font ${fontFamily}. ` +
             'Make sure you are using the latest version of the Lightning ' +
             '3 msdf-generator tool to generate your SDF fonts. Using default metrics.');
-        // Use default metrics
-        normalizedMetrics = {
-            ascender: 0.8,
-            descender: -0.2,
-            lineGap: 0.2,
-        };
     }
+    metrics = metrics ||
+        fontData.lightningMetrics || {
+        ascender: 800,
+        descender: -200,
+        lineGap: 200,
+        unitsPerEm: 1000,
+    };
     // Cache processed data
-    fontCache[fontFamily] = {
+    fontCache.set(fontFamily, {
         data: fontData,
         glyphMap,
         kernings,
         atlasTexture,
-        metrics: normalizedMetrics,
+        metrics,
         maxCharHeight,
-    };
+    });
 };
 /**
  * Check if the SDF font handler can render a font
@@ -153,7 +140,7 @@ export const canRenderFont = (trProps) => {
 export const loadFont = async (stage, options) => {
     const { fontFamily, atlasUrl, atlasDataUrl, metrics } = options;
     // Early return if already loaded
-    if (loadedFonts.has(fontFamily) === true) {
+    if (fontCache.get(fontFamily) !== undefined) {
         return;
     }
     // Early return if already loading
@@ -192,7 +179,6 @@ export const loadFont = async (stage, options) => {
             if (atlasTexture.state === 'loaded') {
                 // If already loaded, process immediately
                 processFontData(fontFamily, fontData, atlasTexture, metrics);
-                loadedFonts.add(fontFamily);
                 fontLoadPromises.delete(fontFamily);
                 for (let key in nwff) {
                     nwff[key].setUpdateType(UpdateType.Local);
@@ -203,8 +189,7 @@ export const loadFont = async (stage, options) => {
             atlasTexture.on('loaded', () => {
                 // Process and cache font data
                 processFontData(fontFamily, fontData, atlasTexture, metrics);
-                // Mark as loaded
-                loadedFonts.add(fontFamily);
+                // remove from promises
                 fontLoadPromises.delete(fontFamily);
                 for (let key in nwff) {
                     nwff[key].setUpdateType(UpdateType.Local);
@@ -232,6 +217,9 @@ export const loadFont = async (stage, options) => {
  * @param {CoreTextNode} node - Node that was waiting for the font
  */
 export const waitingForFont = (fontFamily, node) => {
+    if (nodesWaitingForFont[fontFamily] === undefined) {
+        return;
+    }
     nodesWaitingForFont[fontFamily][node.id] = node;
 };
 /**
@@ -270,25 +258,24 @@ export const type = 'sdf';
  * Check if a font is already loaded by font family
  */
 export const isFontLoaded = (fontFamily) => {
-    return loadedFonts.has(fontFamily);
+    return fontCache.has(fontFamily);
 };
 /**
  * Get normalized font metrics for a font family
  */
-export const getFontMetrics = (fontFamily, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-fontSize) => {
-    const cache = fontCache[fontFamily];
-    return cache ? cache.metrics : { ascender: 0, descender: 0, lineGap: 0 };
-};
-/**
- * Set font metrics for a font family
- */
-export const setFontMetrics = (fontFamily, metrics) => {
-    const cache = fontCache[fontFamily];
-    if (cache !== undefined) {
-        cache.metrics = metrics;
+export const getFontMetrics = (fontFamily, fontSize) => {
+    const out = normalizedMetrics.get(fontFamily);
+    if (out !== undefined) {
+        return out;
     }
+    let metrics = fontCache.get(fontFamily).metrics;
+    return processFontMetrics(fontFamily, fontSize, metrics);
+};
+export const processFontMetrics = (fontFamily, fontSize, metrics) => {
+    const label = fontFamily + fontSize;
+    const normalized = normalizeFontMetrics(metrics, fontSize);
+    normalizedMetrics.set(label, normalized);
+    return normalized;
 };
 /**
  * Get glyph data for a character in a specific font
@@ -297,7 +284,7 @@ export const setFontMetrics = (fontFamily, metrics) => {
  * @returns {Object|null} Glyph data or null if not found
  */
 export const getGlyph = (fontFamily, codepoint) => {
-    const cache = fontCache[fontFamily];
+    const cache = fontCache.get(fontFamily);
     if (cache === undefined)
         return null;
     return cache.glyphMap.get(codepoint) || cache.glyphMap.get(63) || null; // 63 = '?'
@@ -310,7 +297,7 @@ export const getGlyph = (fontFamily, codepoint) => {
  * @returns {number} Kerning value or 0
  */
 export const getKerning = (fontFamily, firstGlyph, secondGlyph) => {
-    const cache = fontCache[fontFamily];
+    const cache = fontCache.get(fontFamily);
     if (cache === undefined)
         return 0;
     const seconds = cache.kernings[secondGlyph];
@@ -322,7 +309,7 @@ export const getKerning = (fontFamily, firstGlyph, secondGlyph) => {
  * @returns {ImageTexture|null} Atlas texture or null
  */
 export const getAtlas = (fontFamily) => {
-    const cache = fontCache[fontFamily];
+    const cache = fontCache.get(fontFamily);
     return cache !== undefined ? cache.atlasTexture : null;
 };
 /**
@@ -331,8 +318,7 @@ export const getAtlas = (fontFamily) => {
  * @returns {SdfFontData|null} Font data or null
  */
 export const getFontData = (fontFamily) => {
-    const cache = fontCache[fontFamily];
-    return cache !== undefined ? cache.data : null;
+    return fontCache.get(fontFamily);
 };
 /**
  * Get maximum character height for a font family
@@ -340,7 +326,7 @@ export const getFontData = (fontFamily) => {
  * @returns {number} Max character height or 0
  */
 export const getMaxCharHeight = (fontFamily) => {
-    const cache = fontCache[fontFamily];
+    const cache = fontCache.get(fontFamily);
     return cache !== undefined ? cache.maxCharHeight : 0;
 };
 /**
@@ -348,21 +334,58 @@ export const getMaxCharHeight = (fontFamily) => {
  * @returns {string[]} Array of font family names
  */
 export const getLoadedFonts = () => {
-    return Array.from(loadedFonts);
+    return Array.from(fontCache.keys());
 };
 /**
  * Unload a font and free resources
  * @param {string} fontFamily - Font family name
  */
 export const unloadFont = (fontFamily) => {
-    const cache = fontCache[fontFamily];
+    const cache = fontCache.get(fontFamily);
     if (cache !== undefined) {
         // Free texture if needed
         if (typeof cache.atlasTexture.free === 'function') {
             cache.atlasTexture.free();
         }
-        delete fontCache[fontFamily];
-        loadedFonts.delete(fontFamily);
+        fontCache.delete(fontFamily);
+    }
+};
+export const measureText = (text, fontFamily, letterSpacing) => {
+    if (text.length === 1) {
+        const char = text.charAt(0);
+        const codepoint = text.codePointAt(0);
+        if (codepoint === undefined)
+            return 0;
+        if (hasZeroWidthSpace(char) === true)
+            return 0;
+        const glyph = getGlyph(fontFamily, codepoint);
+        if (glyph === null)
+            return 0;
+        return glyph.xadvance + letterSpacing;
+    }
+    let width = 0;
+    let prevCodepoint = 0;
+    for (let i = 0; i < text.length; i++) {
+        const char = text.charAt(i);
+        const codepoint = text.codePointAt(i);
+        if (codepoint === undefined)
+            continue;
+        // Skip zero-width spaces in width calculations
+        if (hasZeroWidthSpace(char)) {
+            continue;
+        }
+        const glyph = getGlyph(fontFamily, codepoint);
+        if (glyph === null)
+            continue;
+        let advance = glyph.xadvance;
+        // Add kerning if there's a previous character
+        if (prevCodepoint !== 0) {
+            const kerning = getKerning(fontFamily, prevCodepoint, codepoint);
+            advance += kerning;
+        }
+        width += advance + letterSpacing;
+        prevCodepoint = codepoint;
     }
+    return width;
 };
 //# sourceMappingURL=SdfFontHandler.js.map