@flighthq/application-gl 0.5.1-next.650.5d3df0b → 0.5.1-next.658.9cb44d7

package/README.md

@@ -13,5 +13,5 @@ Import the supported application-facing API from `@flighthq/application-gl`. The
 This package is part of the locked-version Flight SDK graph. Applications may instead install and import `@flighthq/sdk` when package-level tree shaking is sufficient.
 
 - [Flight project](https://github.com/flighthq/flight)
-- [Source for @flighthq/application-gl@0.5.1-next.650.5d3df0b](https://github.com/flighthq/flight/tree/5d3df0b3bd7071e51898ec6ca5f733b81cb94a54/packages/application-gl)
-- [License](https://github.com/flighthq/flight/blob/5d3df0b3bd7071e51898ec6ca5f733b81cb94a54/LICENSE.md)
+- [Source for @flighthq/application-gl@0.5.1-next.658.9cb44d7](https://github.com/flighthq/flight/tree/9cb44d76b981adad2503d5e62207be99adb35c55/packages/application-gl)
+- [License](https://github.com/flighthq/flight/blob/9cb44d76b981adad2503d5e62207be99adb35c55/LICENSE.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/application-gl",
-  "version": "0.5.1-next.650.5d3df0b",
+  "version": "0.5.1-next.658.9cb44d7",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -38,10 +38,10 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/application": "0.5.1-next.650.5d3df0b",
-    "@flighthq/node": "0.5.1-next.650.5d3df0b",
-    "@flighthq/render-gl": "0.5.1-next.650.5d3df0b",
-    "@flighthq/types": "0.5.1-next.650.5d3df0b"
+    "@flighthq/application": "0.5.1-next.658.9cb44d7",
+    "@flighthq/node": "0.5.1-next.658.9cb44d7",
+    "@flighthq/render-gl": "0.5.1-next.658.9cb44d7",
+    "@flighthq/types": "0.5.1-next.658.9cb44d7"
   },
   "devDependencies": {
     "@flighthq/signals": "*",

package/src/glApplicationRenderView.test.ts

@@ -3,60 +3,53 @@ import {
   createApplicationWindow,
   synchronizeApplicationRenderView,
 } from '@flighthq/application/contract';
+import * as nodeContract from '@flighthq/node/contract';
+import * as renderGlContract from '@flighthq/render-gl/contract';
 import { emitSignal } from '@flighthq/signals/contract';
 import type { GlPipeline, GlRenderState, GlRenderTarget } from '@flighthq/types/contract';
 
 import { createGlApplicationRenderView, destroyGlApplicationRenderView } from './glApplicationRenderView';
 
-const mocks = vi.hoisted(() => ({
-  createGlContextFromCanvasElement: vi.fn(),
-  createGlContextState: vi.fn(),
-  createGlRenderState: vi.fn(),
-  createGlRenderTarget: vi.fn(),
-  createViewport: vi.fn(),
-  destroyGlRenderState: vi.fn(),
-  destroyGlRenderTarget: vi.fn(),
-  invalidateGlRenderStateCache: vi.fn(),
-  resizeGlRenderTarget: vi.fn(),
-}));
-
-vi.mock('@flighthq/node/contract', () => ({
-  createViewport: mocks.createViewport,
-}));
-
-vi.mock('@flighthq/render-gl/contract', () => ({
-  createGlContextFromCanvasElement: mocks.createGlContextFromCanvasElement,
-  createGlContextState: mocks.createGlContextState,
-  createGlRenderState: mocks.createGlRenderState,
-  createGlRenderTarget: mocks.createGlRenderTarget,
-  destroyGlRenderState: mocks.destroyGlRenderState,
-  destroyGlRenderTarget: mocks.destroyGlRenderTarget,
-  invalidateGlRenderStateCache: mocks.invalidateGlRenderStateCache,
-  resizeGlRenderTarget: mocks.resizeGlRenderTarget,
-}));
-
 beforeEach(() => {
-  mocks.createGlContextFromCanvasElement.mockImplementation(() => ({ drawingBufferHeight: 0, drawingBufferWidth: 0 }));
-  mocks.createGlContextState.mockImplementation((gl) => ({ gl }));
-  mocks.createGlRenderState.mockImplementation((contextState, _pipeline, options: { pixelRatio: number }) => ({
+  vi.spyOn(nodeContract, 'createViewport').mockImplementation((options) => ({ ...options, x: 0, y: 0 }) as never);
+
+  vi.spyOn(renderGlContract, 'createGlContextFromCanvasElement').mockImplementation(
+    () => ({ drawingBufferHeight: 0, drawingBufferWidth: 0 }) as never,
+  );
+  vi.spyOn(renderGlContract, 'createGlContextState').mockImplementation(((gl: never) => ({ gl })) as never);
+  vi.spyOn(renderGlContract, 'createGlRenderState').mockImplementation(((
+    contextState: never,
+    _pipeline: never,
+    options: { pixelRatio: number },
+  ) => ({
     contextState,
-    gl: contextState.gl,
+    gl: (contextState as { gl: unknown }).gl,
     pixelRatio: options.pixelRatio,
     renderTransform2D: { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 },
-  }));
-  mocks.createGlRenderTarget.mockImplementation(
-    (_state: GlRenderState, descriptor: { height: number; width: number }) => ({
-      height: Math.max(1, descriptor.height),
-      width: Math.max(1, descriptor.width),
-    }),
-  );
-  mocks.createViewport.mockImplementation((options) => ({ ...options, x: 0, y: 0 }));
-  mocks.resizeGlRenderTarget.mockImplementation(
-    (_state: GlRenderState, target: GlRenderTarget, width: number, height: number) => {
-      target.width = Math.max(1, width);
-      target.height = Math.max(1, height);
-    },
-  );
+  })) as never);
+  vi.spyOn(renderGlContract, 'createGlRenderTarget').mockImplementation(((
+    _state: GlRenderState,
+    descriptor: { height: number; width: number },
+  ) => ({
+    height: Math.max(1, descriptor.height),
+    width: Math.max(1, descriptor.width),
+  })) as never);
+  vi.spyOn(renderGlContract, 'destroyGlRenderState').mockImplementation((() => {}) as never);
+  vi.spyOn(renderGlContract, 'destroyGlRenderTarget').mockImplementation((() => {}) as never);
+  vi.spyOn(renderGlContract, 'invalidateGlRenderStateCache').mockImplementation((() => {}) as never);
+  vi.spyOn(renderGlContract, 'resizeGlRenderTarget').mockImplementation(((
+    _state: GlRenderState,
+    target: GlRenderTarget,
+    width: number,
+    height: number,
+  ) => {
+    target.width = Math.max(1, width);
+    target.height = Math.max(1, height);
+  }) as never);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
 });
 
 const pipeline = {} as GlPipeline;
@@ -78,15 +71,19 @@ describe('createGlApplicationRenderView', () => {
 
     expect(canvas.width).toBe(640);
     expect(canvas.height).toBe(360);
-    expect(mocks.createGlContextFromCanvasElement).toHaveBeenCalledWith(canvas, { antialias: false });
-    expect(mocks.createGlContextState).toHaveBeenCalledWith(
-      mocks.createGlContextFromCanvasElement.mock.results[0].value,
+    expect(renderGlContract.createGlContextFromCanvasElement).toHaveBeenCalledWith(canvas, { antialias: false });
+    expect(renderGlContract.createGlContextState).toHaveBeenCalledWith(
+      vi.mocked(renderGlContract.createGlContextFromCanvasElement).mock.results[0].value,
     );
-    expect(mocks.createGlRenderState).toHaveBeenCalledWith(mocks.createGlContextState.mock.results[0].value, pipeline, {
-      pixelRatio: 2,
-      roundPixels: true,
-    });
-    expect(mocks.createGlRenderTarget).toHaveBeenCalledWith(view.renderState, {
+    expect(renderGlContract.createGlRenderState).toHaveBeenCalledWith(
+      vi.mocked(renderGlContract.createGlContextState).mock.results[0].value,
+      pipeline,
+      {
+        pixelRatio: 2,
+        roundPixels: true,
+      },
+    );
+    expect(renderGlContract.createGlRenderTarget).toHaveBeenCalledWith(view.renderState, {
       colorSpace: 'linear',
       depth: 'depth-stencil',
       height: 360,
@@ -101,18 +98,18 @@ describe('createGlApplicationRenderView', () => {
     window.height = 10;
     const canvas = document.createElement('canvas');
     const view = createGlApplicationRenderView(window, canvas, { pipeline });
-    mocks.invalidateGlRenderStateCache.mockClear();
-    mocks.resizeGlRenderTarget.mockClear();
+    vi.mocked(renderGlContract.invalidateGlRenderStateCache).mockClear();
+    vi.mocked(renderGlContract.resizeGlRenderTarget).mockClear();
 
     synchronizeApplicationRenderView(view);
-    expect(mocks.invalidateGlRenderStateCache).not.toHaveBeenCalled();
-    expect(mocks.resizeGlRenderTarget).not.toHaveBeenCalled();
+    expect(renderGlContract.invalidateGlRenderStateCache).not.toHaveBeenCalled();
+    expect(renderGlContract.resizeGlRenderTarget).not.toHaveBeenCalled();
 
     window.width = 30;
     synchronizeApplicationRenderView(view);
     expect(canvas.width).toBe(30);
-    expect(mocks.invalidateGlRenderStateCache).toHaveBeenCalledWith(view.renderState);
-    expect(mocks.resizeGlRenderTarget).toHaveBeenCalledWith(view.renderState, view.renderTarget, 30, 10);
+    expect(renderGlContract.invalidateGlRenderStateCache).toHaveBeenCalledWith(view.renderState);
+    expect(renderGlContract.resizeGlRenderTarget).toHaveBeenCalledWith(view.renderState, view.renderTarget, 30, 10);
   });
 });
 
@@ -123,14 +120,14 @@ describe('destroyGlApplicationRenderView', () => {
     window.height = 10;
     const view = createGlApplicationRenderView(window, document.createElement('canvas'), { pipeline });
     attachApplicationRenderView(view);
-    mocks.resizeGlRenderTarget.mockClear();
+    vi.mocked(renderGlContract.resizeGlRenderTarget).mockClear();
 
     destroyGlApplicationRenderView(view);
     window.width = 30;
     emitSignal(window.onResize);
 
-    expect(mocks.resizeGlRenderTarget).not.toHaveBeenCalled();
-    expect(mocks.destroyGlRenderTarget).toHaveBeenCalledWith(view.renderState, view.renderTarget);
-    expect(mocks.destroyGlRenderState).toHaveBeenCalledWith(view.renderState);
+    expect(renderGlContract.resizeGlRenderTarget).not.toHaveBeenCalled();
+    expect(renderGlContract.destroyGlRenderTarget).toHaveBeenCalledWith(view.renderState, view.renderTarget);
+    expect(renderGlContract.destroyGlRenderState).toHaveBeenCalledWith(view.renderState);
   });
 });