@flighthq/host-web 0.4.0-edge.1908.751021c

package/src/webConnectivity.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebConnectivity, resetHostWebConnectivityForTest } from './webConnectivity';
+
+describe('enableHostWebConnectivity', () => {
+  afterEach(() => resetHostWebConnectivityForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebConnectivity()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebConnectivity();
+    expect(() => enableHostWebConnectivity()).not.toThrow();
+  });
+});
+
+describe('resetHostWebConnectivityForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebConnectivity();
+    resetHostWebConnectivityForTest();
+    expect(() => enableHostWebConnectivity()).not.toThrow();
+  });
+});

package/src/webCursor.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+
+import { createWebCursorBackend } from './webCursor';
+
+describe('createWebCursorBackend', () => {
+  it('sets element.style.cursor to the given cursor value', () => {
+    const element = document.createElement('div');
+    const backend = createWebCursorBackend(element);
+    backend.setCursor('pointer');
+    expect(element.style.cursor).toBe('pointer');
+  });
+
+  it('clears element.style.cursor when given null', () => {
+    const element = document.createElement('div');
+    const backend = createWebCursorBackend(element);
+    backend.setCursor('pointer');
+    backend.setCursor(null);
+    expect(element.style.cursor).toBe('');
+  });
+
+  it('constructs without a DOM side effect', () => {
+    const element = document.createElement('div');
+    createWebCursorBackend(element);
+    expect(element.style.cursor).toBe('');
+  });
+});

package/src/webDevice.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebDevice, resetHostWebDeviceForTest } from './webDevice';
+
+describe('enableHostWebDevice', () => {
+  afterEach(() => resetHostWebDeviceForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebDevice()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebDevice();
+    expect(() => enableHostWebDevice()).not.toThrow();
+  });
+});
+
+describe('resetHostWebDeviceForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebDevice();
+    resetHostWebDeviceForTest();
+    expect(() => enableHostWebDevice()).not.toThrow();
+  });
+});

package/src/webDialog.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebDialog, resetHostWebDialogForTest } from './webDialog';
+
+describe('enableHostWebDialog', () => {
+  afterEach(() => resetHostWebDialogForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebDialog()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebDialog();
+    expect(() => enableHostWebDialog()).not.toThrow();
+  });
+});
+
+describe('resetHostWebDialogForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebDialog();
+    resetHostWebDialogForTest();
+    expect(() => enableHostWebDialog()).not.toThrow();
+  });
+});

package/src/webFilesystem.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebFileSystem, resetHostWebFilesystemForTest } from './webFilesystem';
+
+describe('enableHostWebFileSystem', () => {
+  afterEach(() => resetHostWebFilesystemForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebFileSystem()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebFileSystem();
+    expect(() => enableHostWebFileSystem()).not.toThrow();
+  });
+});
+
+describe('resetHostWebFilesystemForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebFileSystem();
+    resetHostWebFilesystemForTest();
+    expect(() => enableHostWebFileSystem()).not.toThrow();
+  });
+});

package/src/webGeolocation.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebGeolocation, resetHostWebGeolocationForTest } from './webGeolocation';
+
+describe('enableHostWebGeolocation', () => {
+  afterEach(() => resetHostWebGeolocationForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebGeolocation()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebGeolocation();
+    expect(() => enableHostWebGeolocation()).not.toThrow();
+  });
+});
+
+describe('resetHostWebGeolocationForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebGeolocation();
+    resetHostWebGeolocationForTest();
+    expect(() => enableHostWebGeolocation()).not.toThrow();
+  });
+});

package/src/webGlyphRasterizer.test.ts

@@ -0,0 +1,153 @@
+import {
+  explainGlyphRasterizerBackend,
+  getGlyphRasterizerBackend,
+  installGlyphRasterizerHostBackend,
+  resetGlyphRasterizerBackendForTest,
+} from '@flighthq/glyphatlas/contract';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createWebGlyphRasterizerBackend,
+  enableHostWebGlyphRasterizer,
+  resetHostWebGlyphRasterizerForTest,
+} from './webGlyphRasterizer';
+
+describe('createWebGlyphRasterizerBackend', () => {
+  afterEach(resetGlyphRasterizerBackendForTest);
+
+  it('constructs a backend with rasterize and measureMetrics', () => {
+    const backend = createWebGlyphRasterizerBackend();
+    expect(backend.rasterize).toBeTypeOf('function');
+    expect(backend.measureMetrics).toBeTypeOf('function');
+  });
+
+  it('rasterize returns null and observes failure when no canvas context is available', () => {
+    const backend = createWebGlyphRasterizerBackend();
+    installGlyphRasterizerHostBackend(backend);
+    const saved = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = (() => null) as typeof HTMLCanvasElement.prototype.getContext;
+    try {
+      expect(backend.rasterize(65, { fontFamily: 'x', fontSize: 16 })).toBeNull();
+      expect(explainGlyphRasterizerBackend().viability).toBe('runtime-api-unavailable');
+      expect(explainGlyphRasterizerBackend().operation).toBe('rasterize');
+    } finally {
+      HTMLCanvasElement.prototype.getContext = saved;
+    }
+  });
+});
+
+describe('enableHostWebGlyphRasterizer', () => {
+  afterEach(() => {
+    resetGlyphRasterizerBackendForTest();
+    resetHostWebGlyphRasterizerForTest();
+    vi.restoreAllMocks();
+  });
+
+  it('installs a host backend so get returns a non-sentinel', () => {
+    enableHostWebGlyphRasterizer();
+    const backend = getGlyphRasterizerBackend();
+    expect(backend).not.toBe(null);
+    expect(explainGlyphRasterizerBackend().layer).toBe('host');
+  });
+
+  it('is idempotent — second call preserves provider identity and allocates nothing', () => {
+    enableHostWebGlyphRasterizer();
+    const first = getGlyphRasterizerBackend();
+    enableHostWebGlyphRasterizer();
+    const second = getGlyphRasterizerBackend();
+    expect(first).toBe(second);
+  });
+
+  it('starts unobserved — no viability claimed until a real call', () => {
+    enableHostWebGlyphRasterizer();
+    expect(explainGlyphRasterizerBackend()).toEqual({
+      conflict: false,
+      layer: 'host',
+      operation: null,
+      viability: 'unobserved',
+    });
+  });
+
+  it('observes available after a successful rasterize call', () => {
+    enableHostWebGlyphRasterizer();
+    const backend = getGlyphRasterizerBackend();
+    const result = backend.rasterize(65, { fontFamily: 'sans-serif', fontSize: 16 });
+    if (result !== null) {
+      expect(explainGlyphRasterizerBackend()).toEqual({
+        conflict: false,
+        layer: 'host',
+        operation: 'rasterize',
+        viability: 'available',
+      });
+    }
+  });
+
+  it('observes runtime-api-unavailable when context returns null', () => {
+    const saved = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = (() => null) as typeof HTMLCanvasElement.prototype.getContext;
+    try {
+      enableHostWebGlyphRasterizer();
+      const backend = getGlyphRasterizerBackend();
+      backend.rasterize(65, { fontFamily: 'x', fontSize: 16 });
+    } finally {
+      HTMLCanvasElement.prototype.getContext = saved;
+    }
+    expect(explainGlyphRasterizerBackend()).toEqual({
+      conflict: false,
+      layer: 'host',
+      operation: 'rasterize',
+      viability: 'runtime-api-unavailable',
+    });
+  });
+
+  it('reflects recovery: broken environment then restored', () => {
+    enableHostWebGlyphRasterizer();
+    const backend = getGlyphRasterizerBackend();
+
+    // Break the environment — rasterize reports failure
+    const saved = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = (() => null) as typeof HTMLCanvasElement.prototype.getContext;
+    backend.rasterize(65, { fontFamily: 'x', fontSize: 16 });
+    expect(explainGlyphRasterizerBackend().viability).toBe('runtime-api-unavailable');
+
+    // Restore — next call reports success
+    HTMLCanvasElement.prototype.getContext = saved;
+    const result = backend.rasterize(65, { fontFamily: 'sans-serif', fontSize: 16 });
+    if (result !== null) {
+      expect(explainGlyphRasterizerBackend().viability).toBe('available');
+    }
+  });
+
+  it('does not conflict with a prior install of the same backend via direct install', () => {
+    enableHostWebGlyphRasterizer();
+    const backend = getGlyphRasterizerBackend();
+    installGlyphRasterizerHostBackend(backend);
+    expect(explainGlyphRasterizerBackend().conflict).toBe(false);
+  });
+
+  it('observes available even when rasterize returns null for a zero-ink glyph', () => {
+    enableHostWebGlyphRasterizer();
+    const backend = getGlyphRasterizerBackend();
+    // Space (codepoint 32) has no visible pixels — rasterize returns null, but the API is working
+    const result = backend.rasterize(32, { fontFamily: 'sans-serif', fontSize: 16 });
+    expect(result).toBeNull();
+    expect(explainGlyphRasterizerBackend()).toEqual({
+      conflict: false,
+      layer: 'host',
+      operation: 'rasterize',
+      viability: 'available',
+    });
+  });
+});
+
+describe('resetHostWebGlyphRasterizerForTest', () => {
+  afterEach(resetGlyphRasterizerBackendForTest);
+
+  it('clears the enabler flag so a subsequent enable re-installs', () => {
+    enableHostWebGlyphRasterizer();
+    resetHostWebGlyphRasterizerForTest();
+    resetGlyphRasterizerBackendForTest();
+    enableHostWebGlyphRasterizer();
+    expect(explainGlyphRasterizerBackend().layer).toBe('host');
+  });
+});

package/src/webHaptics.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebHaptics, resetHostWebHapticsForTest } from './webHaptics';
+
+describe('enableHostWebHaptics', () => {
+  afterEach(() => resetHostWebHapticsForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebHaptics()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebHaptics();
+    expect(() => enableHostWebHaptics()).not.toThrow();
+  });
+});
+
+describe('resetHostWebHapticsForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebHaptics();
+    resetHostWebHapticsForTest();
+    expect(() => enableHostWebHaptics()).not.toThrow();
+  });
+});

package/src/webImage.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebImage, resetHostWebImageForTest } from './webImage';
+
+describe('enableHostWebImage', () => {
+  afterEach(() => resetHostWebImageForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebImage()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebImage();
+    expect(() => enableHostWebImage()).not.toThrow();
+  });
+});
+
+describe('resetHostWebImageForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebImage();
+    resetHostWebImageForTest();
+    expect(() => enableHostWebImage()).not.toThrow();
+  });
+});

package/src/webKeyboard.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebSoftKeyboard, resetHostWebKeyboardForTest } from './webKeyboard';
+
+describe('enableHostWebSoftKeyboard', () => {
+  afterEach(() => resetHostWebKeyboardForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebSoftKeyboard()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebSoftKeyboard();
+    expect(() => enableHostWebSoftKeyboard()).not.toThrow();
+  });
+});
+
+describe('resetHostWebKeyboardForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebSoftKeyboard();
+    resetHostWebKeyboardForTest();
+    expect(() => enableHostWebSoftKeyboard()).not.toThrow();
+  });
+});

package/src/webLifecycle.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebLifecycle, resetHostWebLifecycleForTest } from './webLifecycle';
+
+describe('enableHostWebLifecycle', () => {
+  afterEach(() => resetHostWebLifecycleForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebLifecycle()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebLifecycle();
+    expect(() => enableHostWebLifecycle()).not.toThrow();
+  });
+});
+
+describe('resetHostWebLifecycleForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebLifecycle();
+    resetHostWebLifecycleForTest();
+    expect(() => enableHostWebLifecycle()).not.toThrow();
+  });
+});

package/src/webLoop.test.ts

@@ -0,0 +1,123 @@
+import { explainLoopBackend, getLoopBackend, resetLoopBackendForTest } from '@flighthq/application/contract';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { enableHostWebLoop, resetHostWebLoopForTest } from './webLoop';
+
+describe('enableHostWebLoop', () => {
+  afterEach(() => {
+    resetLoopBackendForTest();
+    resetHostWebLoopForTest();
+    vi.restoreAllMocks();
+  });
+
+  it('installs a host backend so get returns non-null', () => {
+    enableHostWebLoop();
+    const backend = getLoopBackend();
+    expect(backend).not.toBeNull();
+    expect(backend!.now()).toBeTypeOf('number');
+    expect(explainLoopBackend().layer).toBe('host');
+  });
+
+  it('is idempotent — second call preserves provider identity', () => {
+    enableHostWebLoop();
+    const first = getLoopBackend();
+    enableHostWebLoop();
+    const second = getLoopBackend();
+    expect(first).toBe(second);
+  });
+
+  it('starts unobserved — no viability claimed until a real call', () => {
+    enableHostWebLoop();
+    expect(explainLoopBackend()).toEqual({
+      conflict: false,
+      layer: 'host',
+      operation: null,
+      viability: 'unobserved',
+    });
+  });
+
+  it('observes available after requestFrame call', () => {
+    enableHostWebLoop();
+    const backend = getLoopBackend()!;
+    const handle = backend.requestFrame(() => {});
+    expect(handle).toBeTypeOf('number');
+    expect(explainLoopBackend()).toEqual({
+      conflict: false,
+      layer: 'host',
+      operation: 'requestFrame',
+      viability: 'available',
+    });
+  });
+
+  it('every requestFrame re-observes — not one-shot', () => {
+    enableHostWebLoop();
+    const backend = getLoopBackend()!;
+    backend.requestFrame(() => {});
+    backend.requestFrame(() => {});
+    expect(explainLoopBackend().operation).toBe('requestFrame');
+    expect(explainLoopBackend().viability).toBe('available');
+  });
+
+  it('cancelFrame observes independently from requestFrame', () => {
+    enableHostWebLoop();
+    const backend = getLoopBackend()!;
+    const handle = backend.requestFrame(() => {});
+    expect(explainLoopBackend().operation).toBe('requestFrame');
+    backend.cancelFrame(handle);
+    expect(explainLoopBackend().operation).toBe('cancelFrame');
+    expect(explainLoopBackend().viability).toBe('available');
+  });
+
+  it('loss then recovery — requestFrame failure reverts to available on success', () => {
+    enableHostWebLoop();
+    const backend = getLoopBackend()!;
+    backend.requestFrame(() => {});
+    expect(explainLoopBackend().viability).toBe('available');
+
+    const raf = vi.fn().mockImplementation(() => {
+      throw new Error('rAF unavailable');
+    });
+    vi.stubGlobal('requestAnimationFrame', raf);
+    backend.requestFrame(() => {});
+    expect(explainLoopBackend().viability).toBe('runtime-api-unavailable');
+    expect(explainLoopBackend().operation).toBe('requestFrame');
+
+    vi.stubGlobal('requestAnimationFrame', vi.fn().mockReturnValue(99));
+    backend.requestFrame(() => {});
+    expect(explainLoopBackend().viability).toBe('available');
+  });
+
+  it('cancelFrame failure observes unavailable', () => {
+    enableHostWebLoop();
+    const backend = getLoopBackend()!;
+    backend.requestFrame(() => {});
+
+    vi.stubGlobal(
+      'cancelAnimationFrame',
+      vi.fn().mockImplementation(() => {
+        throw new Error('cAF unavailable');
+      }),
+    );
+    backend.cancelFrame(1);
+    expect(explainLoopBackend().operation).toBe('cancelFrame');
+    expect(explainLoopBackend().viability).toBe('runtime-api-unavailable');
+  });
+
+  it('now returns a positive number', () => {
+    enableHostWebLoop();
+    const backend = getLoopBackend()!;
+    expect(backend.now()).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('resetHostWebLoopForTest', () => {
+  afterEach(resetLoopBackendForTest);
+
+  it('clears the enabler flag so a subsequent enable re-installs', () => {
+    enableHostWebLoop();
+    resetHostWebLoopForTest();
+    resetLoopBackendForTest();
+    enableHostWebLoop();
+    expect(explainLoopBackend().layer).toBe('host');
+  });
+});

package/src/webMediasession.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebMediaSession, resetHostWebMediasessionForTest } from './webMediasession';
+
+describe('enableHostWebMediaSession', () => {
+  afterEach(() => resetHostWebMediasessionForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebMediaSession()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebMediaSession();
+    expect(() => enableHostWebMediaSession()).not.toThrow();
+  });
+});
+
+describe('resetHostWebMediasessionForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebMediaSession();
+    resetHostWebMediasessionForTest();
+    expect(() => enableHostWebMediaSession()).not.toThrow();
+  });
+});

package/src/webMenu.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebMenu, resetHostWebMenuForTest } from './webMenu';
+
+describe('enableHostWebMenu', () => {
+  afterEach(() => resetHostWebMenuForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebMenu()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebMenu();
+    expect(() => enableHostWebMenu()).not.toThrow();
+  });
+});
+
+describe('resetHostWebMenuForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebMenu();
+    resetHostWebMenuForTest();
+    expect(() => enableHostWebMenu()).not.toThrow();
+  });
+});

package/src/webNotification.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebNotification, resetHostWebNotificationForTest } from './webNotification';
+
+describe('enableHostWebNotification', () => {
+  afterEach(() => resetHostWebNotificationForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebNotification()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebNotification();
+    expect(() => enableHostWebNotification()).not.toThrow();
+  });
+});
+
+describe('resetHostWebNotificationForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebNotification();
+    resetHostWebNotificationForTest();
+    expect(() => enableHostWebNotification()).not.toThrow();
+  });
+});

package/src/webPermissions.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebPermission, resetHostWebPermissionsForTest } from './webPermissions';
+
+describe('enableHostWebPermission', () => {
+  afterEach(() => resetHostWebPermissionsForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebPermission()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebPermission();
+    expect(() => enableHostWebPermission()).not.toThrow();
+  });
+});
+
+describe('resetHostWebPermissionsForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebPermission();
+    resetHostWebPermissionsForTest();
+    expect(() => enableHostWebPermission()).not.toThrow();
+  });
+});

package/src/webPlatform.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebPlatform, resetHostWebPlatformForTest } from './webPlatform';
+
+describe('enableHostWebPlatform', () => {
+  afterEach(() => resetHostWebPlatformForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebPlatform()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebPlatform();
+    expect(() => enableHostWebPlatform()).not.toThrow();
+  });
+});
+
+describe('resetHostWebPlatformForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebPlatform();
+    resetHostWebPlatformForTest();
+    expect(() => enableHostWebPlatform()).not.toThrow();
+  });
+});

package/src/webPower.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebPower, resetHostWebPowerForTest } from './webPower';
+
+describe('enableHostWebPower', () => {
+  afterEach(() => resetHostWebPowerForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebPower()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebPower();
+    expect(() => enableHostWebPower()).not.toThrow();
+  });
+});
+
+describe('resetHostWebPowerForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebPower();
+    resetHostWebPowerForTest();
+    expect(() => enableHostWebPower()).not.toThrow();
+  });
+});

package/src/webProtocol.test.ts

@@ -0,0 +1,22 @@
+import { enableHostWebProtocol, resetHostWebProtocolForTest } from './webProtocol';
+
+describe('enableHostWebProtocol', () => {
+  afterEach(() => resetHostWebProtocolForTest());
+
+  it('does not throw on first call', () => {
+    expect(() => enableHostWebProtocol()).not.toThrow();
+  });
+
+  it('is idempotent', () => {
+    enableHostWebProtocol();
+    expect(() => enableHostWebProtocol()).not.toThrow();
+  });
+});
+
+describe('resetHostWebProtocolForTest', () => {
+  it('allows re-enabling after reset', () => {
+    enableHostWebProtocol();
+    resetHostWebProtocolForTest();
+    expect(() => enableHostWebProtocol()).not.toThrow();
+  });
+});