@solidtv/renderer 1.5.3 → 1.5.5

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

@@ -1,5 +1,10 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { loadFont } from '../SdfFontHandler.js';
+import {
+  loadFont,
+  waitingForFont,
+  isFontLoaded,
+  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';
@@ -14,7 +19,19 @@ class FakeXHR {
   onerror: (() => void) | null = null;
   open(): void {}
   send(): void {
-    this.response = { chars: [{}] };
+    // Enough shape for processFontData to run on the success path without
+    // throwing: a chars array, an (empty) kernings array, and metrics so it
+    // skips the atlas-derived cap/x-height branches.
+    this.response = {
+      chars: [{}],
+      kernings: [],
+      lightningMetrics: {
+        ascender: 800,
+        descender: -200,
+        lineGap: 200,
+        unitsPerEm: 1000,
+      },
+    };
     if (this.onload !== null) {
       this.onload();
     }
@@ -34,15 +51,59 @@ function makeFakeTexture() {
   return tex;
 }
 
+type FakeTexture = ReturnType<typeof makeFakeTexture>;
+
+// A stage whose txManager hands out a fresh fake texture per loadFont attempt
+// (so each retry has its own texture to fail/succeed) and records them.
+function makeStage(): { stage: Stage; textures: FakeTexture[] } {
+  const textures: FakeTexture[] = [];
+  const stage = {
+    txManager: {
+      createTexture: () => {
+        const t = makeFakeTexture();
+        textures.push(t);
+        return t;
+      },
+      // loadFont evicts a failed atlas before retrying; a no-op is enough here.
+      removeTextureFromCache: () => {},
+    },
+  } as unknown as Stage;
+  return { stage, textures };
+}
+
+const opts = (fontFamily: string) =>
+  ({
+    fontFamily,
+    atlasUrl: 'atlas.png',
+    atlasDataUrl: 'atlas.json',
+  } as Parameters<typeof loadFont>[1]);
+
 // Drain microtasks + one macrotask so the async loader reaches listener setup.
 const flush = (): Promise<void> => new Promise((r) => setTimeout(r, 0));
 
-describe('SdfFontHandler loadFont — failed event argument', () => {
+// Fail every attempt: each iteration waits for the next attempt to wire up its
+// atlas listener, then fires 'failed' on that attempt's texture.
+async function failAllAttempts(
+  textures: FakeTexture[],
+  error: TextureError,
+  attempts: number,
+): Promise<void> {
+  for (let i = 0; i < attempts; i++) {
+    await flush();
+    textures[i]!.emit('failed', error);
+  }
+}
+
+const TOTAL_ATTEMPTS = MAX_FONT_LOAD_RETRIES + 1; // initial + retries
+
+describe('SdfFontHandler loadFont — failure after exhausting retries', () => {
   let errSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof vi.spyOn>;
   let originalXHR: unknown;
 
   beforeEach(() => {
     errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
     originalXHR = (globalThis as unknown as { XMLHttpRequest: unknown })
       .XMLHttpRequest;
     (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
@@ -51,62 +112,147 @@ describe('SdfFontHandler loadFont — failed event argument', () => {
 
   afterEach(() => {
     errSpy.mockRestore();
+    warnSpy.mockRestore();
     (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
       originalXHR;
   });
 
-  it('rejects with the TextureError (second emit arg), not the emitting texture', async () => {
-    const tex = makeFakeTexture();
-    const stage = {
-      txManager: { createTexture: () => tex },
-    } as unknown as Stage;
+  it('rejects with the last TextureError (second emit arg), not the emitting texture', async () => {
+    const { stage, textures } = makeStage();
+    const promise = loadFont(stage, opts('TestSdfFailFont'));
 
-    const promise = loadFont(stage, {
-      fontFamily: 'TestSdfFailFont',
-      atlasUrl: 'atlas.png',
-      atlasDataUrl: 'atlas.json',
-    } as Parameters<typeof loadFont>[1]);
+    const error = new TextureError(
+      TextureErrorCode.TEXTURE_UPLOAD_FAILED,
+      'boom',
+    );
 
-    await flush();
+    // Attach the rejection assertion before driving failures.
+    const assertion = expect(promise).rejects.toBe(error);
+    await failAllAttempts(textures, error, TOTAL_ATTEMPTS);
+    await assertion;
+  });
+
+  it('logs the error, not the texture, after the final attempt', async () => {
+    const { stage, textures } = makeStage();
+    const promise = loadFont(stage, opts('TestSdfFailFontLog'));
 
     const error = new TextureError(
       TextureErrorCode.TEXTURE_UPLOAD_FAILED,
       'boom',
     );
+    const rejected = promise.catch(() => {});
+    await failAllAttempts(textures, error, TOTAL_ATTEMPTS);
+    await rejected;
 
-    // Attach the rejection assertion before emitting so the handler is ready.
-    const assertion = expect(promise).rejects.toBe(error);
+    const lastCall = errSpy.mock.calls[errSpy.mock.calls.length - 1]!;
+    expect(lastCall[1]).toBe(error);
+    expect(lastCall[1]).not.toBe(textures[textures.length - 1]);
+  });
 
-    // EventEmitter calls listeners as (target, data) -> (tex, error).
-    tex.emit('failed', error);
+  it('attempts the load exactly initial + MAX_FONT_LOAD_RETRIES times', async () => {
+    const { stage, textures } = makeStage();
+    const promise = loadFont(stage, opts('TestSdfAttemptCount'));
 
-    await assertion;
+    const error = new TextureError(
+      TextureErrorCode.TEXTURE_UPLOAD_FAILED,
+      'boom',
+    );
+    const rejected = promise.catch(() => {});
+    await failAllAttempts(textures, error, TOTAL_ATTEMPTS);
+    await rejected;
+
+    // One texture is created per attempt; no further attempts after exhaustion.
+    expect(textures.length).toBe(TOTAL_ATTEMPTS);
+    // A warning per retried attempt, error only on the final failure.
+    expect(warnSpy).toHaveBeenCalledTimes(MAX_FONT_LOAD_RETRIES);
+    expect(errSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('SdfFontHandler loadFont — automatic retry', () => {
+  let errSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof vi.spyOn>;
+  let originalXHR: unknown;
+
+  beforeEach(() => {
+    errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    originalXHR = (globalThis as unknown as { XMLHttpRequest: unknown })
+      .XMLHttpRequest;
+    (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
+      FakeXHR;
+  });
+
+  afterEach(() => {
+    errSpy.mockRestore();
+    warnSpy.mockRestore();
+    (globalThis as unknown as { XMLHttpRequest: unknown }).XMLHttpRequest =
+      originalXHR;
   });
 
-  it('logs the error, not the texture, on failure', async () => {
-    const tex = makeFakeTexture();
-    const stage = {
-      txManager: { createTexture: () => tex },
-    } as unknown as Stage;
+  it('recovers when a retry succeeds and wakes nodes parked before the failure', async () => {
+    const { stage, textures } = makeStage();
+    const fontFamily = 'RetryRecoverFont';
+
+    const promise = loadFont(stage, opts(fontFamily));
 
-    const promise = loadFont(stage, {
-      fontFamily: 'TestSdfFailFontLog',
-      atlasUrl: 'atlas.png',
-      atlasDataUrl: 'atlas.json',
-    } as Parameters<typeof loadFont>[1]);
+    // Park a node while the font is loading (waiter list exists synchronously).
+    const node = { id: 1, setUpdateType: vi.fn() };
+    waitingForFont(
+      fontFamily,
+      node as unknown as Parameters<typeof waitingForFont>[1],
+    );
 
+    // First attempt fails...
     await flush();
+    textures[0]!.emit(
+      'failed',
+      new TextureError(TextureErrorCode.TEXTURE_UPLOAD_FAILED, 'boom'),
+    );
 
+    // ...the automatic retry succeeds.
+    await flush();
+    textures[1]!.emit('loaded');
+    await promise;
+
+    expect(isFontLoaded(fontFamily)).toBe(true);
+    expect(node.setUpdateType).toHaveBeenCalledTimes(1);
+    // Only two attempts were needed.
+    expect(textures.length).toBe(2);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(errSpy).not.toHaveBeenCalled();
+  });
+
+  it('keeps parked nodes after every retry fails so a later loadFont still wakes them', async () => {
+    const { stage, textures } = makeStage();
+    const fontFamily = 'RetryExhaustReuseFont';
     const error = new TextureError(
       TextureErrorCode.TEXTURE_UPLOAD_FAILED,
       'boom',
     );
-    const rejected = promise.catch(() => {});
-    tex.emit('failed', error);
-    await rejected;
 
-    const lastCall = errSpy.mock.calls[errSpy.mock.calls.length - 1]!;
-    expect(lastCall[1]).toBe(error);
-    expect(lastCall[1]).not.toBe(tex);
+    const first = loadFont(stage, opts(fontFamily));
+    const firstRejected = first.catch(() => {});
+
+    const node = { id: 1, setUpdateType: vi.fn() };
+    waitingForFont(
+      fontFamily,
+      node as unknown as Parameters<typeof waitingForFont>[1],
+    );
+
+    await failAllAttempts(textures, error, TOTAL_ATTEMPTS);
+    await firstRejected;
+
+    expect(isFontLoaded(fontFamily)).toBe(false);
+    expect(node.setUpdateType).not.toHaveBeenCalled();
+
+    // A fresh load reuses the still-parked node and wakes it on success.
+    const second = loadFont(stage, opts(fontFamily));
+    await flush();
+    textures[TOTAL_ATTEMPTS]!.emit('loaded');
+    await second;
+
+    expect(isFontLoaded(fontFamily)).toBe(true);
+    expect(node.setUpdateType).toHaveBeenCalledTimes(1);
   });
 });

package/src/core/textures/ImageTexture.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ImageTexture } from './ImageTexture.js';
+import type { CoreTextureManager } from '../CoreTextureManager.js';
+
+describe('ImageTexture.createImageBitmap', () => {
+  beforeEach(() => {
+    vi.stubGlobal('ImageBitmap', class {});
+  });
+
+  it('passes options to createImageBitmap when no crop is requested and options/full are supported', async () => {
+    const createImageBitmapMock = vi.fn(() =>
+      Promise.resolve({ close: () => {} }),
+    );
+    const txManager = {
+      imageBitmapSupported: {
+        basic: true,
+        options: true,
+        full: true,
+        premultiplyHonored: false,
+      },
+      platform: {
+        createImageBitmap: createImageBitmapMock,
+      },
+    } as unknown as CoreTextureManager;
+
+    const props = ImageTexture.resolveDefaults({
+      src: 'test.png',
+      premultiplyAlpha: true,
+    });
+    const texture = new ImageTexture(txManager, props);
+
+    const blob = new Blob([], { type: 'image/png' });
+    const result = await texture.createImageBitmap(
+      blob,
+      true,
+      null,
+      null,
+      null,
+      null,
+    );
+
+    // It should have called createImageBitmap with the options object
+    expect(createImageBitmapMock).toHaveBeenCalledWith(blob, {
+      premultiplyAlpha: 'none',
+      colorSpaceConversion: 'none',
+      imageOrientation: 'none',
+    });
+
+    // Since premultiplyHonored is false, useGlPremultiply should be true
+    expect(result.premultiplyAlpha).toBe(true);
+  });
+
+  it('falls back to basic createImageBitmap when options are not supported', async () => {
+    const createImageBitmapMock = vi.fn(() =>
+      Promise.resolve({ close: () => {} }),
+    );
+    const txManager = {
+      imageBitmapSupported: {
+        basic: true,
+        options: false,
+        full: false,
+        premultiplyHonored: null,
+      },
+      platform: {
+        createImageBitmap: createImageBitmapMock,
+      },
+    } as unknown as CoreTextureManager;
+
+    const props = ImageTexture.resolveDefaults({
+      src: 'test.png',
+      premultiplyAlpha: true,
+    });
+    const texture = new ImageTexture(txManager, props);
+
+    const blob = new Blob([], { type: 'image/png' });
+    const result = await texture.createImageBitmap(
+      blob,
+      true,
+      null,
+      null,
+      null,
+      null,
+    );
+
+    // It should have called basic createImageBitmap without options
+    expect(createImageBitmapMock).toHaveBeenCalledWith(blob);
+
+    // And premultiplyAlpha should be false (browser default is assumed to premultiply)
+    expect(result.premultiplyAlpha).toBe(false);
+  });
+});

package/src/core/textures/ImageTexture.ts

@@ -219,7 +219,10 @@ export class ImageTexture extends Texture {
         },
       );
       return { data: bitmap, premultiplyAlpha: useGlPremultiply };
-    } else if (imageBitmapSupported.basic === true) {
+    } else if (
+      imageBitmapSupported.options === false &&
+      imageBitmapSupported.full === false
+    ) {
       // basic createImageBitmap without options or crop
       // this is supported for Chrome v50 to v52/54 that doesn't support options.
       // The browser default premultiplies, so WebGL must not premultiply again.

package/src/core/textures/SubTexture.ts

@@ -79,7 +79,7 @@ export class SubTexture extends Texture {
     // Resolve parent texture from cache or fallback to provided texture
     this.parentTexture = txManager.resolveParentTexture(this.props.texture);
 
-    if (this.renderableOwners.length > 0) {
+    if (this.renderableOwners.size > 0) {
       this.parentTexture.setRenderableOwner(this.subtextureId, true);
     }
 

package/src/core/textures/Texture.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Texture, type TextureData } from './Texture.js';
+import type { CoreTextureManager } from '../CoreTextureManager.js';
+
+class TestTexture extends Texture {
+  override async getTextureSource(): Promise<TextureData> {
+    return { data: null };
+  }
+}
+
+function makeTexture(): {
+  texture: TestTexture;
+  loadTexture: ReturnType<typeof vi.fn>;
+  onChangeIsRenderable: ReturnType<typeof vi.fn>;
+} {
+  const loadTexture = vi.fn();
+  const txManager = {
+    maxRetryCount: 3,
+    loadTexture,
+  } as unknown as CoreTextureManager;
+  const texture = new TestTexture(txManager);
+  const onChangeIsRenderable = vi.fn();
+  texture.onChangeIsRenderable = onChangeIsRenderable;
+  return { texture, loadTexture, onChangeIsRenderable };
+}
+
+describe('Texture.setRenderableOwner', () => {
+  it('adding an owner fires the 0→1 transition exactly once and loads', () => {
+    const { texture, loadTexture, onChangeIsRenderable } = makeTexture();
+
+    texture.setRenderableOwner(1, true);
+
+    expect(texture.renderableOwners.size).toBe(1);
+    expect(texture.renderable).toBe(true);
+    expect(onChangeIsRenderable).toHaveBeenCalledTimes(1);
+    expect(onChangeIsRenderable).toHaveBeenCalledWith(true);
+    expect(loadTexture).toHaveBeenCalledTimes(1);
+  });
+
+  it('double-add of the same owner is a no-op (size stays 1, one event)', () => {
+    const { texture, loadTexture, onChangeIsRenderable } = makeTexture();
+
+    texture.setRenderableOwner(1, true);
+    texture.setRenderableOwner(1, true);
+
+    expect(texture.renderableOwners.size).toBe(1);
+    expect(onChangeIsRenderable).toHaveBeenCalledTimes(1);
+    expect(loadTexture).toHaveBeenCalledTimes(1);
+  });
+
+  it('a second distinct owner does not re-fire the transition', () => {
+    const { texture, loadTexture, onChangeIsRenderable } = makeTexture();
+
+    texture.setRenderableOwner(1, true);
+    texture.setRenderableOwner(2, true);
+
+    expect(texture.renderableOwners.size).toBe(2);
+    expect(onChangeIsRenderable).toHaveBeenCalledTimes(1);
+    expect(loadTexture).toHaveBeenCalledTimes(1);
+  });
+
+  it('removing a non-member owner does not fire a transition', () => {
+    const { texture, onChangeIsRenderable } = makeTexture();
+
+    texture.setRenderableOwner(1, false);
+
+    expect(texture.renderableOwners.size).toBe(0);
+    expect(texture.renderable).toBe(false);
+    expect(onChangeIsRenderable).not.toHaveBeenCalled();
+  });
+
+  it('1→0 fires onChangeIsRenderable(false) exactly once', () => {
+    const { texture, onChangeIsRenderable } = makeTexture();
+
+    texture.setRenderableOwner(1, true);
+    texture.setRenderableOwner(1, false);
+    texture.setRenderableOwner(1, false);
+
+    expect(texture.renderableOwners.size).toBe(0);
+    expect(texture.renderable).toBe(false);
+    expect(onChangeIsRenderable).toHaveBeenCalledTimes(2);
+    expect(onChangeIsRenderable).toHaveBeenLastCalledWith(false);
+  });
+
+  it('re-adding an owner after 1→0 triggers load again (freed→reload cycle)', () => {
+    const { texture, loadTexture } = makeTexture();
+
+    texture.setRenderableOwner(1, true);
+    texture.setRenderableOwner(1, false);
+    texture.setRenderableOwner(1, true);
+
+    expect(texture.renderable).toBe(true);
+    expect(loadTexture).toHaveBeenCalledTimes(2);
+  });
+
+  it('string and number owners coexist (node ids vs subtexture/font keys)', () => {
+    const { texture } = makeTexture();
+
+    texture.setRenderableOwner(7, true);
+    texture.setRenderableOwner('subtexture-7', true);
+
+    expect(texture.renderableOwners.size).toBe(2);
+
+    texture.setRenderableOwner(7, false);
+    expect(texture.renderableOwners.size).toBe(1);
+    expect(texture.renderable).toBe(true);
+
+    texture.setRenderableOwner('subtexture-7', false);
+    expect(texture.renderableOwners.size).toBe(0);
+    expect(texture.renderable).toBe(false);
+  });
+
+  it('canBeCleanedUp respects remaining owners', () => {
+    const { texture } = makeTexture();
+    // Skip the startup grace period so owners are the deciding factor.
+    texture.isWithinStartupGracePeriod = () => false;
+
+    texture.setRenderableOwner(1, true);
+    expect(texture.canBeCleanedUp()).toBe(false);
+
+    texture.setRenderableOwner(1, false);
+    expect(texture.canBeCleanedUp()).toBe(true);
+  });
+});

package/src/core/textures/Texture.ts

@@ -141,7 +141,7 @@ export abstract class Texture extends EventEmitter {
   // aggregate state
   public state: TextureState = 'initial';
 
-  readonly renderableOwners: any[] = [];
+  readonly renderableOwners: Set<string | number> = new Set();
 
   readonly renderable: boolean = false;
 
@@ -251,7 +251,7 @@ export abstract class Texture extends EventEmitter {
     }
 
     // Don't cleanup if there are still renderable owners
-    if (this.renderableOwners.length > 0) {
+    if (this.renderableOwners.size > 0) {
       return false;
     }
 
@@ -274,28 +274,25 @@ export abstract class Texture extends EventEmitter {
    * @param renderable
    */
   setRenderableOwner(owner: string | number, renderable: boolean): void {
-    const oldSize = this.renderableOwners.length;
-    const hasOwnerIndex = this.renderableOwners.indexOf(owner);
+    const owners = this.renderableOwners;
 
     if (renderable === true) {
-      if (hasOwnerIndex === -1) {
-        // Add the owner to the set
-        this.renderableOwners.push(owner);
+      if (owners.has(owner) === true) {
+        return;
       }
 
-      const newSize = this.renderableOwners.length;
-      if (oldSize !== newSize && newSize === 1) {
+      owners.add(owner);
+      if (owners.size === 1) {
         (this.renderable as boolean) = true;
         this.onChangeIsRenderable?.(true);
         this.load();
       }
     } else {
-      if (hasOwnerIndex !== -1) {
-        this.renderableOwners.splice(hasOwnerIndex, 1);
+      if (owners.delete(owner) === false) {
+        return;
       }
 
-      const newSize = this.renderableOwners.length;
-      if (oldSize !== newSize && newSize === 0) {
+      if (owners.size === 0) {
         (this.renderable as boolean) = false;
         this.onChangeIsRenderable?.(false);
 

package/src/main-api/Inspector.ts

@@ -1104,7 +1104,7 @@ export class Inspector {
     // Update renderable owners count
     div.setAttribute(
       'data-texture-owners',
-      String(texture.renderableOwners.length),
+      String(texture.renderableOwners.size),
     );
 
     // Update retry count