@sdeverywhere/plugin-check 0.3.36 → 0.3.38

package/template-report/src/bundle-metadata.ts

@@ -0,0 +1,66 @@
+// Copyright (c) 2026 Climate Interactive / New Venture Fund
+
+/**
+ * Identifies one side of the model-check comparison.
+ */
+export type BundleSide = 'left' | 'right'
+
+/**
+ * Describes the bundle that is selected for one side of the comparison.
+ */
+export interface BundleMetadata {
+  /** The name of the bundle. */
+  name: string
+  /** The URL of the bundle, or 'current' for the bundle built into the report app. */
+  url: string
+}
+
+/**
+ * Return the `LocalStorage` key used to hold the selected bundle for the given side.
+ *
+ * @param side The side of the comparison.
+ * @returns The `LocalStorage` key.
+ */
+function keyForSide(side: BundleSide): string {
+  return `sde-check-selected-bundle-${side}`
+}
+
+/**
+ * Return the metadata for the bundle that was previously selected for the given side.
+ *
+ * @param side The side of the comparison.
+ * @returns The saved bundle metadata, or undefined if there is no valid saved metadata.
+ */
+export function loadBundleMetadata(side: BundleSide): BundleMetadata | undefined {
+  const metadataJson = localStorage.getItem(keyForSide(side))
+  if (metadataJson) {
+    try {
+      const parsed = JSON.parse(metadataJson)
+      if (parsed.name && parsed.url) {
+        return parsed as BundleMetadata
+      }
+    } catch (_e) {
+      // Treat malformed metadata the same as if no bundle was selected
+    }
+  }
+  return undefined
+}
+
+/**
+ * Save the metadata for the bundle that is selected for the given side.
+ *
+ * @param side The side of the comparison.
+ * @param metadata The bundle metadata to be saved.
+ */
+export function saveBundleMetadata(side: BundleSide, metadata: BundleMetadata): void {
+  localStorage.setItem(keyForSide(side), JSON.stringify(metadata))
+}
+
+/**
+ * Forget the bundle that is selected for the given side.
+ *
+ * @param side The side of the comparison.
+ */
+export function clearBundleMetadata(side: BundleSide): void {
+  localStorage.removeItem(keyForSide(side))
+}

package/template-report/src/index.ts

@@ -6,9 +6,11 @@ import type { BundleLocation, BundleSpec } from '@sdeverywhere/check-ui-shell'
 import { initAppShell } from '@sdeverywhere/check-ui-shell'
 import '@sdeverywhere/check-ui-shell/dist/style.css'
 
-import type { BundleMetadata, BundleResult } from './load-bundle'
+import type { BundleMetadata } from './bundle-metadata'
+import { loadBundleMetadata, saveBundleMetadata } from './bundle-metadata'
 import { loadBundle } from './load-bundle'
 import { initOverlay } from './overlay'
+import { resolveBundle } from './resolve-bundle'
 
 import './global.css'
 
@@ -17,36 +19,6 @@ import { createBundle as createBaselineBundle } from '@_baseline_bundle_'
 import { createBundle as createCurrentBundle } from '@_current_bundle_'
 import { getConfigOptions } from '@_test_config_'
 
-function loadBundleMetadata(side: 'left' | 'right'): BundleMetadata | undefined {
-  if (import.meta.hot) {
-    const metadataJson = localStorage.getItem(`sde-check-selected-bundle-${side}`)
-    if (metadataJson) {
-      const parsed = JSON.parse(metadataJson)
-      if (parsed.name && parsed.url) {
-        return parsed as BundleMetadata
-      }
-    }
-  }
-  return undefined
-}
-
-function saveBundleMetadata(side: 'left' | 'right', metadata: BundleMetadata): void {
-  if (import.meta.hot) {
-    localStorage.setItem(`sde-check-selected-bundle-${side}`, JSON.stringify(metadata))
-  }
-}
-
-// For local development mode, use the bundle metadata saved in `LocalStorage`
-let savedBundleMetadataL: BundleMetadata | undefined
-let savedBundleMetadataR: BundleMetadata | undefined
-// The following value will be injected by `vite-config-for-report.ts`
-const bundlesPath = './bundles/**/*.txt'
-if (import.meta.hot && bundlesPath) {
-  // Restore the previously selected bundles (from before the page was reloaded)
-  savedBundleMetadataL = loadBundleMetadata('left')
-  savedBundleMetadataR = loadBundleMetadata('right')
-}
-
 async function initForProduction(): Promise<void> {
   // For "production" builds, load the summary from a JSON file that
   // was generated as part of the build process.  This makes the
@@ -87,56 +59,27 @@ async function initForProduction(): Promise<void> {
 }
 
 async function initForLocal(): Promise<void> {
-  async function createBundle(
-    bundleMetadata: BundleMetadata | undefined,
-    side: 'left' | 'right'
-  ): Promise<BundleResult> {
-    if (bundleMetadata === undefined) {
-      bundleMetadata = {
-        name: 'current',
-        url: 'current'
-      }
-    }
-
-    if (bundleMetadata.url.startsWith('http') || bundleMetadata.url.startsWith('file://')) {
-      // Load bundles (both local and remote) via the Vite dev server
-      try {
-        console.log(`Loading bundle for ${side} side: name=${bundleMetadata.name} url=${bundleMetadata.url}`)
-        const result = await loadBundle(bundleMetadata)
-        if (result) {
-          return result
-        } else {
-          console.error(`ERROR: Failed to load bundle ${bundleMetadata.name}; will use "current" bundle instead`)
-        }
-      } catch (e) {
-        console.error(
-          `ERROR: Failed to load bundle from ${bundleMetadata.url}; will use "current" bundle instead. Cause:`,
-          e
-        )
-      }
-    }
-
-    // Load the "current" bundle if it was requested or if the other loading
-    // processes failed
-    console.log(`Loading current bundle for ${side} side`)
-    const bundle = createCurrentBundle()
-    return {
-      bundle,
-      bundleName: 'current',
-      bundleUrl: 'current'
-    }
+  const resolveBundleDeps = {
+    loadBundle,
+    createCurrentBundle
   }
 
+  // Restore the bundles that were previously selected (from before the page was reloaded).
+  // Note that we read these each time the app is initialized, since `resolveBundle` will
+  // clear a saved selection if the bundle cannot be loaded.
+  const savedBundleMetadataL = loadBundleMetadata('left')
+  const savedBundleMetadataR = loadBundleMetadata('right')
+
   const {
     bundle: bundleL,
     bundleName: bundleNameL,
     bundleUrl: bundleUrlL
-  } = await createBundle(savedBundleMetadataL, 'left')
+  } = await resolveBundle('left', savedBundleMetadataL, resolveBundleDeps)
   const {
     bundle: bundleR,
     bundleName: bundleNameR,
     bundleUrl: bundleUrlR
-  } = await createBundle(savedBundleMetadataR, 'right')
+  } = await resolveBundle('right', savedBundleMetadataR, resolveBundleDeps)
 
   // Prepare the model check/comparison configuration
   const configInitOptions: ConfigInitOptions = {
@@ -197,13 +140,9 @@ if (import.meta.hot) {
   document.addEventListener('sde-check-bundle', e => {
     // Change the selected bundle
     const info = (e as CustomEvent).detail
-    const bundleMetadata = { name: info.name, url: info.url }
-    if (info.side === 'left') {
-      saveBundleMetadata('left', bundleMetadata)
-      savedBundleMetadataL = bundleMetadata
-    } else if (info.side === 'right') {
-      saveBundleMetadata('right', bundleMetadata)
-      savedBundleMetadataR = bundleMetadata
+    const bundleMetadata: BundleMetadata = { name: info.name, url: info.url }
+    if (info.side === 'left' || info.side === 'right') {
+      saveBundleMetadata(info.side, bundleMetadata)
     }
 
     // Reinitialize using the chosen bundles

package/template-report/src/load-bundle.ts

@@ -2,10 +2,7 @@
 
 import type { Bundle } from '@sdeverywhere/check-core'
 
-export interface BundleMetadata {
-  name: string
-  url: string
-}
+import type { BundleMetadata } from './bundle-metadata'
 
 export interface BundleResult {
   bundle: Bundle

package/template-report/src/resolve-bundle.spec.ts

@@ -0,0 +1,109 @@
+// Copyright (c) 2026 Climate Interactive / New Venture Fund
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { Bundle } from '@sdeverywhere/check-core'
+
+import type { BundleMetadata } from './bundle-metadata'
+import { loadBundleMetadata, saveBundleMetadata } from './bundle-metadata'
+import type { BundleResult } from './load-bundle'
+import type { ResolveBundleDeps } from './resolve-bundle'
+import { resolveBundle } from './resolve-bundle'
+
+/**
+ * A minimal in-memory implementation of the parts of the `Storage` API that are
+ * used by the bundle metadata functions.
+ */
+class FakeStorage {
+  private readonly items: Map<string, string> = new Map()
+
+  getItem(key: string): string | null {
+    const value = this.items.get(key)
+    return value !== undefined ? value : null
+  }
+
+  setItem(key: string, value: string): void {
+    this.items.set(key, value)
+  }
+
+  removeItem(key: string): void {
+    this.items.delete(key)
+  }
+}
+
+const currentBundle = { version: 1 } as unknown as Bundle
+const remoteBundle = { version: 1 } as unknown as Bundle
+
+const remoteMetadata: BundleMetadata = { name: 'remote-2', url: 'http://localhost:9000/remote-2.js' }
+
+function deps(loadBundle: ResolveBundleDeps['loadBundle']): ResolveBundleDeps {
+  return {
+    loadBundle,
+    createCurrentBundle: () => currentBundle
+  }
+}
+
+beforeEach(() => {
+  vi.stubGlobal('localStorage', new FakeStorage())
+  vi.spyOn(console, 'log').mockImplementation(() => {})
+  vi.spyOn(console, 'error').mockImplementation(() => {})
+})
+
+describe('resolveBundle', () => {
+  it('should use the current bundle if no metadata is provided', async () => {
+    const loadBundle = vi.fn()
+    const result = await resolveBundle('right', undefined, deps(loadBundle))
+    expect(result).toEqual({ bundle: currentBundle, bundleName: 'current', bundleUrl: 'current' })
+    expect(loadBundle).not.toHaveBeenCalled()
+  })
+
+  it('should use the current bundle if the saved metadata refers to the current bundle', async () => {
+    const loadBundle = vi.fn()
+    const metadata: BundleMetadata = { name: 'current', url: 'current' }
+    const result = await resolveBundle('right', metadata, deps(loadBundle))
+    expect(result).toEqual({ bundle: currentBundle, bundleName: 'current', bundleUrl: 'current' })
+    expect(loadBundle).not.toHaveBeenCalled()
+  })
+
+  it('should use the loaded bundle and keep the saved metadata if the bundle is loaded successfully', async () => {
+    saveBundleMetadata('right', remoteMetadata)
+    const loaded: BundleResult = {
+      bundle: remoteBundle,
+      bundleName: remoteMetadata.name,
+      bundleUrl: remoteMetadata.url
+    }
+    const loadBundle = vi.fn(async () => loaded)
+    const result = await resolveBundle('right', remoteMetadata, deps(loadBundle))
+    expect(result).toEqual(loaded)
+    expect(loadBundle).toHaveBeenCalledWith(remoteMetadata)
+    expect(loadBundleMetadata('right')).toEqual(remoteMetadata)
+  })
+
+  it('should fall back to the current bundle and clear the saved metadata if the bundle cannot be loaded', async () => {
+    saveBundleMetadata('right', remoteMetadata)
+    const loadBundle = vi.fn(async () => undefined)
+    const result = await resolveBundle('right', remoteMetadata, deps(loadBundle))
+    expect(result).toEqual({ bundle: currentBundle, bundleName: 'current', bundleUrl: 'current' })
+    expect(loadBundleMetadata('right')).toBeUndefined()
+  })
+
+  it('should fall back to the current bundle and clear the saved metadata if the load fails with an error', async () => {
+    saveBundleMetadata('left', remoteMetadata)
+    const loadBundle = vi.fn(async () => {
+      throw new Error('fetch failed')
+    })
+    const result = await resolveBundle('left', remoteMetadata, deps(loadBundle))
+    expect(result).toEqual({ bundle: currentBundle, bundleName: 'current', bundleUrl: 'current' })
+    expect(loadBundleMetadata('left')).toBeUndefined()
+  })
+
+  it('should clear the saved metadata for the failing side only', async () => {
+    const localMetadata: BundleMetadata = { name: 'previous', url: 'file:///previous.js' }
+    saveBundleMetadata('left', localMetadata)
+    saveBundleMetadata('right', remoteMetadata)
+    const loadBundle = vi.fn(async () => undefined)
+    await resolveBundle('right', remoteMetadata, deps(loadBundle))
+    expect(loadBundleMetadata('left')).toEqual(localMetadata)
+    expect(loadBundleMetadata('right')).toBeUndefined()
+  })
+})

package/template-report/src/resolve-bundle.ts

@@ -0,0 +1,64 @@
+// Copyright (c) 2026 Climate Interactive / New Venture Fund
+
+import type { Bundle } from '@sdeverywhere/check-core'
+
+import type { BundleMetadata, BundleSide } from './bundle-metadata'
+import { clearBundleMetadata } from './bundle-metadata'
+import type { BundleResult } from './load-bundle'
+
+/**
+ * The functions used by `resolveBundle` to load or create a bundle.
+ */
+export interface ResolveBundleDeps {
+  /** Load a bundle (local or remote) via the Vite dev server. */
+  loadBundle: (metadata: BundleMetadata) => Promise<BundleResult | undefined>
+  /** Create the "current" bundle that is built into the report app. */
+  createCurrentBundle: () => Bundle
+}
+
+/**
+ * Resolve the bundle to be used for one side of the comparison.
+ *
+ * If the given metadata refers to a local or remote bundle, that bundle will be loaded
+ * via the Vite dev server.  If it cannot be loaded, the saved selection is cleared (so
+ * that we don't try and fail to load the same bundle every time the app is reloaded)
+ * and the "current" bundle is used instead.
+ *
+ * @param side The side of the comparison.
+ * @param metadata The metadata for the selected bundle, or undefined if no bundle was selected.
+ * @param deps The functions used to load or create a bundle.
+ * @returns The resolved bundle along with its name and URL.
+ */
+export async function resolveBundle(
+  side: BundleSide,
+  metadata: BundleMetadata | undefined,
+  deps: ResolveBundleDeps
+): Promise<BundleResult> {
+  if (metadata && (metadata.url.startsWith('http') || metadata.url.startsWith('file://'))) {
+    // Load the bundle (either local or remote) via the Vite dev server
+    let failure: string
+    try {
+      console.log(`Loading bundle for ${side} side: name=${metadata.name} url=${metadata.url}`)
+      const result = await deps.loadBundle(metadata)
+      if (result) {
+        return result
+      }
+      failure = `ERROR: Failed to load bundle ${metadata.name}; will use "current" bundle instead`
+    } catch (e) {
+      failure = `ERROR: Failed to load bundle from ${metadata.url}; will use "current" bundle instead. Cause: ${e}`
+    }
+
+    // Forget the failed selection, otherwise we would try (and fail) to load the same
+    // bundle each time the app is reloaded
+    console.error(failure)
+    clearBundleMetadata(side)
+  }
+
+  // Use the "current" bundle if it was requested or if the load above failed
+  console.log(`Loading current bundle for ${side} side`)
+  return {
+    bundle: deps.createCurrentBundle(),
+    bundleName: 'current',
+    bundleUrl: 'current'
+  }
+}