@ifc-lite/viewer 1.17.3 → 1.17.4

package/src/lib/geo/cesium-bridge.ts

@@ -0,0 +1,310 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Cesium coordinate bridge — lookAtTransform approach.
+ *
+ * KEY INSIGHT (from Cesium GitHub #6032): Camera.setView() with direction/up
+ * vectors causes drift because it doesn't properly orthonormalize. The fix:
+ * use lookAtTransform() which sets a reference frame and keeps the camera
+ * matrix clean.
+ *
+ * APPROACH: Build a single 4x4 matrix that transforms from IFC viewer space
+ * to ECEF, pass it to Cesium via lookAtTransform(). Then set camera position,
+ * direction, and up in IFC viewer coordinates — Cesium applies the transform
+ * internally with full precision.
+ *
+ * The viewer→ECEF transform is composed of:
+ *   1. Translate by (-modelCenter) to center on model origin
+ *   2. Rotate via viewerYup→ifcZup axis swap
+ *   3. Rotate via Helmert (IFC→projected CRS alignment)
+ *   4. Transform ENU→ECEF via Cesium.Transforms.eastNorthUpToFixedFrame()
+ *
+ * Since this is a SINGLE matrix, it's applied atomically by Cesium — no
+ * intermediate rounding or re-orthonormalization. The model stays pinned.
+ */
+
+import proj4 from 'proj4';
+import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
+import type { CoordinateInfo } from '@ifc-lite/geometry';
+import { resolveProjection } from './reproject';
+
+export interface GeodesicPosition {
+  longitude: number;
+  latitude: number;
+  height: number;
+}
+
+export interface CesiumBridge {
+  modelOrigin: GeodesicPosition;
+  rotationAngle: number;
+
+  /**
+   * Sync the Cesium camera using lookAtTransform with a viewer→ECEF matrix.
+   * The IFC camera position/direction/up are passed in viewer coordinates —
+   * Cesium transforms them to ECEF internally using one consistent matrix.
+   */
+  syncCamera(
+    Cesium: typeof import('cesium'),
+    viewer: InstanceType<typeof import('cesium').Viewer>,
+    camPos: { x: number; y: number; z: number },
+    camTarget: { x: number; y: number; z: number },
+    camUp: { x: number; y: number; z: number },
+    fov: number,
+    terrainClampOffset?: number,
+  ): void;
+
+  /** Query terrain height at model origin. */
+  queryTerrainHeight(
+    Cesium: typeof import('cesium'),
+    viewer: InstanceType<typeof import('cesium').Viewer>,
+  ): Promise<number | null>;
+
+  viewerToGeodetic(vx: number, vy: number, vz: number): GeodesicPosition | null;
+}
+
+const TERRAIN_QUERY_RETRY_DELAY_MS = 3000;
+
+export async function createCesiumBridge(
+  mapConversion: MapConversion,
+  projectedCRS: ProjectedCRS,
+  coordinateInfo?: CoordinateInfo,
+): Promise<CesiumBridge | null> {
+  const projDef = await resolveProjection(projectedCRS);
+  if (!projDef) return null;
+
+  const hScale = mapConversion.scale ?? 1.0;
+  const absc = mapConversion.xAxisAbscissa ?? 1.0;
+  const ordi = mapConversion.xAxisOrdinate ?? 0.0;
+  const rotAngle = Math.atan2(ordi, absc);
+
+  const shift = coordinateInfo?.originShift ?? { x: 0, y: 0, z: 0 };
+  const rtc = coordinateInfo?.wasmRtcOffset;
+  const rtcYup = rtc
+    ? { x: rtc.x, y: rtc.z, z: -rtc.y }
+    : { x: 0, y: 0, z: 0 };
+
+  const bounds = coordinateInfo?.originalBounds;
+  const modelVX = bounds ? (bounds.min.x + bounds.max.x) / 2 : 0;
+  const modelVY = bounds ? (bounds.min.y + bounds.max.y) / 2 : 0;
+  const modelVZ = bounds ? (bounds.min.z + bounds.max.z) / 2 : 0;
+
+  // ── Compute model origin in WGS84 ──
+  const owx = modelVX + shift.x + rtcYup.x;
+  const owy = modelVY + shift.y + rtcYup.y;
+  const owz = modelVZ + shift.z + rtcYup.z;
+  // Viewer Y-up → IFC Z-up
+  const oIfcX = owx;
+  const oIfcY = -owz;
+  const oIfcZ = owy;
+  const oEasting = mapConversion.eastings + hScale * (absc * oIfcX - ordi * oIfcY);
+  const oNorthing = mapConversion.northings + hScale * (ordi * oIfcX + absc * oIfcY);
+  const oHeight = mapConversion.orthogonalHeight + oIfcZ;
+
+  let originLon: number, originLat: number;
+  try {
+    const [lon, lat] = proj4(projDef, 'WGS84', [oEasting, oNorthing]);
+    if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+    originLon = lon;
+    originLat = lat;
+  } catch {
+    return null;
+  }
+
+  const modelOrigin: GeodesicPosition = {
+    longitude: originLon,
+    latitude: originLat,
+    height: oHeight,
+  };
+
+  // ── Build the viewer→ENU 3x3 rotation matrix ──
+  // This converts a DELTA vector from viewer space to ENU.
+  // Step 1: viewer Y-up → IFC Z-up: (vx, vy, vz) → (vx, -vz, vy)
+  // Step 2: Helmert rotation: (ifcX, ifcY) → (east, north) with scale
+  //
+  // Combined as a 3x3 matrix M where [east, north, up] = M * [vx, vy, vz]:
+  //   east  = hScale * (absc * vx - ordi * (-vz))  = hScale * (absc*vx + ordi*vz)
+  //   north = hScale * (ordi * vx + absc * (-vz))   = hScale * (ordi*vx - absc*vz)
+  //   up    = vy  (ifcZ = vy, vertical is viewer Y)
+  //
+  // So M = [hScale*absc,   0,  hScale*ordi ]
+  //        [hScale*ordi,   0, -hScale*absc ]
+  //        [0,             1,  0           ]
+  const m00 = hScale * absc;   // east  from vx
+  const m01 = 0;               // east  from vy
+  const m02 = hScale * ordi;   // east  from vz
+  const m10 = hScale * ordi;   // north from vx
+  const m11 = 0;               // north from vy
+  const m12 = -hScale * absc;  // north from vz
+  const m20 = 0;               // up    from vx
+  const m21 = 1;               // up    from vy
+  const m22 = 0;               // up    from vz
+
+  // ── Cache for ECEF objects ──
+  let viewerToEcefMatrix: InstanceType<typeof import('cesium').Matrix4> | null = null;
+  let modelOriginCartesian: InstanceType<typeof import('cesium').Cartesian3> | null = null;
+  let cachedClampUp: number | null = null;
+
+  function ensureEcefCache(Cesium: typeof import('cesium'), clampUp: number) {
+    if (cachedClampUp === clampUp && viewerToEcefMatrix !== null) return;
+    cachedClampUp = clampUp;
+
+    const originWithClamp = Cesium.Cartesian3.fromDegrees(
+      originLon, originLat, oHeight + clampUp,
+    );
+    modelOriginCartesian = originWithClamp;
+
+    // Get ENU→ECEF 4x4 matrix at model origin
+    const enuToEcef = Cesium.Transforms.eastNorthUpToFixedFrame(originWithClamp);
+
+    // Build viewer→ECEF = enuToEcef * viewerToENU
+    // viewerToENU is: translate(-modelCenter) then rotate by M
+    // As a 4x4: columns are the ENU directions of viewer axes, translation is -modelCenter in ENU
+    //
+    // viewerToENU_4x4 = [ m00  m01  m02  tx ]
+    //                    [ m10  m11  m12  ty ]
+    //                    [ m20  m21  m22  tz ]
+    //                    [ 0    0    0    1  ]
+    // where (tx, ty, tz) = M * (-modelVX, -modelVY, -modelVZ)
+    const tx = m00 * (-modelVX) + m01 * (-modelVY) + m02 * (-modelVZ);
+    const ty = m10 * (-modelVX) + m11 * (-modelVY) + m12 * (-modelVZ);
+    const tz = m20 * (-modelVX) + m21 * (-modelVY) + m22 * (-modelVZ);
+
+    // Cesium Matrix4 is column-major
+    const viewerToEnu = new Cesium.Matrix4(
+      m00, m01, m02, tx,
+      m10, m11, m12, ty,
+      m20, m21, m22, tz,
+      0,   0,   0,   1,
+    );
+
+    // Compose: viewerToEcef = enuToEcef * viewerToEnu
+    viewerToEcefMatrix = Cesium.Matrix4.multiply(
+      enuToEcef, viewerToEnu, new Cesium.Matrix4(),
+    );
+  }
+
+  function syncCamera(
+    Cesium: typeof import('cesium'),
+    viewer: InstanceType<typeof import('cesium').Viewer>,
+    camPos: { x: number; y: number; z: number },
+    camTarget: { x: number; y: number; z: number },
+    camUp: { x: number; y: number; z: number },
+    fov: number,
+    terrainClampOffset?: number,
+  ): void {
+    const clampUp = terrainClampOffset ?? 0;
+    ensureEcefCache(Cesium, clampUp);
+    if (!viewerToEcefMatrix) return;
+
+    // Set the camera's reference frame to our viewer→ECEF transform.
+    // After this call, all camera properties (position, direction, up)
+    // are interpreted in IFC VIEWER coordinates, not ECEF.
+    viewer.camera.lookAtTransform(viewerToEcefMatrix);
+
+    // Now set camera in VIEWER coordinates — Cesium applies the transform
+    viewer.camera.position = new Cesium.Cartesian3(camPos.x, camPos.y, camPos.z);
+
+    const dirX = camTarget.x - camPos.x;
+    const dirY = camTarget.y - camPos.y;
+    const dirZ = camTarget.z - camPos.z;
+    const dirLen = Math.sqrt(dirX * dirX + dirY * dirY + dirZ * dirZ);
+    if (dirLen > 1e-8) {
+      viewer.camera.direction = new Cesium.Cartesian3(
+        dirX / dirLen, dirY / dirLen, dirZ / dirLen,
+      );
+    }
+
+    viewer.camera.up = new Cesium.Cartesian3(camUp.x, camUp.y, camUp.z);
+
+    // Recompute right = direction × up (maintain orthonormality)
+    const right = Cesium.Cartesian3.cross(
+      viewer.camera.direction, viewer.camera.up, new Cesium.Cartesian3(),
+    );
+    Cesium.Cartesian3.normalize(right, right);
+    viewer.camera.right = right;
+
+    // Sync FOV — CRITICAL for preventing model drift.
+    // IFC renderer uses `fov` as VERTICAL FOV always.
+    // Cesium's PerspectiveFrustum.fov is HORIZONTAL when aspect > 1 (landscape).
+    // If we set Cesium's fov = IFC's vertical fov, Cesium treats it as horizontal,
+    // producing a completely different projection — the model slides during orbit.
+    // Fix: convert vertical FOV → horizontal FOV.
+    const frustum = viewer.camera.frustum;
+    if (frustum instanceof Cesium.PerspectiveFrustum) {
+      const aspect = frustum.aspectRatio || (viewer.canvas.width / viewer.canvas.height);
+      if (aspect > 1) {
+        // Landscape: Cesium expects horizontal FOV
+        // horizontal_fov = 2 * atan(aspect * tan(vertical_fov / 2))
+        frustum.fov = 2 * Math.atan(aspect * Math.tan(fov / 2));
+      } else {
+        // Portrait: Cesium uses fov as vertical — pass through
+        frustum.fov = fov;
+      }
+    }
+
+    viewer.scene.requestRender();
+  }
+
+  async function queryTerrainHeight(
+    Cesium: typeof import('cesium'),
+    viewer: InstanceType<typeof import('cesium').Viewer>,
+  ): Promise<number | null> {
+    const position = Cesium.Cartographic.fromDegrees(originLon, originLat);
+
+    try {
+      const globeHeight = viewer.scene.globe.getHeight(position);
+      if (globeHeight !== undefined && Number.isFinite(globeHeight)) {
+        return globeHeight;
+      }
+    } catch { /* not available yet */ }
+
+    try {
+      const terrainProvider = viewer.terrainProvider;
+      if (terrainProvider) {
+        const results = await Cesium.sampleTerrainMostDetailed(terrainProvider, [position]);
+        if (results && results.length > 0 && Number.isFinite(results[0].height)) {
+          return results[0].height;
+        }
+      }
+    } catch { /* terrain sampling failed */ }
+
+    await new Promise(r => setTimeout(r, TERRAIN_QUERY_RETRY_DELAY_MS));
+    try {
+      const globeHeight = viewer.scene.globe.getHeight(position);
+      if (globeHeight !== undefined && Number.isFinite(globeHeight)) {
+        return globeHeight;
+      }
+    } catch { /* still not available */ }
+
+    return null;
+  }
+
+  function viewerToGeodetic(vx: number, vy: number, vz: number): GeodesicPosition | null {
+    const wx = vx + shift.x + rtcYup.x;
+    const wy = vy + shift.y + rtcYup.y;
+    const wz = vz + shift.z + rtcYup.z;
+    const ifcX = wx;
+    const ifcY = -wz;
+    const ifcZ = wy;
+    const easting = mapConversion.eastings + hScale * (absc * ifcX - ordi * ifcY);
+    const northing = mapConversion.northings + hScale * (ordi * ifcX + absc * ifcY);
+    const height = mapConversion.orthogonalHeight + ifcZ;
+    try {
+      const [lon, lat] = proj4(projDef!, 'WGS84', [easting, northing]);
+      if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+      return { longitude: lon, latitude: lat, height };
+    } catch {
+      return null;
+    }
+  }
+
+  return {
+    modelOrigin,
+    rotationAngle: rotAngle,
+    syncCamera,
+    queryTerrainHeight,
+    viewerToGeodetic,
+  };
+}

package/src/lib/geo/reproject.ts

@@ -176,31 +176,7 @@ function computeProjectedCenter(
   conversion: MapConversion,
   coordinateInfo?: CoordinateInfo,
 ): { easting: number; northing: number } {
-  let ifcX = 0;
-  let ifcY = 0;
-
-  if (coordinateInfo) {
-    const bounds = coordinateInfo.originalBounds;
-    const shift = coordinateInfo.originShift;
-    const rtc = coordinateInfo.wasmRtcOffset;
-
-    // Convert WASM RTC offset from IFC Z-up to viewer Y-up
-    const rtcYup = rtc
-      ? { x: rtc.x, y: rtc.z, z: -rtc.y }
-      : { x: 0, y: 0, z: 0 };
-
-    // Bounds center in viewer Y-up (scene-local)
-    const cx = (bounds.min.x + bounds.max.x) / 2;
-    const cz = (bounds.min.z + bounds.max.z) / 2;
-
-    // World Y-up = scene_local + originShift + wasmRtcOffset_yup
-    const worldYupX = cx + shift.x + rtcYup.x;
-    const worldYupZ = cz + shift.z + rtcYup.z;
-
-    // Convert Y-up to IFC Z-up: ifc_x = viewer_x, ifc_y = -viewer_z
-    ifcX = worldYupX;
-    ifcY = -worldYupZ;
-  }
+  const { ifcX, ifcY } = computeLocalIfcCenter(coordinateInfo);
 
   // Apply MapConversion rotation + scale + offset
   const scale = conversion.scale ?? 1.0;
@@ -242,3 +218,153 @@ export async function reprojectToLatLon(
     return null;
   }
 }
+
+/**
+ * Compute the model's local IFC center offset (ifcX, ifcY) from coordinate info.
+ * This is the geometry center in IFC Z-up coordinates, before MapConversion is applied.
+ */
+function computeLocalIfcCenter(coordinateInfo?: CoordinateInfo): { ifcX: number; ifcY: number } {
+  if (!coordinateInfo) return { ifcX: 0, ifcY: 0 };
+
+  const bounds = coordinateInfo.originalBounds;
+  const shift = coordinateInfo.originShift;
+  const rtc = coordinateInfo.wasmRtcOffset;
+
+  const rtcYup = rtc
+    ? { x: rtc.x, y: rtc.z, z: -rtc.y }
+    : { x: 0, y: 0, z: 0 };
+
+  const cx = (bounds.min.x + bounds.max.x) / 2;
+  const cz = (bounds.min.z + bounds.max.z) / 2;
+
+  const worldYupX = cx + shift.x + rtcYup.x;
+  const worldYupZ = cz + shift.z + rtcYup.z;
+
+  return { ifcX: worldYupX, ifcY: -worldYupZ };
+}
+
+/**
+ * Reverse-project a WGS84 lat/lon into the IfcMapConversion eastings/northings
+ * values that would place the model center at the given location.
+ *
+ * This accounts for the model's local geometry offset, rotation, and scale:
+ *   projected = eastings + scale * (cos*ifcX - sin*ifcY)
+ *   ⟹ eastings = projected - scale * (cos*ifcX - sin*ifcY)
+ */
+export async function reprojectFromLatLon(
+  latLon: LatLon,
+  crs: ProjectedCRS,
+  conversion?: MapConversion,
+  coordinateInfo?: CoordinateInfo,
+): Promise<{ easting: number; northing: number } | null> {
+  const projDef = await resolveProjection(crs);
+  if (!projDef) return null;
+
+  try {
+    const [projE, projN] = proj4('WGS84', projDef, [latLon.lon, latLon.lat]);
+    if (!Number.isFinite(projE) || !Number.isFinite(projN)) return null;
+
+    // Subtract the rotated/scaled local geometry offset so that
+    // the resulting eastings/northings place the model center at this position
+    const { ifcX, ifcY } = computeLocalIfcCenter(coordinateInfo);
+    const scale = conversion?.scale ?? 1.0;
+    const abscissa = conversion?.xAxisAbscissa ?? 1.0;
+    const ordinate = conversion?.xAxisOrdinate ?? 0.0;
+
+    const easting = projE - scale * (abscissa * ifcX - ordinate * ifcY);
+    const northing = projN - scale * (ordinate * ifcX + abscissa * ifcY);
+
+    return { easting, northing };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compute a building footprint rectangle from the model's bounding box and
+ * reproject each corner to WGS84 for display as a GeoJSON polygon on a web map.
+ *
+ * Uses the shiftedBounds (scene-local after RTC) from CoordinateInfo, transforms
+ * each corner through the MapConversion pipeline (rotation + scale + offset),
+ * then reprojects to lat/lon. The result is a rotated rectangle matching the
+ * model's XZ extent on the map.
+ *
+ * @returns A single GeoJSON-compatible polygon: closed ring of [lon, lat] pairs
+ */
+export async function computeFootprintGeoJSON(
+  conversion: MapConversion,
+  crs: ProjectedCRS,
+  coordinateInfo: CoordinateInfo,
+): Promise<[number, number][] | null> {
+  const projDef = await resolveProjection(crs);
+  if (!projDef) {
+    console.warn('[footprint] failed to resolve projection for CRS:', crs.name);
+    return null;
+  }
+
+  const scale = conversion.scale ?? 1.0;
+  const abscissa = conversion.xAxisAbscissa ?? 1.0;
+  const ordinate = conversion.xAxisOrdinate ?? 0.0;
+
+  const shift = coordinateInfo.originShift;
+  const rtc = coordinateInfo.wasmRtcOffset;
+  const rtcYup = rtc
+    ? { x: rtc.x, z: -rtc.y }
+    : { x: 0, z: 0 };
+
+  const bounds = coordinateInfo.shiftedBounds;
+
+  // Four corners of the bounding box on the XZ plane (viewer Y-up)
+  const corners = [
+    { x: bounds.min.x, z: bounds.min.z },
+    { x: bounds.max.x, z: bounds.min.z },
+    { x: bounds.max.x, z: bounds.max.z },
+    { x: bounds.min.x, z: bounds.max.z },
+  ];
+
+  const ring: [number, number][] = [];
+
+  for (const c of corners) {
+    // Scene-local → world Y-up
+    const worldX = c.x + shift.x + rtcYup.x;
+    const worldZ = c.z + shift.z + rtcYup.z;
+
+    // Y-up → IFC Z-up: ifcX = worldX, ifcY = -worldZ
+    const ifcX = worldX;
+    const ifcY = -worldZ;
+
+    // MapConversion: local IFC → projected CRS
+    const easting = conversion.eastings + scale * (abscissa * ifcX - ordinate * ifcY);
+    const northing = conversion.northings + scale * (ordinate * ifcX + abscissa * ifcY);
+
+    // Projected CRS → WGS84
+    try {
+      const [lon, lat] = proj4(projDef, 'WGS84', [easting, northing]);
+      if (!Number.isFinite(lat) || !Number.isFinite(lon)) return null;
+      ring.push([lon, lat]);
+    } catch {
+      return null;
+    }
+  }
+
+  // Close the ring (GeoJSON requirement)
+  ring.push(ring[0]);
+  return ring;
+}
+
+/**
+ * Query terrain elevation at a given lat/lon using the Open-Meteo elevation API.
+ * Returns height in metres above sea level, or null on failure.
+ */
+export async function queryTerrainElevation(latLon: LatLon): Promise<number | null> {
+  try {
+    const url = `https://api.open-meteo.com/v1/elevation?latitude=${latLon.lat}&longitude=${latLon.lon}`;
+    const resp = await fetch(url);
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const elev = data?.elevation?.[0];
+    return typeof elev === 'number' && Number.isFinite(elev) ? elev : null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/recent-files.ts

@@ -103,7 +103,8 @@ export async function cacheFileBlobs(files: File[]): Promise<void> {
 }
 
 /** Retrieve a cached file blob and reconstruct a File object. */
-export async function getCachedFile(name: string): Promise<File | null> {
+export async function getCachedFile(target: string | RecentFileEntry): Promise<File | null> {
+  const name = typeof target === 'string' ? target : target.name;
   try {
     const db = await openDB();
     const tx = db.transaction(STORE_NAME, 'readonly');

package/src/services/analysis-extensions.ts

@@ -0,0 +1,125 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { ComponentType, ReactNode } from 'react';
+
+export type AnalysisExtensionPlacement = 'right' | 'bottom';
+
+export interface AnalysisExtensionRenderProps {
+  onClose: () => void;
+}
+
+export interface AnalysisExtensionDefinition {
+  id: string;
+  label: string;
+  description?: string;
+  placement?: AnalysisExtensionPlacement;
+  icon: ComponentType<{ className?: string }>;
+  renderPanel: (props: AnalysisExtensionRenderProps) => ReactNode;
+  onBeforeOpen?: () => boolean | void;
+}
+
+export interface AnalysisExtensionsSnapshot {
+  activeId: string | null;
+  extensions: AnalysisExtensionDefinition[];
+}
+
+const listeners = new Set<() => void>();
+const extensions = new Map<string, AnalysisExtensionDefinition>();
+
+let activeId: string | null = null;
+let snapshot: AnalysisExtensionsSnapshot = {
+  activeId,
+  extensions: [],
+};
+
+function rebuildSnapshot(): void {
+  snapshot = {
+    activeId,
+    extensions: Array.from(extensions.values()),
+  };
+}
+
+function emit(): void {
+  rebuildSnapshot();
+  listeners.forEach((listener) => listener());
+}
+
+function setActiveId(nextActiveId: string | null): void {
+  if (activeId === nextActiveId) {
+    return;
+  }
+  activeId = nextActiveId;
+  emit();
+}
+
+function canOpen(definition: AnalysisExtensionDefinition): boolean {
+  return definition.onBeforeOpen?.() !== false;
+}
+
+export function subscribeAnalysisExtensions(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function getAnalysisExtensionsSnapshot(): AnalysisExtensionsSnapshot {
+  return snapshot;
+}
+
+export function getAnalysisExtensionById(id: string | null | undefined): AnalysisExtensionDefinition | null {
+  if (!id) {
+    return null;
+  }
+  return extensions.get(id) ?? null;
+}
+
+export function closeActiveAnalysisExtension(): void {
+  setActiveId(null);
+}
+
+export function openAnalysisExtension(id: string): boolean {
+  const definition = extensions.get(id);
+  if (!definition) {
+    return false;
+  }
+  if (!canOpen(definition)) {
+    return false;
+  }
+  setActiveId(id);
+  return true;
+}
+
+export function toggleAnalysisExtension(id: string): boolean {
+  if (activeId === id) {
+    closeActiveAnalysisExtension();
+    return false;
+  }
+  return openAnalysisExtension(id);
+}
+
+export function registerAnalysisExtensions(definitions: AnalysisExtensionDefinition[]): () => void {
+  const nextEntries = definitions.map((definition) => [definition.id, definition] as const);
+  nextEntries.forEach(([id, definition]) => {
+    extensions.set(id, definition);
+  });
+  emit();
+
+  return () => {
+    let shouldEmit = false;
+    for (const [id] of nextEntries) {
+      if (extensions.delete(id)) {
+        shouldEmit = true;
+      }
+      if (activeId === id) {
+        activeId = null;
+        shouldEmit = true;
+      }
+    }
+    if (shouldEmit) {
+      emit();
+    }
+  };
+}

package/src/services/app-navigation.ts

@@ -0,0 +1,13 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+export function navigateToPath(path: string, options: { replace?: boolean } = {}): void {
+  const { replace = false } = options;
+  if (replace) {
+    window.history.replaceState({}, '', path);
+  } else {
+    window.history.pushState({}, '', path);
+  }
+  window.dispatchEvent(new PopStateEvent('popstate'));
+}