@solidtv/renderer 1.5.2 → 1.5.4

package/src/core/TextureMemoryManager.ts

@@ -349,7 +349,7 @@ export class TextureMemoryManager {
       if (
         evictable === true &&
         texture.preventCleanup === false &&
-        texture.renderableOwners.length === 0 &&
+        texture.renderableOwners.size === 0 &&
         texture.hasListeners() === false
       ) {
         this.destroyTexture(texture);

package/src/core/lib/collectionUtils.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import type { CoreNode } from '../CoreNode.js';
+import { sortByZIndexStable } from './collectionUtils.js';
+
+const makeNode = (zIndex: number, tag: number): CoreNode =>
+  ({ props: { zIndex }, tag } as unknown as CoreNode);
+
+const tags = (nodes: CoreNode[]): number[] => {
+  const out: number[] = [];
+  for (let i = 0; i < nodes.length; i++) {
+    out.push((nodes[i] as unknown as { tag: number }).tag);
+  }
+  return out;
+};
+
+describe('sortByZIndexStable', () => {
+  it('should sort nodes ascending by zIndex', () => {
+    const nodes = [makeNode(3, 0), makeNode(1, 1), makeNode(2, 2)];
+
+    sortByZIndexStable(nodes);
+
+    expect(tags(nodes)).toEqual([1, 2, 0]);
+  });
+
+  it('should preserve insertion order for equal zIndex values', () => {
+    const nodes = [
+      makeNode(1, 0),
+      makeNode(0, 1),
+      makeNode(1, 2),
+      makeNode(0, 3),
+      makeNode(1, 4),
+    ];
+
+    sortByZIndexStable(nodes);
+
+    expect(tags(nodes)).toEqual([1, 3, 0, 2, 4]);
+  });
+
+  it('should be stable for arrays longer than 10 elements', () => {
+    // V8 on Chrome < 70 switched to an unstable quicksort above 10 elements;
+    // this guards the case the native sort got wrong.
+    const nodes: CoreNode[] = [];
+    for (let i = 0; i < 20; i++) {
+      nodes.push(makeNode(i % 2, i));
+    }
+
+    sortByZIndexStable(nodes);
+
+    const expected: number[] = [];
+    for (let i = 0; i < 20; i += 2) {
+      expected.push(i);
+    }
+    for (let i = 1; i < 20; i += 2) {
+      expected.push(i);
+    }
+    expect(tags(nodes)).toEqual(expected);
+  });
+
+  it('should handle negative and fractional zIndex values', () => {
+    const nodes = [
+      makeNode(0.5, 0),
+      makeNode(-2, 1),
+      makeNode(1000000000, 2),
+      makeNode(0, 3),
+      makeNode(-2, 4),
+    ];
+
+    sortByZIndexStable(nodes);
+
+    expect(tags(nodes)).toEqual([1, 4, 3, 0, 2]);
+  });
+
+  it('should leave an already sorted array unchanged', () => {
+    const nodes = [makeNode(0, 0), makeNode(0, 1), makeNode(1, 2)];
+
+    sortByZIndexStable(nodes);
+
+    expect(tags(nodes)).toEqual([0, 1, 2]);
+  });
+
+  it('should handle empty and single-element arrays', () => {
+    const empty: CoreNode[] = [];
+    const single = [makeNode(5, 0)];
+
+    sortByZIndexStable(empty);
+    sortByZIndexStable(single);
+
+    expect(empty.length).toBe(0);
+    expect(tags(single)).toEqual([0]);
+  });
+});

package/src/core/lib/collectionUtils.ts

@@ -1,44 +1,23 @@
 import type { CoreNode } from '../CoreNode.js';
 
-//Bucket sort implementation for sorting CoreNode arrays by zIndex
-export const bucketSortByZIndex = (nodes: CoreNode[], min: number): void => {
-  const buckets: CoreNode[][] = [];
-  const bucketIndices: number[] = [];
-  //distribute nodes into buckets
-  for (let i = 0; i < nodes.length; i++) {
+// Stable in-place sort by zIndex. Array.prototype.sort is not stable on
+// Chrome < 70 (V8 quicksorts arrays longer than 10), and equal-zIndex
+// siblings must keep insertion order or paint order silently reshuffles.
+// Children arrays are small and nearly sorted (kept sorted; a re-sort
+// usually follows a single zIndex change), so insertion sort is O(n) in
+// practice and allocation-free.
+export const sortByZIndexStable = (nodes: CoreNode[]): void => {
+  const len = nodes.length;
+  for (let i = 1; i < len; i++) {
     const node = nodes[i]!;
-    const index = node.props.zIndex - min;
-    //create bucket if it doesn't exist
-    if (buckets[index] === undefined) {
-      buckets[index] = [];
-      bucketIndices.push(index);
-    }
-    buckets[index]!.push(node);
-  }
-
-  //sort each bucket using insertion sort
-  for (let i = 1; i < bucketIndices.length; i++) {
-    const key = bucketIndices[i]!;
+    const z = node.props.zIndex;
     let j = i - 1;
-    while (j >= 0 && bucketIndices[j]! > key) {
-      bucketIndices[j + 1] = bucketIndices[j]!;
+    while (j >= 0 && nodes[j]!.props.zIndex > z) {
+      nodes[j + 1] = nodes[j]!;
       j--;
     }
-    bucketIndices[j + 1] = key;
+    nodes[j + 1] = node;
   }
-
-  //flatten buckets
-  let idx = 0;
-  for (let i = 0; i < bucketIndices.length; i++) {
-    const bucket = buckets[bucketIndices[i]!]!;
-    for (let j = 0; j < bucket.length; j++) {
-      nodes[idx++] = bucket[j]!;
-    }
-  }
-
-  //clean up
-  buckets.length = 0;
-  bucketIndices.length = 0;
 };
 
 export const incrementalRepositionByZIndex = (

package/src/core/renderers/webgl/WebGlCtxTexture.ts

@@ -161,10 +161,11 @@ export class WebGlCtxTexture extends CoreContextTexture {
       );
     }
 
-    // Set to a 1x1 transparent texture
-    glw.texImage2D(0, glw.RGBA, 1, 1, 0, glw.RGBA, glw.UNSIGNED_BYTE, null);
-    this.setTextureMemUse(TRANSPARENT_TEXTURE_DATA.byteLength);
-
+    // No placeholder upload here: every branch below fully (re)uploads the
+    // texture before this method returns, and there is no `await` in between,
+    // so no frame can render an intermediate 1x1. The empty-texture case
+    // (`tdata === null`) does its own 1x1 upload. Uploading a throwaway 1x1
+    // first would be a wasted texImage2D + setTextureMemUse per texture.
     let w = 0;
     let h = 0;
 

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