@solidtv/renderer 1.6.2 → 1.6.4

package/src/core/text-rendering/tests/SdfFontHandler.test.ts

@@ -4,11 +4,13 @@ import {
   waitingForFont,
   isFontLoaded,
   getFontData,
+  canRenderFont,
   MAX_FONT_LOAD_RETRIES,
 } from '../SdfFontHandler.js';
 import { EventEmitter } from '../../../common/EventEmitter.js';
 import { TextureError, TextureErrorCode } from '../../TextureError.js';
 import type { Stage } from '../../Stage.js';
+import type { TrProps } from '../TextRenderer.js';
 
 // Minimal XHR stand-in: synchronously delivers valid SDF font JSON so loadFont
 // proceeds to create the atlas texture and attach its event listeners.
@@ -294,6 +296,47 @@ describe('SdfFontHandler loadFont — multiple names for one font', () => {
     }
   });
 
+  it('reports every name as renderable while the font is still loading', async () => {
+    const { stage, textures } = makeStage();
+    const names = ['MidLoadPrimary', 'MidLoadAlias'];
+
+    const promise = loadFont(stage, opts(names));
+
+    // Mid-load: nothing is in fontCache yet, so this is answered purely by the
+    // in-flight markers. An alias that answers `false` here makes the stage
+    // resolve a *different* text renderer for the node — silently substituting
+    // a Canvas face, or throwing "No compatible text renderer found" when SDF
+    // is the only engine. Both names must answer the same.
+    for (let i = 0; i < names.length; i++) {
+      expect(canRenderFont({ fontFamily: names[i]! } as TrProps)).toBe(true);
+    }
+    expect(isFontLoaded(names[1]!)).toBe(false);
+
+    await flush();
+    textures[0]!.emit('loaded');
+    await promise;
+
+    for (let i = 0; i < names.length; i++) {
+      expect(canRenderFont({ fontFamily: names[i]! } as TrProps)).toBe(true);
+      expect(isFontLoaded(names[i]!)).toBe(true);
+    }
+  });
+
+  it('dedupes a load requested under an alias onto the in-flight load', async () => {
+    const { stage, textures } = makeStage();
+
+    const first = loadFont(stage, opts(['DedupePrimary', 'DedupeAlias']));
+    const second = loadFont(stage, opts('DedupeAlias'));
+
+    expect(second).toBe(first);
+
+    await flush();
+    // A single atlas fetch served both calls.
+    expect(textures.length).toBe(1);
+    textures[0]!.emit('loaded');
+    await first;
+  });
+
   it('wakes nodes parked under an alias, not just the primary name', async () => {
     const { stage, textures } = makeStage();
     const names = ['MultiWakePrimary', 'MultiWakeAlias'];

package/src/main-api/Renderer.ts

@@ -654,16 +654,16 @@ export type RendererMainSettings = RendererRuntimeSettings & {
    * ignore it, returning straight (non-premultiplied) alpha. This causes edge
    * "ghosting" on images with transparency.
    *
-   * `'auto'` (the default) detects via a cheap startup probe (one 1×1 PNG
-   * decode + texture upload + framebuffer readback). On devices that honor the
-   * option — the vast majority — the probe returns `true` and behavior is
-   * identical to assuming it honored; only devices that actually ignore it
-   * (e.g. the Movistar STB) switch to the WebGL-side premultiply fallback, so
-   * the change is invisible everywhere it isn't needed. Set to a boolean to
-   * force the value and skip the probe (`false` forces the GL-premultiply
-   * fallback; `true` skips it).
-   *
-   * @defaultValue `'auto'` (probe once at startup)
+   * Set to `'auto'` to detect via a cheap startup probe (one 1×1 PNG decode +
+   * texture upload + framebuffer readback). On devices that honor the option —
+   * the vast majority — the probe returns `true` and behavior is identical to
+   * assuming it honored; only devices that actually ignore it (e.g. the
+   * Movistar STB) switch to the WebGL-side premultiply fallback. Set to a
+   * boolean to force the value (`false` forces the GL-premultiply fallback;
+   * `true` skips it). Leave unset to assume the option is honored — the
+   * default, which preserves existing behavior with no probe overhead.
+   *
+   * @defaultValue `true` (assume honored; no probe)
    */
   premultiplyAlphaHonored?: boolean | 'auto';
 
@@ -825,11 +825,11 @@ export class RendererMain extends EventEmitter {
       textureProcessingTimeLimit: settings.textureProcessingTimeLimit || 10,
       canvas: settings.canvas,
       createImageBitmapSupport: settings.createImageBitmapSupport || 'auto',
-      // undefined -> 'auto' (probe once at startup); 'auto' -> probe;
-      // explicit boolean -> force the value, skip the probe.
+      // undefined -> true (assume honored, no probe); 'auto' -> probe;
+      // explicit boolean -> force the value.
       premultiplyAlphaHonored:
         settings.premultiplyAlphaHonored === undefined
-          ? 'auto'
+          ? true
           : settings.premultiplyAlphaHonored,
       platform: settings.platform || null,
       maxRetryCount: settings.maxRetryCount ?? 5,