ogm-viewer 0.4.0 → 0.5.1

package/dist/collection/lib/errors.js

@@ -0,0 +1,137 @@
+// Supertype for errors thrown inside ogm-viewer. `message` is inherited from Error; redeclaring it
+// here would emit an uninitialized class field that clobbers the value super() sets (under the
+// es2022 define-fields semantics this project compiles with), leaving every subtype's message empty.
+export class PreviewError extends Error {
+    title;
+    url;
+}
+// The OGM record URL responded with a non-OK HTTP status.
+class RecordLoadError extends PreviewError {
+    title = "This record couldn't be loaded";
+    constructor(status, url) {
+        super(`The record URL responded with an error (HTTP ${status}). Check that the URL is correct and the record is publicly available.`);
+        this.url = url;
+    }
+}
+// The OGM record URL fetch failed due to a network error or CORS restriction.
+class RecordNetworkError extends PreviewError {
+    title = "This record couldn't be reached";
+    constructor(url) {
+        super('The server may be unreachable, or it may be blocking cross-origin (CORS) requests from this page.');
+        this.url = url;
+    }
+}
+// The OGM record couldn't be parsed as JSON.
+class RecordParseError extends PreviewError {
+    title = "This record couldn't be parsed";
+    constructor(url) {
+        super("The record URL didn't return valid JSON metadata. It may be pointing at an HTML page or a malformed file.");
+        this.url = url;
+    }
+}
+// Something else went wrong reading the record.
+class RecordReadError extends PreviewError {
+    title = "This record couldn't be read";
+    constructor(message, url) {
+        super(message);
+        this.url = url;
+    }
+}
+// The reference URL responded with a non-OK HTTP status.
+class ReferenceLoadError extends PreviewError {
+    constructor(refType, status, url) {
+        super(`The reference URL responded with an error (HTTP ${status}). Check that the URL is correct and the reference is publicly available.`);
+        this.title = `The ${refType} preview couldn't be loaded`;
+        this.url = url;
+    }
+}
+// The reference URL fetch failed due to a network error or CORS restriction.
+class ReferenceNetworkError extends PreviewError {
+    constructor(refType, url) {
+        super('The server may be unreachable, or it may be blocking cross-origin (CORS) requests from this page.');
+        this.title = `The ${refType} preview couldn't be reached`;
+        this.url = url;
+    }
+}
+// Something else went wrong reading the reference.
+class ReferenceReadError extends PreviewError {
+    constructor(refType, message, url) {
+        super(message);
+        this.title = `The ${refType} preview couldn't be read`;
+        this.url = url;
+    }
+}
+// Used to re-raise HTTP responses from fetch() with a non-OK status as PreviewErrors
+export class HttpError extends Error {
+    status;
+    statusText;
+    url;
+    constructor(url, status, statusText) {
+        super(`HTTP ${status} ${statusText} for ${url}`);
+        this.name = 'HttpError';
+        this.status = status;
+        this.statusText = statusText;
+        this.url = url;
+    }
+}
+// Execute a fetch() and raise HttpError on non-OK status
+export async function fetchOrThrow(url, init) {
+    const response = await fetch(url, init);
+    if (!response.ok)
+        throw new HttpError(url, response.status, response.statusText);
+    return response;
+}
+// Attempt to get a useful HTTP status code from any error. We only keep values
+// over 400 because MapLibre uses code "0", which isn't a real HTTP status.
+function statusOf(error) {
+    if (error instanceof HttpError)
+        return error.status;
+    const status = error?.status;
+    return typeof status === 'number' && status >= 400 ? status : undefined;
+}
+// A fetch() failure to reach the server at all, or a CORS block, rejects with a TypeError. MapLibre
+// reports the same class of failure on its internal tile/data requests with a synthetic status of 0
+// (not a real HTTP status). Treat both as a network error so the user sees the unreachable/CORS
+// message rather than a generic read error or a nonsensical "HTTP 0".
+function isNetworkError(error) {
+    if (error instanceof TypeError)
+        return true;
+    return error?.status === 0;
+}
+// Attempt get a useful message from any error.
+function messageOf(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    return undefined;
+}
+// Generate a PreviewError when something went wrong loading the record.
+export function recordError(error, url) {
+    const status = statusOf(error);
+    const message = messageOf(error);
+    // The request failed to reach the server at all, or was blocked by CORS.
+    if (isNetworkError(error))
+        return new RecordNetworkError(url);
+    // If we have an HTTP status code, the server responded.
+    if (status !== undefined)
+        return new RecordLoadError(status, url);
+    // A SyntaxError here means we got a response but it wasn't valid JSON metadata.
+    if (error instanceof SyntaxError)
+        return new RecordParseError(url);
+    // Anything else (e.g. an unsupported metadata version thrown by OgmRecord's constructor).
+    return new RecordReadError(message ?? 'An unknown error occurred while reading this record.', url);
+}
+// Generate a PreviewError when something went wrong loading an individual reference.
+export function referenceError(error, refType, url) {
+    const status = statusOf(error);
+    const message = messageOf(error);
+    // The request failed to reach the server at all, or was blocked by CORS.
+    if (isNetworkError(error))
+        return new ReferenceNetworkError(refType, url);
+    // If we have an HTTP status code, the server responded.
+    if (status !== undefined)
+        return new ReferenceLoadError(refType, status, url);
+    // Anything else.
+    return new ReferenceReadError(refType, message ?? 'An unknown error occurred while reading this reference.', url);
+}

package/dist/collection/lib/errors.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, afterEach } from "@stencil/vitest";
+import { HttpError, PreviewError, fetchOrThrow, recordError, referenceError } from "./errors";
+describe('errors', () => {
+    afterEach(() => vi.restoreAllMocks());
+    describe('HttpError', () => {
+        it('captures the status, statusText, and url', () => {
+            const error = new HttpError('http://example.com/x', 404, 'Not Found');
+            expect(error).toBeInstanceOf(Error);
+            expect(error.name).toBe('HttpError');
+            expect(error.status).toBe(404);
+            expect(error.statusText).toBe('Not Found');
+            expect(error.url).toBe('http://example.com/x');
+            expect(error.message).toContain('404');
+        });
+    });
+    describe('fetchOrThrow', () => {
+        it('returns the response when the status is ok', async () => {
+            const response = new Response('{}', { status: 200 });
+            vi.spyOn(global, 'fetch').mockResolvedValueOnce(response);
+            await expect(fetchOrThrow('http://example.com/ok')).resolves.toBe(response);
+        });
+        it('throws an HttpError when the status is not ok', async () => {
+            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response('nope', { status: 500, statusText: 'Server Error' }));
+            await expect(fetchOrThrow('http://example.com/bad')).rejects.toMatchObject({ name: 'HttpError', status: 500, url: 'http://example.com/bad' });
+        });
+        it('propagates a network error (TypeError) unchanged', async () => {
+            const networkError = new TypeError('Failed to fetch');
+            vi.spyOn(global, 'fetch').mockRejectedValueOnce(networkError);
+            await expect(fetchOrThrow('http://example.com/cors')).rejects.toBe(networkError);
+        });
+    });
+    describe('recordError', () => {
+        it('always returns a PreviewError (and therefore an Error), carrying a usable message', () => {
+            const error = recordError(new Error('boom'), 'http://example.com/r');
+            expect(error).toBeInstanceOf(PreviewError);
+            expect(error).toBeInstanceOf(Error);
+            // Guards the class-field pitfall where redeclaring `message` blanks the value super() sets.
+            expect(error.message).toBeTruthy();
+        });
+        it('classifies an HttpError as an HTTP load error and includes the status', () => {
+            const error = recordError(new HttpError('http://example.com/r', 403, 'Forbidden'), 'http://example.com/r');
+            expect(error.title).toBe("This record couldn't be loaded");
+            expect(error.message).toContain('403');
+            expect(error.url).toBe('http://example.com/r');
+        });
+        it('classifies a SyntaxError as a parse error', () => {
+            const error = recordError(new SyntaxError('Unexpected token < in JSON'), 'http://example.com/r');
+            expect(error.title).toBe("This record couldn't be parsed");
+            expect(error.message).toMatch(/JSON/);
+        });
+        it('classifies a fetch TypeError as a network/CORS error', () => {
+            const error = recordError(new TypeError('Failed to fetch'), 'http://example.com/r');
+            expect(error.title).toBe("This record couldn't be reached");
+            expect(error.message).toMatch(/CORS/);
+        });
+        it('falls back to a read error for other failures (e.g. an unsupported metadata version)', () => {
+            const error = recordError(new Error('Unsupported metadata version: GeoBlacklight'), 'http://example.com/r');
+            expect(error.title).toBe("This record couldn't be read");
+            expect(error.message).toContain('Unsupported metadata version');
+        });
+    });
+    describe('referenceError', () => {
+        it('names the source in the title and keeps the url', () => {
+            const error = referenceError(new TypeError('Failed to fetch'), 'GeoJSON', 'http://example.com/data.json');
+            expect(error).toBeInstanceOf(PreviewError);
+            expect(error.title).toContain('GeoJSON');
+            expect(error.url).toBe('http://example.com/data.json');
+        });
+        it('classifies an HttpError as an HTTP load error', () => {
+            const error = referenceError(new HttpError('http://example.com/wms', 502, 'Bad Gateway'), 'WMS');
+            expect(error.title).toBe("The WMS preview couldn't be loaded");
+            expect(error.message).toContain('502');
+        });
+        it('reads a numeric status off a library error object (e.g. MapLibre AjaxError)', () => {
+            const error = referenceError({ status: 404, message: 'not found' }, 'XYZ tiles');
+            expect(error.title).toBe("The XYZ tiles preview couldn't be loaded");
+            expect(error.message).toContain('404');
+        });
+        it('classifies a fetch TypeError as a network/CORS error', () => {
+            const error = referenceError(new TypeError('Failed to fetch'), 'IIIF Image');
+            expect(error.title).toBe("The IIIF Image preview couldn't be reached");
+            expect(error.message).toMatch(/CORS/);
+        });
+        it('falls back to a read error for a non-HTTP, non-network failure', () => {
+            const error = referenceError(new Error('open-failed'), 'IIIF Image');
+            expect(error.title).toBe("The IIIF Image preview couldn't be read");
+            expect(error.message).toContain('open-failed');
+        });
+        it('treats a status-0 error (MapLibre CORS/network block) as a network error, not "HTTP 0"', () => {
+            const error = referenceError({ status: 0, message: 'Failed to fetch' }, 'Web Map Service (WMS)');
+            expect(error.title).toBe("The Web Map Service (WMS) preview couldn't be reached");
+            expect(error.message).toMatch(/CORS/);
+            expect(error.message).not.toContain('HTTP 0');
+        });
+    });
+});

package/dist/collection/lib/sources/geojson.js

@@ -1,12 +1,13 @@
 import geojsonExtent from "@mapbox/geojson-extent";
 import VectorSource from "./vector";
+import { fetchOrThrow } from "../errors";
 export default class GeoJSONSource extends VectorSource {
     // Data parsed from GeoJSON document
     data;
     // Fetch and memoize data
     async getData() {
         if (!this.data) {
-            const resp = await fetch(this.url);
+            const resp = await fetchOrThrow(this.url);
             this.data = await resp.json();
         }
         return this.data;

package/dist/collection/lib/sources/iiif-manifest.js

@@ -1,4 +1,5 @@
 import IIIFSource from "./iiif";
+import { fetchOrThrow } from "../errors";
 // A manifest containing multiple IIIF image URLs for preview
 export default class IIIFManifestSource extends IIIFSource {
     // The parsed manifest contents
@@ -21,9 +22,7 @@ export default class IIIFManifestSource extends IIIFSource {
     async fetchManifest() {
         if (this.manifest)
             return this.manifest;
-        const response = await fetch(this.url);
-        if (!response.ok)
-            throw new Error(`Unexpected response fetching IIIF manifest: ${response.statusText}`);
+        const response = await fetchOrThrow(this.url);
         const manifest = await response.json();
         this.manifest = manifest;
         return manifest;

package/dist/collection/lib/sources/iiif-manifest.test.js

@@ -66,13 +66,13 @@ describe('IIIFManifestSource', () => {
         it('should fetch and extract image URLs from a IIIF v2 manifest', async () => {
             const fetchSpy = vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(v2Manifest)));
             const urls = await createSource().getIIIFImageUrls();
-            expect(fetchSpy).toHaveBeenCalledWith(MANIFEST_URL);
+            expect(fetchSpy.mock.calls[0][0]).toBe(MANIFEST_URL);
             expect(urls).toEqual(['http://example.com/image1/info.json']);
         });
         it('should fetch and extract image URLs from a IIIF v3 manifest', async () => {
             const fetchSpy = vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(v3Manifest)));
             const urls = await createSource().getIIIFImageUrls();
-            expect(fetchSpy).toHaveBeenCalledWith(MANIFEST_URL);
+            expect(fetchSpy.mock.calls[0][0]).toBe(MANIFEST_URL);
             expect(urls).toEqual(['http://example.com/image1/info.json']);
         });
         it('should not fetch the manifest again if already cached', async () => {
@@ -94,9 +94,9 @@ describe('IIIFManifestSource', () => {
             vi.spyOn(global, 'fetch').mockRejectedValueOnce(new Error('Network error'));
             await expect(createSource().getIIIFImageUrls()).rejects.toThrow('Network error');
         });
-        it('should throw if the manifest response is not ok', async () => {
+        it('should throw an HttpError if the manifest response is not ok', async () => {
             vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response('Not found', { status: 404, statusText: 'Not Found' }));
-            await expect(createSource().getIIIFImageUrls()).rejects.toThrow('Unexpected response fetching IIIF manifest');
+            await expect(createSource().getIIIFImageUrls()).rejects.toMatchObject({ name: 'HttpError', status: 404 });
         });
         it('should throw if the manifest is not valid JSON', async () => {
             vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response('invalid json'));

package/dist/esm/{lerc-Bz409klg.js → lerc-yC3LNu-h.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from './pako.esm-KbdoS3Oq.js';
-import { g as getDefaultExportFromCjs, L as LercAddCompression, a as LercParameters } from './ogm-attributes.ogm-image.ogm-map.ogm-menubar.ogm-metadata.ogm-previews.ogm-settings.ogm-sidebar.ogm-viewer-C9zV3wMe.js';
+import { g as getDefaultExportFromCjs, L as LercAddCompression, a as LercParameters } from './ogm-alerts.ogm-attributes.ogm-image.ogm-map.ogm-menubar.ogm-metadata.ogm-preview.ogm-previews.ogm-settings.ogm-sidebar.ogm-viewer-BpVupgSB.js';
 import { B as BaseDecoder } from './basedecoder-BK531nfi.js';
 import './index-DTLAlWKQ.js';
 

package/dist/esm/loader.js

@@ -5,7 +5,7 @@ import { g as globalScripts } from './app-globals-DQuL1Twl.js';
 const defineCustomElements = async (win, options) => {
   if (typeof window === 'undefined') return undefined;
   await globalScripts();
-  return bootstrapLazy([["ogm-attributes_9",[[513,"ogm-viewer",{"recordUrl":[1,"record-url"],"theme":[1],"record":[32],"previewOpacity":[32],"sidebarOpen":[32],"loadRecord":[64]},[[0,"sidebarToggled","toggleSidebar"],[0,"opacityChange","adjustPreviewOpacity"],[0,"mapLoading","setLoadingStarted"],[0,"imageLoading","setLoadingStarted"],[0,"mapIdle","setLoadingFinished"],[0,"imageLoaded","setLoadingFinished"]],{"recordUrl":[{"updateRecord":0}]}],[513,"ogm-previews",{"theme":[1],"record":[16],"previewOpacity":[2,"preview-opacity"],"sidebarPadding":[2,"sidebar-padding"],"sources":[32]},null,{"record":[{"getSources":0}]}],[513,"ogm-sidebar",{"record":[16],"theme":[1],"open":[4]}],[513,"ogm-menubar",{"record":[16],"theme":[1],"loading":[4]}],[513,"ogm-map",{"source":[16],"theme":[1],"padding":[2],"easeMapTo":[64]},[[16,"featureSelected","handleFeatureSelected"]],{"source":[{"previewSource":0}],"padding":[{"onPaddingChange":0}]}],[513,"ogm-image",{"source":[16],"theme":[1],"padding":[2]},null,{"source":[{"onSourceChange":0}],"padding":[{"onPaddingChange":0}]}],[513,"ogm-metadata",{"record":[16],"theme":[1],"fieldNames":[16],"filteredRecord":[32]}],[513,"ogm-settings",{"record":[16]},[[0,"input","handleOpacityChange"]]],[513,"ogm-attributes",{"features":[16],"currentIndex":[32]},null,{"features":[{"onFeaturesChange":0}],"currentIndex":[{"onCurrentIndexChange":0}]}]]]], options);
+  return bootstrapLazy([["ogm-alerts_11",[[513,"ogm-viewer",{"recordUrl":[1,"record-url"],"theme":[1],"hideTitle":[4,"hide-title"],"record":[32],"error":[32],"previewOpacity":[32],"sidebarOpen":[32],"loading":[32],"loadRecord":[64]},[[0,"sidebarToggled","toggleSidebar"],[0,"opacityChange","adjustPreviewOpacity"],[0,"mapLoading","setLoadingStarted"],[0,"imageLoading","setLoadingStarted"],[0,"mapIdle","setLoadingFinished"],[0,"imageLoaded","setLoadingFinished"]],{"recordUrl":[{"updateRecord":0}],"record":[{"resetLoading":0}]}],[513,"ogm-previews",{"theme":[1],"record":[16],"previewOpacity":[2,"preview-opacity"],"sidebarPadding":[2,"sidebar-padding"],"sources":[32]},null,{"record":[{"getSources":0}]}],[513,"ogm-sidebar",{"record":[16],"theme":[1],"open":[4]}],[513,"ogm-menubar",{"record":[16],"theme":[1],"loading":[4],"hideTitle":[4,"hide-title"]}],[513,"ogm-preview",{"theme":[1],"source":[16],"previewOpacity":[2,"preview-opacity"],"sidebarPadding":[2,"sidebar-padding"],"error":[32]},[[0,"previewError","handlePreviewError"]],{"source":[{"resetError":0}]}],[513,"ogm-metadata",{"record":[16],"theme":[1],"fieldNames":[16],"filteredRecord":[32]}],[513,"ogm-settings",{"record":[16]},[[0,"input","handleOpacityChange"]]],[513,"ogm-map",{"source":[16],"theme":[1],"padding":[2],"easeMapTo":[64]},[[16,"featureSelected","handleFeatureSelected"]],{"source":[{"previewSource":0}],"theme":[{"onThemeChange":0}],"padding":[{"onPaddingChange":0}]}],[513,"ogm-alerts",{"theme":[1],"error":[16]}],[513,"ogm-image",{"source":[16],"theme":[1],"padding":[2]},null,{"source":[{"onSourceChange":0}],"padding":[{"onPaddingChange":0}]}],[513,"ogm-attributes",{"features":[16],"currentIndex":[32]},null,{"features":[{"onFeaturesChange":0}],"currentIndex":[{"onCurrentIndexChange":0}]}]]]], options);
 };
 
 export { defineCustomElements };