@flighthq/scene2d 0.2.1-next.840.857425c

package/src/renderView.test.ts

@@ -0,0 +1,104 @@
+import { createRectangle } from '@flighthq/geometry';
+import type { Node, RenderView, RenderViewRenderer } from '@flighthq/types';
+import { RenderViewKind } from '@flighthq/types';
+
+import {
+  computeRenderViewLocalBoundsRectangle,
+  createRenderView,
+  createRenderViewData,
+  createRenderViewRuntime,
+  getRenderViewRuntime,
+  setRenderViewSize,
+} from './renderView';
+
+function makeRenderer(): RenderViewRenderer {
+  const canvas = document.createElement('canvas');
+  canvas.width = 100;
+  canvas.height = 100;
+  return { canvas, render: () => {} };
+}
+
+describe('computeRenderViewLocalBoundsRectangle', () => {
+  it('writes width and height from data', () => {
+    const view = createRenderView({ data: { width: 400, height: 300 } });
+    const out = createRectangle(0, 0, 0, 0);
+    computeRenderViewLocalBoundsRectangle(out, view as unknown as Node);
+    expect(out.width).toBe(400);
+    expect(out.height).toBe(300);
+  });
+});
+
+describe('createRenderView', () => {
+  let view: RenderView;
+
+  beforeEach(() => {
+    view = createRenderView();
+  });
+
+  it('initializes default values', () => {
+    expect(view.data.renderer).toBeNull();
+    expect(view.data.width).toBe(0);
+    expect(view.data.height).toBe(0);
+    expect(view.kind).toStrictEqual(RenderViewKind);
+  });
+
+  it('allows pre-defined values', () => {
+    const renderer = makeRenderer();
+    const obj = createRenderView({ data: { renderer, width: 320, height: 240 } });
+    expect(obj.data.renderer).toStrictEqual(renderer);
+    expect(obj.data.width).toBe(320);
+    expect(obj.data.height).toBe(240);
+  });
+
+  it('returns a new object for better hidden-class performance', () => {
+    const base = {};
+    const obj = createRenderView(base);
+    expect(obj).not.toStrictEqual(base);
+  });
+});
+
+describe('createRenderViewData', () => {
+  it('returns default values', () => {
+    const data = createRenderViewData();
+    expect(data.renderer).toBeNull();
+    expect(data.width).toBe(0);
+    expect(data.height).toBe(0);
+  });
+
+  it('allows pre-defined values', () => {
+    const renderer = makeRenderer();
+    const data = createRenderViewData({ renderer, width: 800, height: 600 });
+    expect(data.renderer).toStrictEqual(renderer);
+    expect(data.width).toBe(800);
+    expect(data.height).toBe(600);
+  });
+});
+
+describe('createRenderViewRuntime', () => {
+  it('returns a non-null runtime', () => {
+    expect(createRenderViewRuntime()).not.toBeNull();
+  });
+});
+
+describe('getRenderViewRuntime', () => {
+  it('returns the runtime for a RenderView', () => {
+    const view = createRenderView();
+    expect(getRenderViewRuntime(view)).not.toBeNull();
+  });
+});
+
+describe('setRenderViewSize', () => {
+  it('updates width and height', () => {
+    const view = createRenderView();
+    setRenderViewSize(view, 640, 480);
+    expect(view.data.width).toBe(640);
+    expect(view.data.height).toBe(480);
+  });
+
+  it('is a no-op when size is unchanged', () => {
+    const view = createRenderView({ data: { width: 100, height: 100 } });
+    const before = view.data.width;
+    setRenderViewSize(view, 100, 100);
+    expect(view.data.width).toBe(before);
+  });
+});

package/src/scene2d.test.ts

@@ -0,0 +1,165 @@
+import { addNodeChild } from '@flighthq/node';
+import { connectSignal } from '@flighthq/signals';
+import type { Scene2D } from '@flighthq/types';
+
+import { createDisplayObject } from './displayObject';
+import {
+  createScene2D,
+  createScene2DRuntime,
+  createScene2DSignals,
+  enableScene2DSignals,
+  getScene2DRoot,
+  getScene2DRuntime,
+  getScene2DSignals,
+  setScene2DSize,
+} from './scene2d';
+
+describe('createScene2D', () => {
+  let scene2d: Scene2D;
+
+  beforeEach(() => {
+    scene2d = createScene2D();
+  });
+
+  it('initializes default values', () => {
+    expect(scene2d.color).toBe(null);
+    expect(scene2d.scene2dHeight).toBe(550);
+    expect(scene2d.scene2dWidth).toBe(400);
+    expect(scene2d.align).toBe('topleft');
+    expect(scene2d.scaleMode).toBe('noscale');
+  });
+
+  it('allocates a display-object root the scene2d points back to', () => {
+    expect(scene2d.root).toBeDefined();
+    expect(getScene2DRoot(scene2d.root)).toBe(scene2d);
+  });
+
+  it('allows pre-defined values', () => {
+    const obj = createScene2D({ color: 0xff0000ff, scene2dHeight: 1000, scene2dWidth: 2000 });
+    expect(obj.color).toStrictEqual(0xff0000ff);
+    expect(obj.scene2dHeight).toStrictEqual(1000);
+    expect(obj.scene2dWidth).toStrictEqual(2000);
+  });
+});
+
+describe('createScene2DRuntime', () => {
+  it('returns a non-null runtime with scene2dSignals initialized to null', () => {
+    const runtime = createScene2DRuntime();
+    expect(runtime).not.toBeNull();
+    expect(runtime.scene2dSignals).toBeNull();
+  });
+});
+
+describe('createScene2DSignals', () => {
+  it('returns an object with all signal properties', () => {
+    const signals = createScene2DSignals();
+    expect(signals.onResize).toBeDefined();
+    expect(signals.onFullscreenChanged).toBeDefined();
+    expect(signals.onOrientationChanged).toBeDefined();
+  });
+});
+
+describe('enableScene2DSignals', () => {
+  it('creates and returns signals on first call', () => {
+    const scene2d = createScene2D();
+    const signals = enableScene2DSignals(scene2d);
+    expect(signals).toBeDefined();
+    expect(signals.onResize).toBeDefined();
+  });
+
+  it('returns the same object on subsequent calls', () => {
+    const scene2d = createScene2D();
+    expect(enableScene2DSignals(scene2d)).toBe(enableScene2DSignals(scene2d));
+  });
+
+  it('makes getScene2DSignals return the enabled object', () => {
+    const scene2d = createScene2D();
+    const signals = enableScene2DSignals(scene2d);
+    expect(getScene2DSignals(scene2d)).toBe(signals);
+  });
+});
+
+describe('getScene2DRoot', () => {
+  it('returns null when the node has no parent', () => {
+    const obj = createDisplayObject();
+    expect(getScene2DRoot(obj)).toBeNull();
+  });
+
+  it('returns null when the root is not owned by a Scene2D', () => {
+    const root = createDisplayObject();
+    const child = createDisplayObject();
+    addNodeChild(root, child);
+    expect(getScene2DRoot(child)).toBeNull();
+  });
+
+  it('returns the Scene2D when a child is added under its root', () => {
+    const scene2d = createScene2D();
+    const child = createDisplayObject();
+    addNodeChild(scene2d.root, child);
+    expect(getScene2DRoot(child)).toBe(scene2d);
+  });
+
+  it('returns the Scene2D from a deeply nested node', () => {
+    const scene2d = createScene2D();
+    const mid = createDisplayObject();
+    const leaf = createDisplayObject();
+    addNodeChild(scene2d.root, mid);
+    addNodeChild(mid, leaf);
+    expect(getScene2DRoot(leaf)).toBe(scene2d);
+  });
+});
+
+describe('getScene2DRuntime', () => {
+  it('returns the runtime for a Scene2D', () => {
+    const scene2d = createScene2D();
+    const runtime = getScene2DRuntime(scene2d);
+    expect(runtime).not.toBeNull();
+  });
+});
+
+describe('getScene2DSignals', () => {
+  it('returns null before signals are enabled', () => {
+    const scene2d = createScene2D();
+    expect(getScene2DSignals(scene2d)).toBeNull();
+  });
+
+  it('returns the signals after enableScene2DSignals', () => {
+    const scene2d = createScene2D();
+    const signals = enableScene2DSignals(scene2d);
+    expect(getScene2DSignals(scene2d)).toBe(signals);
+  });
+});
+
+describe('setScene2DSize', () => {
+  it('updates scene2dWidth and scene2dHeight', () => {
+    const scene2d = createScene2D();
+    setScene2DSize(scene2d, 1920, 1080);
+    expect(scene2d.scene2dWidth).toBe(1920);
+    expect(scene2d.scene2dHeight).toBe(1080);
+  });
+
+  it('emits onResize when dimensions change', () => {
+    const scene2d = createScene2D();
+    let called = false;
+    connectSignal(enableScene2DSignals(scene2d).onResize, () => {
+      called = true;
+    });
+    setScene2DSize(scene2d, 1280, 720);
+    expect(called).toBe(true);
+  });
+
+  it('does not emit onResize when dimensions are unchanged', () => {
+    const scene2d = createScene2D({ scene2dWidth: 400, scene2dHeight: 300 });
+    let called = false;
+    connectSignal(enableScene2DSignals(scene2d).onResize, () => {
+      called = true;
+    });
+    setScene2DSize(scene2d, 400, 300);
+    expect(called).toBe(false);
+  });
+
+  it('does not emit onResize when no one has subscribed', () => {
+    const scene2d = createScene2D();
+    expect(() => setScene2DSize(scene2d, 1280, 720)).not.toThrow();
+  });
+});

package/src/video.test.ts

@@ -0,0 +1,113 @@
+import { getNodeLocalBoundsRevision, getNodeLocalContentRevision, getNodeLocalTransformRevision } from '@flighthq/node';
+import type { Video } from '@flighthq/types';
+import { VideoKind } from '@flighthq/types';
+
+import {
+  computeVideoLocalBoundsRectangle,
+  createVideo,
+  createVideoData,
+  createVideoRuntime,
+  getVideoRuntime,
+  setVideoSmoothing,
+  setVideoSource,
+} from './video';
+
+describe('computeVideoLocalBoundsRectangle', () => {
+  it('does not modify out when source element is null', () => {
+    const video = createVideo();
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    computeVideoLocalBoundsRectangle(out as never, video as never);
+    expect(out.width).toBe(0);
+    expect(out.height).toBe(0);
+  });
+
+  it('sets out dimensions from the video element', () => {
+    const video = createVideo();
+    const el = document.createElement('video');
+    Object.defineProperty(el, 'videoWidth', { get: () => 320 });
+    Object.defineProperty(el, 'videoHeight', { get: () => 240 });
+    video.data.source = { element: el } as never;
+    const out = { x: 0, y: 0, width: 0, height: 0 };
+    computeVideoLocalBoundsRectangle(out as never, video as never);
+    expect(out.width).toBe(320);
+    expect(out.height).toBe(240);
+  });
+});
+
+describe('createVideo', () => {
+  let video: Video;
+
+  beforeEach(() => {
+    video = createVideo();
+  });
+
+  it('initializes default values', () => {
+    expect(video.data.smoothing).toBe(true);
+    expect(video.kind).toStrictEqual(VideoKind);
+  });
+
+  it('allows pre-defined values', () => {
+    const base = {
+      data: {
+        smoothing: false,
+      },
+    };
+    const obj = createVideo(base);
+    expect(obj.data.smoothing).toStrictEqual(base.data.smoothing);
+  });
+
+  it('returns a new object for better hidden-class performance', () => {
+    const base = {};
+    const obj = createVideo(base);
+    expect(obj).not.toStrictEqual(base);
+  });
+});
+
+describe('createVideoData', () => {
+  it('returns default values', () => {
+    const data = createVideoData();
+    expect(data.smoothing).toBe(true);
+  });
+
+  it('allows pre-defined values', () => {
+    const data = createVideoData({ smoothing: false });
+    expect(data.smoothing).toBe(false);
+  });
+});
+
+describe('createVideoRuntime', () => {
+  it('returns a non-null runtime', () => {
+    const runtime = createVideoRuntime();
+    expect(runtime).not.toBeNull();
+  });
+});
+
+describe('getVideoRuntime', () => {
+  it('returns the runtime for a Video', () => {
+    const video = createVideo();
+    const runtime = getVideoRuntime(video);
+    expect(runtime).not.toBeNull();
+  });
+});
+
+describe('setVideoSmoothing', () => {
+  it('updates the smoothing field', () => {
+    const video = createVideo();
+    setVideoSmoothing(video, false);
+    expect(video.data.smoothing).toBe(false);
+    setVideoSmoothing(video, true);
+    expect(video.data.smoothing).toBe(true);
+  });
+});
+
+describe('setVideoSource', () => {
+  it('updates the source field', () => {
+    const video = createVideo();
+    const el = document.createElement('video');
+    const source = { element: el } as never;
+    setVideoSource(video, source);
+    expect(video.data.source).toBe(source);
+    setVideoSource(video, null);
+    expect(video.data.source).toBeNull();
+  });
+});