@flighthq/geolocation 0.4.0-next.1903.50bfa67 → 0.4.0-next.1908.751021c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/geolocation",
-  "version": "0.4.0-next.1903.50bfa67",
+  "version": "0.4.0-next.1908.751021c",
   "author": "Joshua Granick and other contributors",
   "license": "MIT",
   "repository": {
@@ -38,7 +38,7 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/types": "0.4.0-next.1903.50bfa67"
+    "@flighthq/types": "0.4.0-next.1908.751021c"
   },
   "devDependencies": {
     "typescript": "^5.3.0"

package/src/geolocation.test.ts

@@ -18,6 +18,10 @@ import {
   requestGeolocationPermission,
   setGeolocationBackend,
   watchGeolocationPosition,
+  explainGeolocationBackend,
+  installGeolocationHostBackend,
+  observeGeolocationHostResult,
+  resetGeolocationBackendForTest,
 } from './geolocation';
 
 function fakeBackend(): GeolocationBackend & { cleared: number[]; lastWatch: number } {
@@ -157,6 +161,34 @@ describe('createWebGeolocationBackend', () => {
   });
 });
 
+describe('explainGeolocationBackend', () => {
+  afterEach(() => resetGeolocationBackendForTest());
+
+  it('reports host-not-enabled when no backend is installed', () => {
+    resetGeolocationBackendForTest();
+    const explanation = explainGeolocationBackend();
+    expect(explanation.layer).toBe('host-not-enabled');
+    expect(explanation.conflict).toBe(false);
+    expect(explanation.viability).toBe('unobserved');
+  });
+
+  it('reports custom layer when a custom backend is set', () => {
+    setGeolocationBackend(fakeBackend());
+    expect(explainGeolocationBackend().layer).toBe('custom');
+  });
+
+  it('reports host layer when a host backend is installed', () => {
+    installGeolocationHostBackend(fakeBackend());
+    expect(explainGeolocationBackend().layer).toBe('host');
+  });
+
+  it('reports conflict when two different host backends are installed', () => {
+    installGeolocationHostBackend(fakeBackend());
+    installGeolocationHostBackend(fakeBackend());
+    expect(explainGeolocationBackend().conflict).toBe(true);
+  });
+});
+
 describe('getCurrentGeoPosition', () => {
   it('returns the backend position', async () => {
     setGeolocationBackend(fakeBackend());
@@ -206,6 +238,25 @@ describe('getGeolocationPermission', () => {
   });
 });
 
+describe('installGeolocationHostBackend', () => {
+  afterEach(() => resetGeolocationBackendForTest());
+
+  it('installs a host backend that getGeolocationBackend returns', () => {
+    const backend = fakeBackend();
+    installGeolocationHostBackend(backend);
+    expect(getGeolocationBackend()).toBe(backend);
+  });
+
+  it('is first-host-wins: a second different backend sets conflict', () => {
+    const first = fakeBackend();
+    const second = fakeBackend();
+    installGeolocationHostBackend(first);
+    installGeolocationHostBackend(second);
+    expect(getGeolocationBackend()).toBe(first);
+    expect(explainGeolocationBackend().conflict).toBe(true);
+  });
+});
+
 describe('isGeolocationAvailable', () => {
   it('returns a boolean', () => {
     expect(typeof isGeolocationAvailable()).toBe('boolean');
@@ -217,6 +268,24 @@ describe('isGeolocationAvailable', () => {
   });
 });
 
+describe('observeGeolocationHostResult', () => {
+  afterEach(() => resetGeolocationBackendForTest());
+
+  it('records a successful observation', () => {
+    installGeolocationHostBackend(fakeBackend());
+    observeGeolocationHostResult('clearWatch', true);
+    const explanation = explainGeolocationBackend();
+    expect(explanation.operation).toBe('clearWatch');
+    expect(explanation.viability).toBe('available');
+  });
+
+  it('records a failed observation', () => {
+    installGeolocationHostBackend(fakeBackend());
+    observeGeolocationHostResult('clearWatch', false);
+    expect(explainGeolocationBackend().viability).toBe('runtime-api-unavailable');
+  });
+});
+
 describe('onGeolocationPermissionChange', () => {
   it('returns an unsubscribe function', () => {
     const unsubscribe = onGeolocationPermissionChange(() => {});
@@ -253,6 +322,18 @@ describe('requestGeolocationPermission', () => {
   });
 });
 
+describe('resetGeolocationBackendForTest', () => {
+  it('clears all backend slots', () => {
+    setGeolocationBackend(fakeBackend());
+    installGeolocationHostBackend(fakeBackend());
+    observeGeolocationHostResult('clearWatch', true);
+    resetGeolocationBackendForTest();
+    expect(explainGeolocationBackend().layer).toBe('host-not-enabled');
+    expect(explainGeolocationBackend().conflict).toBe(false);
+    expect(explainGeolocationBackend().viability).toBe('unobserved');
+  });
+});
+
 describe('setGeolocationBackend', () => {
   it('clears back to the web fallback when passed null', () => {
     setGeolocationBackend(fakeBackend());