three-text 0.5.1 → 0.6.0

package/dist/index.js

@@ -1,6 +1,6 @@
 /*!
  * @license
- * three-text v0.5.1
+ * three-text v0.6.0
  * Copyright © 2025-2026 Jeremy Tribby, Countertype LLC
  * SPDX-License-Identifier: MIT
  */
@@ -3260,6 +3260,8 @@ class Text {
     static { this.patternCache = new Map(); }
     static { this.hbInitPromise = null; }
     static { this.fontCache = new Map(); }
+    static { this.fontLoadPromises = new Map(); }
+    static { this.fontRefCounts = new Map(); }
     static { this.fontCacheMemoryBytes = 0; }
     static { this.maxFontCacheMemoryBytes = Infinity; }
     static { this.fontIdCounter = 0; }
@@ -3304,9 +3306,9 @@ class Text {
         if (!Text.hbInitPromise) {
             Text.hbInitPromise = HarfBuzzLoader.getHarfBuzz();
         }
-        const loadedFont = await Text.resolveFont(options);
+        const { loadedFont, fontKey } = await Text.resolveFont(options);
         const text = new Text();
-        text.setLoadedFont(loadedFont);
+        text.setLoadedFont(loadedFont, fontKey);
         const result = await text.createLayout(options);
         const update = async (newOptions) => {
             const mergedOptions = { ...options };
@@ -3319,8 +3321,8 @@ class Text {
             if (newOptions.font !== undefined ||
                 newOptions.fontVariations !== undefined ||
                 newOptions.fontFeatures !== undefined) {
-                const newLoadedFont = await Text.resolveFont(mergedOptions);
-                text.setLoadedFont(newLoadedFont);
+                const { loadedFont: newLoadedFont, fontKey: newFontKey } = await Text.resolveFont(mergedOptions);
+                text.setLoadedFont(newLoadedFont, newFontKey);
                 text.resetHelpers();
             }
             options = mergedOptions;
@@ -3341,6 +3343,22 @@ class Text {
             dispose: () => text.destroy()
         };
     }
+    static retainFont(fontKey) {
+        Text.fontRefCounts.set(fontKey, (Text.fontRefCounts.get(fontKey) ?? 0) + 1);
+    }
+    static releaseFont(fontKey, loadedFont) {
+        const nextCount = (Text.fontRefCounts.get(fontKey) ?? 0) - 1;
+        if (nextCount > 0) {
+            Text.fontRefCounts.set(fontKey, nextCount);
+            return;
+        }
+        Text.fontRefCounts.delete(fontKey);
+        // Cached fonts stay alive while present in the cache. If a font has been
+        // evicted, destroy it once the last live handle releases it.
+        if (!Text.fontCache.has(fontKey)) {
+            FontLoader.destroyFont(loadedFont);
+        }
+    }
     static async resolveFont(options) {
         const baseFontKey = typeof options.font === 'string'
             ? options.font
@@ -3354,9 +3372,17 @@ class Text {
         }
         let loadedFont = Text.fontCache.get(fontKey);
         if (!loadedFont) {
-            loadedFont = await Text.loadAndCacheFont(fontKey, options.font, options.fontVariations, options.fontFeatures);
+            let loadPromise = Text.fontLoadPromises.get(fontKey);
+            if (!loadPromise) {
+                loadPromise = Text.loadAndCacheFont(fontKey, options.font, options.fontVariations, options.fontFeatures).finally(() => {
+                    Text.fontLoadPromises.delete(fontKey);
+                });
+                Text.fontLoadPromises.set(fontKey, loadPromise);
+            }
+            loadedFont = await loadPromise;
         }
-        return loadedFont;
+        Text.retainFont(fontKey);
+        return { loadedFont, fontKey };
     }
     static async loadAndCacheFont(fontKey, font, fontVariations, fontFeatures) {
         const tempText = new Text();
@@ -3388,8 +3414,12 @@ class Text {
             const firstKey = Text.fontCache.keys().next().value;
             if (firstKey === undefined)
                 break;
+            const font = Text.fontCache.get(firstKey);
             Text.trackFontCacheRemove(firstKey);
             Text.fontCache.delete(firstKey);
+            if ((Text.fontRefCounts.get(firstKey) ?? 0) <= 0 && font) {
+                FontLoader.destroyFont(font);
+            }
         }
     }
     static generateFontContentHash(buffer) {
@@ -3411,8 +3441,12 @@ class Text {
             return `c${++Text.fontIdCounter}`;
         }
     }
-    setLoadedFont(loadedFont) {
+    setLoadedFont(loadedFont, fontKey) {
+        if (this.loadedFont && this.loadedFont !== loadedFont) {
+            this.releaseCurrentFont();
+        }
         this.loadedFont = loadedFont;
+        this.currentFontCacheKey = fontKey;
         const contentHash = Text.generateFontContentHash(loadedFont._buffer);
         this.currentFontId = `font_${contentHash}`;
         if (loadedFont.fontVariations) {
@@ -3422,6 +3456,29 @@ class Text {
             this.currentFontId += `_feat_${Text.stableStringify(loadedFont.fontFeatures)}`;
         }
     }
+    releaseCurrentFont() {
+        if (!this.loadedFont)
+            return;
+        const currentFont = this.loadedFont;
+        const currentFontKey = this.currentFontCacheKey;
+        try {
+            if (currentFontKey) {
+                Text.releaseFont(currentFontKey, currentFont);
+            }
+            else {
+                FontLoader.destroyFont(currentFont);
+            }
+        }
+        catch (error) {
+            logger.warn('Error destroying HarfBuzz objects:', error);
+        }
+        finally {
+            this.loadedFont = undefined;
+            this.currentFontCacheKey = undefined;
+            this.textLayout = undefined;
+            this.textShaper = undefined;
+        }
+    }
     async loadFont(fontSrc, fontVariations, fontFeatures) {
         perfLogger.start('Text.loadFont', {
             fontSrc: typeof fontSrc === 'string' ? fontSrc : `buffer(${fontSrc.byteLength})`
@@ -3641,18 +3698,7 @@ class Text {
         if (!this.loadedFont) {
             return;
         }
-        const currentFont = this.loadedFont;
-        try {
-            FontLoader.destroyFont(currentFont);
-        }
-        catch (error) {
-            logger.warn('Error destroying HarfBuzz objects:', error);
-        }
-        finally {
-            this.loadedFont = undefined;
-            this.textLayout = undefined;
-            this.textShaper = undefined;
-        }
+        this.releaseCurrentFont();
     }
 }