three-text 0.5.1 → 0.6.0

package/dist/index.umd.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
  */
@@ -3267,6 +3267,8 @@
         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; }
@@ -3311,9 +3313,9 @@
             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 };
@@ -3326,8 +3328,8 @@
                 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;
@@ -3348,6 +3350,22 @@
                 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
@@ -3361,9 +3379,17 @@
             }
             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();
@@ -3395,8 +3421,12 @@
                 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) {
@@ -3418,8 +3448,12 @@
                 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) {
@@ -3429,6 +3463,29 @@
                 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})`
@@ -3648,18 +3705,7 @@
             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();
         }
     };
 
@@ -6378,7 +6424,8 @@
             getCacheSize: () => meshPipeline.getCacheSize(),
             clearCache: () => meshPipeline.clearCache(),
             measureTextWidth: (text, letterSpacing) => layoutHandle.measureTextWidth(text, letterSpacing),
-            update
+            update,
+            dispose: () => layoutHandle.dispose()
         };
     }
     class Text {