ogm-viewer 0.3.0 → 0.4.0

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

@@ -74,156 +74,6 @@ describe('References', () => {
             expect(references.iiifManifestUrl).toBe('http://example.com/manifest.json');
         });
     });
-    describe('Fetching IIIF image URLs', () => {
-        it('should return IIIF image URL directly if present', async () => {
-            const contents = { 'http://iiif.io/api/image': 'http://example.com/image1/info.json' };
-            const references = new References(JSON.stringify(contents));
-            const urls = await references.iiifImageUrls();
-            expect(urls).toEqual(['http://example.com/image1/info.json']);
-        });
-        it('should fetch and extract image URLs from IIIF v2 manifest', async () => {
-            const manifest = {
-                '@context': 'http://iiif.io/api/presentation/2/context.json',
-                '@id': 'http://example.com/manifest.json',
-                '@type': 'sc:Manifest',
-                'sequences': [
-                    {
-                        canvases: [
-                            {
-                                images: [
-                                    {
-                                        resource: {
-                                            '@id': 'http://example.com/image1/full/full/0/default.jpg',
-                                            '@type': 'dctypes:Image',
-                                            'service': {
-                                                '@id': 'http://example.com/image1',
-                                            },
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            };
-            const references = new References(JSON.stringify({ 'http://iiif.io/api/presentation#manifest': 'http://example.com/manifest.json' }));
-            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(manifest)));
-            const urls = await references.iiifImageUrls();
-            expect(urls).toEqual(['http://example.com/image1/info.json']);
-        });
-        it('should fetch and extract image URLs from IIIF v3 manifest', async () => {
-            const manifest = {
-                '@context': 'http://iiif.io/api/presentation/3/context.json',
-                'id': 'http://example.com/manifest.json',
-                'type': 'Manifest',
-                'items': [
-                    {
-                        id: 'http://example.com/canvas1',
-                        type: 'Canvas',
-                        items: [
-                            {
-                                id: 'http://example.com/annotationpage1',
-                                type: 'AnnotationPage',
-                                items: [
-                                    {
-                                        id: 'http://example.com/annotation1',
-                                        type: 'Annotation',
-                                        body: {
-                                            id: 'http://example.com/image1/full/full/0/default.jpg',
-                                            type: 'Image',
-                                            service: {
-                                                id: 'http://example.com/image1',
-                                                type: 'ImageService2',
-                                            },
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            };
-            const references = new References(JSON.stringify({ 'http://iiif.io/api/presentation#manifest': 'http://example.com/manifest.json' }));
-            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(manifest)));
-            const urls = await references.iiifImageUrls();
-            expect(urls).toEqual(['http://example.com/image1/info.json']);
-        });
-        it('should not fetch manifest again if already cached', async () => {
-            const manifest = {
-                '@context': 'http://iiif.io/api/presentation/2/context.json',
-                '@id': 'http://example.com/manifest.json',
-                '@type': 'sc:Manifest',
-                'sequences': [
-                    {
-                        canvases: [
-                            {
-                                images: [
-                                    {
-                                        resource: {
-                                            '@id': 'http://example.com/image1/full/full/0/default.jpg',
-                                            '@type': 'dctypes:Image',
-                                            'service': {
-                                                '@id': 'http://example.com/image1',
-                                            },
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            };
-            const references = new References(JSON.stringify({ 'http://iiif.io/api/presentation#manifest': 'http://example.com/manifest.json' }));
-            const fetchSpy = vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(manifest)));
-            const urls1 = await references.iiifImageUrls();
-            const urls2 = await references.iiifImageUrls();
-            expect(fetchSpy).toHaveBeenCalledTimes(1);
-            expect(urls1).toEqual(['http://example.com/image1/info.json']);
-            expect(urls2).toEqual(['http://example.com/image1/info.json']);
-        });
-        it('should return empty array if manifest URL is not present', async () => {
-            const references = new References('{}');
-            const urls = await references.iiifImageUrls();
-            expect(urls).toEqual([]);
-        });
-        it('should return empty array if manifest has no items', async () => {
-            const manifest = {
-                '@context': 'http://iiif.io/api/presentation/3/context.json',
-                'id': 'http://example.com/manifest.json',
-                'type': 'Manifest',
-                'items': [],
-            };
-            const references = new References(JSON.stringify({ 'http://iiif.io/api/presentation#manifest': 'http://example.com/manifest.json' }));
-            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(manifest)));
-            const urls = await references.iiifImageUrls();
-            expect(urls).toEqual([]);
-        });
-        it('should return empty array and error if manifest fetch fails', async () => {
-            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            const references = new References(JSON.stringify({ 'http://iiif.io/api/presentation#manifest': 'http://example.com/manifest.json' }));
-            vi.spyOn(global, 'fetch').mockRejectedValueOnce(new Error('Network error'));
-            const urls = await references.iiifImageUrls();
-            expect(urls).toEqual([]);
-            expect(consoleErrorSpy).toHaveBeenCalled();
-        });
-        it('should return empty array and error if manifest does not match spec', async () => {
-            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            const manifest = { unexpected: 'structure' };
-            const references = new References(JSON.stringify({ 'http://iiif.io/api/presentation#manifest': 'http://example.com/manifest.json' }));
-            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(manifest)));
-            const urls = await references.iiifImageUrls();
-            expect(urls).toEqual([]);
-            expect(consoleErrorSpy).toHaveBeenCalled();
-        });
-        it('should return empty array if manifest is not valid JSON', async () => {
-            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            const references = new References(JSON.stringify({ 'http://iiif.io/api/presentation#manifest': 'http://example.com/manifest.json' }));
-            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response('invalid json'));
-            const urls = await references.iiifImageUrls();
-            expect(urls).toEqual([]);
-            expect(consoleErrorSpy).toHaveBeenCalled();
-        });
-    });
     describe('downloads', () => {
         it('should return empty links list if no download links are present', () => {
             const references = new References('{}');

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

@@ -1,7 +1,10 @@
 import RasterSource from "./raster";
 export default class CogSource extends RasterSource {
+    label() {
+        return 'Cloud Optimized GeoTIFF';
+    }
     // Appends the cog:// protocol; must be registered first to work
-    getSourceUrl() {
+    getMapLibreSourceUrl() {
         return `cog://${this.url}`;
     }
     // COGs have no specific scheme identifier for MapLibre
@@ -10,6 +13,6 @@ export default class CogSource extends RasterSource {
     }
     // TODO: is it possible to read COG metadata to get bounds?
     async getBounds() {
-        return undefined;
+        return super.getBounds();
     }
 }

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

@@ -11,6 +11,9 @@ export default class GeoJSONSource extends VectorSource {
         }
         return this.data;
     }
+    label() {
+        return 'GeoJSON';
+    }
     // GeoJSON is always a vector source
     async isVector() {
         return true;
@@ -20,14 +23,17 @@ export default class GeoJSONSource extends VectorSource {
         return undefined;
     }
     // GeoJSON has a special source type
-    async getType() {
+    async getMapLibreSourceType() {
         return 'geojson';
     }
     // Only one layer in a GeoJSON document
     async getVectorLayers() {
         return ['geojson'];
     }
+    // Used to zoom the map to the data once loaded
     async getBounds() {
+        if (this.bounds)
+            return this.bounds;
         const data = await this.getData();
         const bounds = geojsonExtent(data);
         return [

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

@@ -0,0 +1,55 @@
+import IIIFSource from "./iiif";
+// A manifest containing multiple IIIF image URLs for preview
+export default class IIIFManifestSource extends IIIFSource {
+    // The parsed manifest contents
+    manifest;
+    label() {
+        return 'IIIF Manifest';
+    }
+    // List of IIIF image URLs extracted from the manifest
+    async getIIIFImageUrls() {
+        // Fetch and cache the manifest if we haven't already
+        const manifest = await this.fetchManifest();
+        if (!manifest)
+            return [];
+        // Try to extract image URLs from the manifest
+        if (this.getIIIFVersion(manifest) == 3)
+            return this.extractIiif3ImageUrls(manifest);
+        return this.extractIiif2ImageUrls(manifest);
+    }
+    // Attempt to fetch and parse the IIIF manifest, if any
+    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 manifest = await response.json();
+        this.manifest = manifest;
+        return manifest;
+    }
+    // Get the IIIF presentation spec version of the manifest
+    getIIIFVersion(manifest) {
+        return manifest['@context']?.includes('http://iiif.io/api/presentation/3/context.json') ? 3 : 2;
+    }
+    // Given a v2 manifest, extract all of the IIIF images and format as info.json URLs
+    extractIiif2ImageUrls(manifest) {
+        return (manifest.sequences
+            .flatMap(seq => seq.canvases)
+            .flatMap(can => can.images)
+            .flatMap(img => img.resource)
+            //@ts-ignore
+            .flatMap(res => (res['@type'] === 'dctypes:Image' ? res.service['@id'] + '/info.json' : [])));
+    }
+    // Given a v3 manifest, extract all of the IIIF images and format as info.json URLs
+    extractIiif3ImageUrls(manifest) {
+        // Recursively search the '.items' key until we end up with nodes that have type 'ImageService2'
+        return (manifest.items
+            .flatMap(canvas => canvas.items)
+            .flatMap(annotationPage => annotationPage?.items || [])
+            .flatMap(annotation => (Array.isArray(annotation.body) ? annotation.body : [annotation.body]))
+            //@ts-ignore
+            .flatMap(annotationBody => annotationBody.service)
+            .flatMap(service => service.id + '/info.json'));
+    }
+}

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

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, afterEach } from "@stencil/vitest";
+import IIIFManifestSource from "./iiif-manifest";
+const MANIFEST_URL = 'http://example.com/manifest.json';
+// A source always points at a manifest URL; the manifest itself is fetched lazily
+const createSource = () => new IIIFManifestSource('test-id', MANIFEST_URL);
+// A minimal IIIF v2 manifest with a single image
+const v2Manifest = {
+    '@context': 'http://iiif.io/api/presentation/2/context.json',
+    '@id': MANIFEST_URL,
+    '@type': 'sc:Manifest',
+    'sequences': [
+        {
+            canvases: [
+                {
+                    images: [
+                        {
+                            resource: {
+                                '@id': 'http://example.com/image1/full/full/0/default.jpg',
+                                '@type': 'dctypes:Image',
+                                'service': {
+                                    '@id': 'http://example.com/image1',
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};
+// A minimal IIIF v3 manifest with a single image
+const v3Manifest = {
+    '@context': 'http://iiif.io/api/presentation/3/context.json',
+    'id': MANIFEST_URL,
+    'type': 'Manifest',
+    'items': [
+        {
+            id: 'http://example.com/canvas1',
+            type: 'Canvas',
+            items: [
+                {
+                    id: 'http://example.com/annotationpage1',
+                    type: 'AnnotationPage',
+                    items: [
+                        {
+                            id: 'http://example.com/annotation1',
+                            type: 'Annotation',
+                            body: {
+                                id: 'http://example.com/image1/full/full/0/default.jpg',
+                                type: 'Image',
+                                service: {
+                                    id: 'http://example.com/image1',
+                                    type: 'ImageService2',
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};
+describe('IIIFManifestSource', () => {
+    afterEach(() => vi.restoreAllMocks());
+    describe('getIIIFImageUrls', () => {
+        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(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(urls).toEqual(['http://example.com/image1/info.json']);
+        });
+        it('should not fetch the manifest again if already cached', async () => {
+            const fetchSpy = vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(v2Manifest)));
+            const source = createSource();
+            const urls1 = await source.getIIIFImageUrls();
+            const urls2 = await source.getIIIFImageUrls();
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+            expect(urls1).toEqual(['http://example.com/image1/info.json']);
+            expect(urls2).toEqual(['http://example.com/image1/info.json']);
+        });
+        it('should return an empty array if the manifest has no items', async () => {
+            const manifest = { ...v3Manifest, items: [] };
+            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify(manifest)));
+            const urls = await createSource().getIIIFImageUrls();
+            expect(urls).toEqual([]);
+        });
+        it('should throw if the manifest fetch fails', async () => {
+            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 () => {
+            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');
+        });
+        it('should throw if the manifest is not valid JSON', async () => {
+            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response('invalid json'));
+            await expect(createSource().getIIIFImageUrls()).rejects.toThrow();
+        });
+        it('should throw if the manifest does not match the IIIF spec', async () => {
+            vi.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(JSON.stringify({ unexpected: 'structure' })));
+            await expect(createSource().getIIIFImageUrls()).rejects.toThrow();
+        });
+    });
+});

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

@@ -0,0 +1,11 @@
+import Source from "./source";
+// A source of IIIF image URL(s) to be previewed
+export default class IIIFSource extends Source {
+    label() {
+        return 'IIIF Image';
+    }
+    // By default, assume we have a IIIF image URL and just return it
+    async getIIIFImageUrls() {
+        return [this.url];
+    }
+}

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

@@ -0,0 +1,8 @@
+import Source from "./source";
+// A source of mapped vector or raster data, accessed remotely
+export default class MapLibreSource extends Source {
+    // URL used to generate a MapLibre source when adding to map
+    getMapLibreSourceUrl() {
+        return this.url;
+    }
+}

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

@@ -4,4 +4,7 @@ export default class OpenIndexMapSource extends GeoJSONSource {
     async getVectorLayers() {
         return ['indexmap'];
     }
+    label() {
+        return 'Index Map';
+    }
 }

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

@@ -9,10 +9,13 @@ export default class PMTilesSource extends Source {
     metadata;
     header;
     // Store a reference so we can open the archive for metadata inspection
-    constructor(id, url) {
-        super(id, url);
+    constructor(id, url, bounds) {
+        super(id, url, bounds);
         this.archive = new PMTiles(url);
     }
+    label() {
+        return 'PMTiles';
+    }
     // Fetch and memoize PMTiles metadata
     async getMetadata() {
         if (!this.metadata) {
@@ -32,7 +35,10 @@ export default class PMTilesSource extends Source {
         const header = await this.getHeader();
         return header.tileType === TileType.Mvt || header.tileType === TileType.Mlt;
     }
+    // Used to zoom the map to the data once loaded
     async getBounds() {
+        if (this.bounds)
+            return this.bounds;
         const header = await this.getHeader();
         return [
             [header.minLon, header.minLat],
@@ -57,7 +63,7 @@ export default class PMTilesSource extends Source {
         return undefined;
     }
     // Appends the pmtiles:// protocol; must be registered first to work
-    getSourceUrl() {
+    getMapLibreSourceUrl() {
         return `pmtiles://${this.url}`;
     }
     // Raster PMTiles have no specific scheme identifier for MapLibre
@@ -68,7 +74,7 @@ export default class PMTilesSource extends Source {
     getTileSize() {
         return undefined;
     }
-    async getType() {
+    async getMapLibreSourceType() {
         if (await this.isVector())
             return 'vector';
         return 'raster';

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

@@ -1,13 +1,13 @@
-import Source from "./source";
+import MapLibreSource from "./maplibre";
 // Tiled raster data, accessed remotely
-export default class RasterSource extends Source {
+export default class RasterSource extends MapLibreSource {
     async isVector() {
         return false;
     }
     getTileSize() {
         return 256;
     }
-    async getType() {
+    async getMapLibreSourceType() {
         return 'raster';
     }
 }

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

@@ -1,20 +1,39 @@
-// A source of vector or raster data, accessed remotely
+// A source of previewable data at a URL
 export default class Source {
     // URL to the remote data source
     url;
-    // Unique ID for this source, used in MapLibre style generation
+    // Explicitly provided bounds for the source, if any
+    bounds;
+    // Unique ID for this source
     id;
     // Store the source URL
-    constructor(id, url) {
+    constructor(id, url, bounds) {
         this.id = id;
         this.url = url;
+        this.bounds = bounds;
+    }
+    // Used to label the tabs for switching between sources, e.g.
+    label() {
+        return this.constructor.name;
     }
     // Check that the URL is valid and accessible
     async test() {
-        await fetch(this.url, { method: 'HEAD' });
+        try {
+            const response = await fetch(this.url, {
+                method: 'HEAD',
+                signal: AbortSignal.timeout(8000),
+            });
+            return response.ok;
+        }
+        catch (error) {
+            console.error(`Error checking source URL ${this.url}:`, error);
+            return false;
+        }
     }
-    // URL used to generate a MapLibre source when adding to map
-    getSourceUrl() {
-        return this.url;
+    // Async because subclasses may do operations to calculate it
+    async getBounds() {
+        if (this.bounds)
+            return this.bounds;
+        return undefined;
     }
 }

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

@@ -3,6 +3,9 @@ import Source from "./source";
 export default class TileJSONSource extends Source {
     // Metadata parsed from TileJSON document
     metadata;
+    label() {
+        return 'TileJSON';
+    }
     // Fetch and memoize metadata
     async getMetadata() {
         if (!this.metadata) {
@@ -18,7 +21,10 @@ export default class TileJSONSource extends Source {
         const pathname = new URL(template).pathname;
         return pathname.endsWith('.pbf') || pathname.endsWith('.mvt') || pathname.endsWith('.mlt');
     }
+    // Used to zoom the map to the data once loaded
     async getBounds() {
+        if (this.bounds)
+            return this.bounds;
         const metadata = await this.getMetadata();
         return [
             [metadata.bounds[0], metadata.bounds[1]],
@@ -37,7 +43,7 @@ export default class TileJSONSource extends Source {
             return 'mlt';
         return 'mvt';
     }
-    async getType() {
+    async getMapLibreSourceType() {
         if (await this.isVector())
             return 'vector';
         return 'raster';

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

@@ -1,5 +1,8 @@
 import RasterSource from "./raster";
 export default class TmsSource extends RasterSource {
+    label() {
+        return 'Tiled Map Service (TMS)';
+    }
     getScheme() {
         return 'tms';
     }

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

@@ -1,10 +1,10 @@
-import Source from "./source";
+import MapLibreSource from "./maplibre";
 // A source of vector data, accessed remotely
-export default class VectorSource extends Source {
+export default class VectorSource extends MapLibreSource {
     async isVector() {
         return true;
     }
-    async getType() {
+    async getMapLibreSourceType() {
         return 'vector';
     }
 }

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

@@ -13,14 +13,17 @@ export default class WmsSource extends RasterSource {
     options;
     // Memoized metadata via GetCapabilities request
     metadata;
-    constructor(id, url, options) {
-        super(id, url);
+    constructor(id, url, options, bounds) {
+        super(id, url, bounds);
         this.options = { ...defaultOptions, ...options };
         // Assume we're using one layer with the given ID if no layer IDs are provided
         if (!this.options.layerIds || this.options.layerIds.length === 0) {
             this.options.layerIds = [id];
         }
     }
+    label() {
+        return 'Web Map Service (WMS)';
+    }
     // Fetch and memoize WMS GetCapabilities XML document
     async getMetadata() {
         if (!this.metadata) {
@@ -30,15 +33,7 @@ export default class WmsSource extends RasterSource {
         }
         return this.metadata;
     }
-    // WMS doesn't provide bounds in the URL, so we can't zoom the map
-    // TODO: use getCapabilities to get the bounding box of the layer(s) and return that
-    async getBounds() {
-        return [
-            [-180, -90],
-            [180, 90],
-        ];
-    }
-    getSourceUrl() {
+    getMapLibreSourceUrl() {
         return this.tilesUrl;
     }
     // WMS has no specific scheme identifier for MapLibre

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

@@ -1,5 +1,8 @@
 import RasterSource from "./raster";
 export default class XyzSource extends RasterSource {
+    label() {
+        return 'XYZ Tile Service';
+    }
     getScheme() {
         return 'xyz';
     }