ogcopenapis 0.0.12 → 1.0.0

package/lib/OgcOpenApiGetCapabilities.js

@@ -1,277 +1,424 @@
-import { OgcOpenApiFetchTools } from "./OgcOpenApiFetchTools";
-const SCALE_DENOMINATOR_TOLERANCE = 1e-8;
-export var CollectionLinkType;
-(function (CollectionLinkType) {
-    CollectionLinkType["Items"] = "items";
-    CollectionLinkType["Styles"] = "styles";
-    CollectionLinkType["Map"] = "map";
-    CollectionLinkType["Tiles"] = "tiles";
-})(CollectionLinkType || (CollectionLinkType = {}));
-const CollectionLinkTypeAlternatives = {
-    [CollectionLinkType.Items]: ["items", "item"],
-    [CollectionLinkType.Styles]: ["http://www.opengis.net/def/rel/ogc/1.0/styles", "styles"],
-    [CollectionLinkType.Map]: ["http://www.opengis.net/def/rel/ogc/1.0/map", "map"],
-    [CollectionLinkType.Tiles]: ["http://www.opengis.net/def/rel/ogc/1.0/tilesets-map", "tilesets-map"],
-};
-export class OgcOpenApiGetCapabilities {
-    static fromURL(inputRequest, options) {
-        return new Promise((resolve, reject) => {
-            const baseUrl = OgcOpenApiFetchTools.cleanUrl(inputRequest);
-            const requestUrl = OgcOpenApiFetchTools.cleanUrl(inputRequest);
-            const serverOptions = OgcOpenApiFetchTools.createFetchOptions({ originalUrl: requestUrl, proxify: options === null || options === void 0 ? void 0 : options.proxify });
-            OgcOpenApiFetchTools.fetch(requestUrl, {
-                method: 'GET',
-                credentials: (options === null || options === void 0 ? void 0 : options.credentials) ? "same-origin" : "omit",
-                headers: options ? options.requestHeaders : {},
-            }, serverOptions).then((response) => {
-                if (response.status === 200) {
-                    response.json().then((jsonObject) => {
-                        if (!jsonObject.links) {
-                            reject("Invalid format: (property 'links' is missing)");
-                            return;
-                        }
-                        let linkToData = jsonObject.links.find((link) => link.rel === 'data' && link.type === 'application/json');
-                        if (!linkToData) {
-                            linkToData = jsonObject.links.find((link) => link.rel === 'data');
-                        }
-                        const linkToApi = jsonObject.links.find((link) => {
-                            return ((link.rel === 'service-desc' || link.rel === 'service') &&
-                                link.type.indexOf('openapi+json') > -1);
-                        });
-                        const promiseArray = [];
-                        if (linkToData) {
-                            const collectionsPromise = OgcOpenApiGetCapabilities.fetchLinkContentAsJSON(linkToData, { credentials: options.credentials, requestHeaders: options.requestHeaders }, serverOptions);
-                            promiseArray.push(collectionsPromise);
-                            if (linkToApi) {
-                                const apiPromise = OgcOpenApiGetCapabilities.fetchLinkContentAsJSON(linkToApi, { credentials: options.credentials, requestHeaders: options.requestHeaders }, serverOptions);
-                                promiseArray.push(apiPromise);
-                            }
-                            Promise.all(promiseArray).then((responses) => {
-                                const responseDataLink = responses[0];
-                                const responseOpenApi = responses.length >= 1 ? responses[1] : undefined;
-                                const crsArray = typeof responseDataLink.crs !== "undefined" ? { crs: responseDataLink.crs } : {};
-                                const foundCollections = responseDataLink.collections.filter(c => options && options.filterCollectionsByLinkType ?
-                                    OgcOpenApiGetCapabilities.filterCollectionLinks(c.links, options.filterCollectionsByLinkType).length > 0 : true)
-                                    .map((collection) => {
-                                    const name = typeof collection.id !== 'undefined'
-                                        ? collection.id
-                                        : collection.name;
-                                    const collectionCrsObject = {};
-                                    if (typeof collection.crs !== "undefined")
-                                        collectionCrsObject.crs = collection.crs;
-                                    if (typeof collection.storageCrs !== "undefined")
-                                        collectionCrsObject.storageCrs = collection.storageCrs;
-                                    const layer = Object.assign({ description: collection.description, id: name, name, title: collection.title, keywords: collection.keywords
-                                            ? collection.keywords
-                                            : [], defaultReference: 'CRS:84', links: collection.links, outputFormats: options.filterCollectionsByLinkType ?
-                                            this.filterCollectionLinks(collection.links, options.filterCollectionsByLinkType).map(link => this.detectTypeFormat(link))
-                                            :
-                                                collection.links.map(link => this.detectTypeFormat(link)), extent: collection.extent }, collectionCrsObject);
-                                    return layer;
-                                });
-                                // console.log(featureTypes);
-                                const o = Object.assign(Object.assign({ name: '', collections: foundCollections.map(col => (Object.assign(Object.assign({}, col), { crs: col.crs ? col.crs : [], links: col.links.map(l => (Object.assign(Object.assign({}, l), { href: serverOptions.complete(l.href) }))) }))), version: responseOpenApi ? responseOpenApi.openapi : '', service: '', info: responseOpenApi ? responseOpenApi.info : {} }, crsArray), { serverOptions: serverOptions, baseUrl });
-                                resolve(o);
-                            });
-                        }
-                        else {
-                            reject("Invalid format: (property 'links' contains no links with rel=data");
-                        }
-                    }, () => {
-                        reject("Not JSON");
-                    });
-                }
-                else {
-                    reject(response.status);
-                }
-            }, (err) => {
-                reject(err);
-            });
-        });
-    }
-    static fetchLinkContentAsJSON(link, options, serverOptions) {
-        return new Promise((resolve) => {
-            OgcOpenApiFetchTools.fetch(link.href, { method: "GET", credentials: options.credentials ? "same-origin" : "omit", headers: options.requestHeaders }, serverOptions).then((result) => {
-                if (result.status === 200) {
-                    result.json().then((json) => resolve(json));
-                }
-                else {
-                    resolve(undefined);
-                }
-            }, () => {
-                resolve(undefined);
-            });
-        });
-    }
-    static filterCollectionLinks(links, linkType) {
-        switch (linkType) {
-            case CollectionLinkType.Items:
-            case CollectionLinkType.Map:
-            case CollectionLinkType.Styles:
-            case CollectionLinkType.Tiles:
-                return links.filter((link) => CollectionLinkTypeAlternatives[linkType].some(e => e === link.rel));
-            default:
-                return [];
-        }
-    }
-    static getDataLink(currentLayer, preferedFormat) {
-        const dataLink = OgcOpenApiGetCapabilities.filterCollectionLinks(currentLayer.links, CollectionLinkType.Items).find((link) => link.type === preferedFormat);
-        return dataLink ? dataLink.href : '';
-    }
-    static detectTypeFormat(link) {
-        if (link.type)
-            return link.type;
-        let rel = null;
-        for (let key in CollectionLinkTypeAlternatives) {
-            if (CollectionLinkTypeAlternatives.hasOwnProperty(key)) {
-                CollectionLinkTypeAlternatives[key].some(e => e === link.rel);
-                rel = key;
-                break;
-            }
-        }
-        if (rel) {
-            if (CollectionLinkType.Map)
-                return "image/png";
-        }
-        return "application/json";
-    }
-    static fetchTileSetsInFull(capabilities, options) {
-        return new Promise((resolve, reject) => {
-            this.fetchTileSets(capabilities, options).then((tileSetMetaArray) => {
-                const promises = tileSetMetaArray.map(tml => this.fetchTileset(capabilities, tml, options));
-                Promise.all(promises).then((arr) => {
-                    resolve(arr);
-                });
-            });
-        });
-    }
-    static getQuadTreeCompatibleLevelOffset(tileMatrixSet) {
-        const levels = tileMatrixSet.tileMatrices;
-        const reference = levels[levels.length - 1];
-        for (let level = levels.length - 2; level >= 0; level--) {
-            const current = levels[level];
-            // tslint:disable-next-line:no-bitwise
-            const multiplier = 1 << (levels.length - level - 1);
-            const errorMargin = current.scaleDenominator * SCALE_DENOMINATOR_TOLERANCE;
-            if (Math.abs(current.scaleDenominator - reference.scaleDenominator * multiplier) > errorMargin) {
-                return level + 1;
-            }
-            if (current.pointOfOrigin[0] !== reference.pointOfOrigin[0]) {
-                return level + 1;
-            }
-            if (current.tileWidth !== reference.tileWidth || current.tileHeight !== reference.tileHeight) {
-                return level + 1;
-            }
-            if (typeof current.variableMatrixWidths !== "undefined") {
-                return level + 1;
-            }
-            if (current.matrixWidth !== (reference.matrixWidth / multiplier) || current.matrixHeight !== (reference.matrixHeight / multiplier)) {
-                return level + 1;
-            }
-        }
-        return 0;
-    }
-    static fetchTileSets(capabilities, options) {
-        return new Promise((resolve, reject) => {
-            if (capabilities === null)
-                reject();
-            const url = capabilities.baseUrl + "tileMatrixSets";
-            OgcOpenApiFetchTools.fetch(url, {
-                method: "GET",
-                credentials: (options === null || options === void 0 ? void 0 : options.credentials) ? "same-origin" : "omit",
-                headers: (options === null || options === void 0 ? void 0 : options.requestHeaders) ? options.requestHeaders : {}
-            }, capabilities.serverOptions).then(result => {
-                if (result.status === 200) {
-                    result.json().then((data) => {
-                        if (data.tileMatrixSets) {
-                            resolve(data.tileMatrixSets.map(tml => (Object.assign(Object.assign({}, tml), { href: capabilities.serverOptions.complete(tml.href) }))));
-                        }
-                        else {
-                            reject({ error: true, message: "tileMatrixSets not defined" });
-                        }
-                    }, () => {
-                        reject({ error: true, message: "Not JSON data" });
-                    });
-                }
-                else {
-                    reject({ error: true, message: "Invalid response: " + result.status });
-                }
-            }, (err) => {
-                reject({ error: true, message: err.message });
-            });
-        });
-    }
-    static getTilesLink(capabilities, currentCollection, tileMatrixId, options) {
-        return new Promise((resolve, reject) => {
-            if (capabilities === null)
-                reject();
-            const dataLinks = OgcOpenApiGetCapabilities.filterCollectionLinks(currentCollection.links, CollectionLinkType.Tiles);
-            const link = dataLinks.find((link) => link.type === "application/json");
-            const href = link ? link.href : dataLinks.length > 0 ? dataLinks[0].href : '';
-            const tileInfoUrl = OgcOpenApiFetchTools.cleanUrl(href) + tileMatrixId;
-            OgcOpenApiFetchTools.fetch(tileInfoUrl, {
-                method: "GET",
-                credentials: (options === null || options === void 0 ? void 0 : options.credentials) ? "same-origin" : "omit",
-                headers: (options === null || options === void 0 ? void 0 : options.requestHeaders) ? options === null || options === void 0 ? void 0 : options.requestHeaders : {}
-            }, capabilities.serverOptions).then(result => {
-                if (result.status === 200) {
-                    result.json().then((data) => {
-                        if (data.links.length > 0) {
-                            const links = data.links.filter(l => l.rel === "item" || l.rel === "items").map(a => (Object.assign(Object.assign({}, a), { href: capabilities.serverOptions.complete(a.href) })));
-                            if (links) {
-                                resolve(links);
-                            }
-                            else {
-                                reject({ error: true, message: "Invalid" });
-                            }
-                        }
-                        else {
-                            reject({ error: true, message: "Invalid" });
-                        }
-                    }, () => {
-                        reject({ error: true, message: "Not JSON data" });
-                    });
-                }
-                else {
-                    reject({ error: true, message: "Invalid response: " + result.status });
-                }
-            }, (err) => {
-                reject({ error: true, message: err.message });
-            });
-        });
-    }
-    static fetchTileset(capabilities, tileset, options) {
-        return new Promise((resolve, reject) => {
-            if (capabilities === null) {
-                reject();
-                return;
-            }
-            let jsonLink = tileset.links.find(l => l.type ? l.type === "application/json" : false);
-            jsonLink = jsonLink ? jsonLink : tileset.links[0];
-            const href = OgcOpenApiFetchTools.cleanUrlToAsset(jsonLink.href);
-            OgcOpenApiFetchTools.fetch(href, {
-                method: "GET",
-                credentials: (options === null || options === void 0 ? void 0 : options.credentials) ? "same-origin" : "omit",
-                headers: options ? options.requestHeaders : {}
-            }, capabilities.serverOptions).then(result => {
-                if (result.status === 200) {
-                    result.json().then((data) => {
-                        if (typeof data.id !== "undefined" && data.tileMatrices && data.crs) {
-                            resolve(data);
-                        }
-                        else {
-                            reject({ error: true, message: "TileSet has invalid data" });
-                        }
-                    }, () => {
-                        reject({ error: true, message: "Not JSON data" });
-                    });
-                }
-                else {
-                    reject({ error: true, message: "Invalid response: " + result.status });
-                }
-            }, (err) => {
-                reject({ error: true, message: err.message });
-            });
-        });
-    }
-}
+import { OgcOpenApiFetchTools } from "./OgcOpenApiFetchTools.js";
+const SCALE_DENOMINATOR_TOLERANCE = 1e-8;
+export var CollectionLinkType;
+(function (CollectionLinkType) {
+    CollectionLinkType["Items"] = "items";
+    CollectionLinkType["Styles"] = "styles";
+    CollectionLinkType["Map"] = "map";
+    CollectionLinkType["Tiles"] = "tiles";
+    CollectionLinkType["VectorTiles"] = "vectorTiles";
+})(CollectionLinkType || (CollectionLinkType = {}));
+const CollectionLinkTypeAlternatives = {
+    [CollectionLinkType.Items]: ["items", "item"],
+    [CollectionLinkType.Styles]: ["http://www.opengis.net/def/rel/ogc/1.0/styles", "styles"],
+    [CollectionLinkType.Map]: ["http://www.opengis.net/def/rel/ogc/1.0/map", "map"],
+    [CollectionLinkType.Tiles]: ["http://www.opengis.net/def/rel/ogc/1.0/tilesets-map", "tilesets-map"],
+    [CollectionLinkType.VectorTiles]: ["http://www.opengis.net/def/rel/ogc/1.0/tilesets-vector", "tilesets-vector"],
+};
+// OGC API link relations are given in full or, by older servers, short: tiling-scheme or http://www.opengis.net/def/rel/ogc/1.0/tiling-scheme
+const OGC_REL = "http://www.opengis.net/def/rel/ogc/1.0/";
+const isRel = (link, rel) => link.rel === OGC_REL + rel || link.rel === rel;
+const CollectionLinkTypeDefaultFormat = {
+    [CollectionLinkType.Map]: "image/png",
+    [CollectionLinkType.Tiles]: "image/png",
+    [CollectionLinkType.VectorTiles]: "application/vnd.mapbox-vector-tile",
+};
+export class OgcOpenApiGetCapabilities {
+    static fromURL(inputRequest, fromUrlOptions) {
+        const options = fromUrlOptions ? fromUrlOptions : {};
+        return new Promise((resolve, reject) => {
+            const baseUrl = OgcOpenApiFetchTools.cleanUrl(inputRequest);
+            const requestUrl = OgcOpenApiFetchTools.cleanUrl(inputRequest);
+            const serverOptions = OgcOpenApiFetchTools.createFetchOptions({ originalUrl: requestUrl, proxify: options?.proxify });
+            OgcOpenApiFetchTools.fetch(requestUrl, {
+                method: 'GET',
+                credentials: options?.credentials ? "same-origin" : "omit",
+                headers: options ? options.requestHeaders : {},
+            }, serverOptions).then((response) => {
+                if (response.status === 200) {
+                    response.json().then((jsonObject) => {
+                        if (!jsonObject.links) {
+                            reject("Invalid format: (property 'links' is missing)");
+                            return;
+                        }
+                        let linkToData = jsonObject.links.find((link) => link.rel === 'data' && link.type === 'application/json');
+                        if (!linkToData) {
+                            linkToData = jsonObject.links.find((link) => link.rel === 'data');
+                        }
+                        const linkToApi = jsonObject.links.find((link) => {
+                            return ((link.rel === 'service-desc' || link.rel === 'service') &&
+                                link.type.indexOf('openapi+json') > -1);
+                        });
+                        const tilingSchemes = jsonObject.links.filter((link) => isRel(link, 'tiling-schemes'));
+                        const linkToTileMatrixSets = tilingSchemes.find((link) => link.type === 'application/json') || tilingSchemes.find((link) => !link.type);
+                        // The links of the landing page are relative to it, the links of the collections to /collections
+                        const resolveLink = (link, documentUrl) => ({ ...link, href: OgcOpenApiFetchTools.resolveUrl(link.href, documentUrl, serverOptions) });
+                        const promiseArray = [];
+                        if (linkToData) {
+                            const collectionsLink = resolveLink(linkToData, requestUrl);
+                            const collectionsPromise = OgcOpenApiGetCapabilities.fetchLinkContentAsJSON(collectionsLink, { credentials: options.credentials, requestHeaders: options.requestHeaders }, serverOptions);
+                            promiseArray.push(collectionsPromise);
+                            if (linkToApi) {
+                                const apiPromise = OgcOpenApiGetCapabilities.fetchLinkContentAsJSON(resolveLink(linkToApi, requestUrl), { credentials: options.credentials, requestHeaders: options.requestHeaders }, serverOptions);
+                                promiseArray.push(apiPromise);
+                            }
+                            Promise.all(promiseArray).then((responses) => {
+                                const responseDataLink = responses[0];
+                                const responseOpenApi = responses.length >= 1 ? responses[1] : undefined;
+                                const crsArray = typeof responseDataLink.crs !== "undefined" ? { crs: responseDataLink.crs } : {};
+                                const foundCollections = responseDataLink.collections.filter(c => options && options.filterCollectionsByLinkType ?
+                                    OgcOpenApiGetCapabilities.filterCollectionLinks(c.links, options.filterCollectionsByLinkType).length > 0 : true)
+                                    .map((collection) => {
+                                    const name = typeof collection.id !== 'undefined'
+                                        ? collection.id
+                                        : collection.name;
+                                    const collectionCrsObject = {};
+                                    if (typeof collection.crs !== "undefined")
+                                        collectionCrsObject.crs = collection.crs;
+                                    if (typeof collection.storageCrs !== "undefined")
+                                        collectionCrsObject.storageCrs = collection.storageCrs;
+                                    const layer = {
+                                        description: collection.description,
+                                        id: name,
+                                        name,
+                                        title: collection.title,
+                                        keywords: collection.keywords
+                                            ? collection.keywords
+                                            : [],
+                                        defaultReference: 'CRS:84',
+                                        links: collection.links,
+                                        outputFormats: options.filterCollectionsByLinkType ?
+                                            this.filterCollectionLinks(collection.links, options.filterCollectionsByLinkType).map(link => this.detectTypeFormat(link))
+                                            :
+                                                collection.links.map(link => this.detectTypeFormat(link)),
+                                        extent: collection.extent,
+                                        ...collectionCrsObject
+                                    };
+                                    return layer;
+                                });
+                                // console.log(featureTypes);
+                                const o = {
+                                    name: '',
+                                    collections: foundCollections.map(col => ({ ...col, crs: col.crs ? col.crs : [], links: col.links.map(l => resolveLink(l, collectionsLink.href)) })),
+                                    version: responseOpenApi ? responseOpenApi.openapi : '',
+                                    service: '',
+                                    info: responseOpenApi ? responseOpenApi.info : {},
+                                    ...crsArray,
+                                    serverOptions: serverOptions,
+                                    links: jsonObject.links.map(l => resolveLink(l, requestUrl)),
+                                    baseUrl,
+                                    tileMatrixSetsUrl: linkToTileMatrixSets ? resolveLink(linkToTileMatrixSets, requestUrl).href : undefined
+                                };
+                                resolve(o);
+                            });
+                        }
+                        else {
+                            reject("Invalid format: (property 'links' contains no links with rel=data");
+                        }
+                    }, () => {
+                        reject("Not JSON");
+                    });
+                }
+                else {
+                    reject(response.status);
+                }
+            }, (err) => {
+                reject(err);
+            });
+        });
+    }
+    static fetchLinkContentAsJSON(link, options, serverOptions) {
+        return new Promise((resolve) => {
+            OgcOpenApiFetchTools.fetch(link.href, { method: "GET", credentials: options.credentials ? "same-origin" : "omit", headers: options.requestHeaders }, serverOptions).then((result) => {
+                if (result.status === 200) {
+                    result.json().then((json) => resolve(json));
+                }
+                else {
+                    resolve(undefined);
+                }
+            }, () => {
+                resolve(undefined);
+            });
+        });
+    }
+    static filterCollectionLinks(links, linkType) {
+        switch (linkType) {
+            case CollectionLinkType.Items:
+            case CollectionLinkType.Map:
+            case CollectionLinkType.Styles:
+            case CollectionLinkType.Tiles:
+            case CollectionLinkType.VectorTiles:
+                return links.filter((link) => CollectionLinkTypeAlternatives[linkType].some(e => e === link.rel));
+            default:
+                return [];
+        }
+    }
+    static getDataLink(currentLayer, preferedFormat) {
+        const dataLink = OgcOpenApiGetCapabilities.filterCollectionLinks(currentLayer.links, CollectionLinkType.Items).find((link) => link.type === preferedFormat);
+        return dataLink ? dataLink.href : '';
+    }
+    static detectTypeFormat(link) {
+        if (link.type)
+            return link.type;
+        for (const key in CollectionLinkTypeAlternatives) {
+            if (CollectionLinkTypeAlternatives.hasOwnProperty(key) && CollectionLinkTypeAlternatives[key].some(e => e === link.rel)) {
+                if (CollectionLinkTypeDefaultFormat[key])
+                    return CollectionLinkTypeDefaultFormat[key];
+                break;
+            }
+        }
+        return "application/json";
+    }
+    /**
+     * The tile matrix sets of the server, with their definitions. A definition that cannot be read is left out, so one
+     * broken definition does not hide the others. Rejects only when none can be read.
+     */
+    static async fetchTileSetsInFull(capabilities, options) {
+        const tileSetMetaArray = await this.fetchTileSets(capabilities, options);
+        const settled = await Promise.all(tileSetMetaArray.map(tml => this.fetchTileset(capabilities, tml, options).then(tileSet => ({ tileSet, error: undefined }), error => ({ tileSet: undefined, error }))));
+        const tileSets = settled.filter(s => s.tileSet).map(s => s.tileSet);
+        const failed = settled.find(s => !s.tileSet);
+        if (tileSets.length === 0 && failed)
+            throw failed.error;
+        return tileSets;
+    }
+    static getQuadTreeCompatibleLevelOffset(tileMatrixSet) {
+        const levels = tileMatrixSet.tileMatrices;
+        const reference = levels[levels.length - 1];
+        for (let level = levels.length - 2; level >= 0; level--) {
+            const current = levels[level];
+            // tslint:disable-next-line:no-bitwise
+            const multiplier = 1 << (levels.length - level - 1);
+            const errorMargin = current.scaleDenominator * SCALE_DENOMINATOR_TOLERANCE;
+            if (Math.abs(current.scaleDenominator - reference.scaleDenominator * multiplier) > errorMargin) {
+                return level + 1;
+            }
+            if (current.pointOfOrigin[0] !== reference.pointOfOrigin[0]) {
+                return level + 1;
+            }
+            if (current.tileWidth !== reference.tileWidth || current.tileHeight !== reference.tileHeight) {
+                return level + 1;
+            }
+            if (typeof current.variableMatrixWidths !== "undefined") {
+                return level + 1;
+            }
+            if (current.matrixWidth !== (reference.matrixWidth / multiplier) || current.matrixHeight !== (reference.matrixHeight / multiplier)) {
+                return level + 1;
+            }
+        }
+        return 0;
+    }
+    static async fetchTileSets(capabilities, options) {
+        if (capabilities === null)
+            throw { error: true, message: "No capabilities" };
+        const url = capabilities.tileMatrixSetsUrl ? capabilities.tileMatrixSetsUrl : capabilities.baseUrl + "tileMatrixSets";
+        const data = await OgcOpenApiGetCapabilities.fetchJson(capabilities, url, options);
+        if (!data.tileMatrixSets)
+            throw { error: true, message: "tileMatrixSets not defined" };
+        const resolve = (href) => OgcOpenApiFetchTools.resolveUrl(href, url, capabilities.serverOptions);
+        return data.tileMatrixSets.map(tml => ({
+            ...tml,
+            href: resolve(tml.href),
+            links: (tml.links ? tml.links : []).map(l => ({ ...l, href: resolve(l.href) }))
+        }));
+    }
+    // GETs a JSON document. Servers answer JSON for the Accept header, or for the f parameter that their links carry.
+    static async fetchJson(capabilities, href, options) {
+        let result;
+        try {
+            result = await OgcOpenApiFetchTools.fetch(href, {
+                method: "GET",
+                credentials: options?.credentials ? "same-origin" : "omit",
+                headers: { Accept: "application/json", ...(options?.requestHeaders ? options.requestHeaders : {}) }
+            }, capabilities.serverOptions);
+        }
+        catch (err) {
+            throw { error: true, message: err.message };
+        }
+        if (result.status !== 200)
+            throw { error: true, message: "Invalid response: " + result.status };
+        try {
+            return await result.json();
+        }
+        catch (err) {
+            throw { error: true, message: "Not JSON data" };
+        }
+    }
+    // The link that identifies the tile matrix set of a tileset, relative to the document that has it
+    static getTilingSchemeHref(capabilities, links, documentUrl) {
+        const tilingScheme = links.find(l => isRel(l, "tiling-scheme"));
+        return tilingScheme ? OgcOpenApiFetchTools.resolveUrl(tilingScheme.href, documentUrl, capabilities.serverOptions) : undefined;
+    }
+    static getTilesLink(capabilities, currentCollection, tileMatrixId, options, linkType = CollectionLinkType.Tiles) {
+        return this.fetchCollectionTileSet(capabilities, currentCollection, tileMatrixId, options, linkType).then(tileSet => tileSet.links);
+    }
+    // The tilesets link of a collection, the JSON one when the server types its links
+    static getTileSetsHref(collection, linkType) {
+        const dataLinks = OgcOpenApiGetCapabilities.filterCollectionLinks(collection.links, linkType);
+        const link = dataLinks.find((link) => link.type === "application/json");
+        return link ? link.href : dataLinks.length > 0 ? dataLinks[0].href : '';
+    }
+    // The tilesets link of the landing page: the tilesets of the dataset, with all its collections in each tile
+    static getDatasetTileSetsHref(capabilities, linkType) {
+        const dataLinks = OgcOpenApiGetCapabilities.filterCollectionLinks(capabilities.links ? capabilities.links : [], linkType);
+        const link = dataLinks.find((link) => link.type === "application/json") || dataLinks.find((link) => !link.type) || dataLinks[0];
+        return link ? link.href : '';
+    }
+    /**
+     * Whether the server tiles the dataset as a whole, all its collections in each tile, for linkType Tiles or VectorTiles
+     */
+    static hasDatasetTileSets(capabilities, linkType) {
+        return capabilities !== null && OgcOpenApiGetCapabilities.getDatasetTileSetsHref(capabilities, linkType) !== '';
+    }
+    /**
+     * Lists the tilesets of a collection: the tile matrix sets the collection is tiled in, which can be fewer than the
+     * tile matrix sets of the server.
+     */
+    static async fetchCollectionTileSets(capabilities, collection, linkType = CollectionLinkType.Tiles, options) {
+        if (capabilities === null)
+            throw { error: true, message: "No capabilities" };
+        const href = OgcOpenApiGetCapabilities.getTileSetsHref(collection, linkType);
+        if (href === '')
+            throw { error: true, message: "Collection " + collection.id + " has no " + linkType + " link" };
+        return OgcOpenApiGetCapabilities.fetchTileSetList(capabilities, href, options);
+    }
+    /**
+     * Lists the tilesets of the dataset (/tiles of the landing page): each tile has the data of all its collections.
+     * Some servers tile only the dataset (PDOK).
+     */
+    static async fetchDatasetTileSets(capabilities, linkType = CollectionLinkType.Tiles, options) {
+        if (capabilities === null)
+            throw { error: true, message: "No capabilities" };
+        const href = OgcOpenApiGetCapabilities.getDatasetTileSetsHref(capabilities, linkType);
+        if (href === '')
+            throw { error: true, message: "The dataset has no " + linkType + " link" };
+        return OgcOpenApiGetCapabilities.fetchTileSetList(capabilities, href, options);
+    }
+    static async fetchTileSetList(capabilities, href, options) {
+        const data = await OgcOpenApiGetCapabilities.fetchJson(capabilities, href, options);
+        if (!Array.isArray(data.tilesets))
+            throw { error: true, message: "Response has no tilesets" };
+        const tileSets = [];
+        for (const tileSet of data.tilesets) {
+            const links = tileSet.links ? tileSet.links : [];
+            const selfLinks = links.filter(l => l.rel === "self");
+            const self = selfLinks.find(l => l.type === "application/json") || selfLinks[0];
+            if (!self)
+                continue;
+            tileSets.push({
+                tileMatrixSetURI: tileSet.tileMatrixSetURI,
+                tileMatrixSetId: tileSet.tileMatrixSetId,
+                dataType: tileSet.dataType,
+                crs: typeof tileSet.crs === "string" ? tileSet.crs : undefined,
+                href: OgcOpenApiFetchTools.resolveUrl(self.href, href, capabilities.serverOptions),
+                tilingSchemeHref: OgcOpenApiGetCapabilities.getTilingSchemeHref(capabilities, links, href),
+                tileMatrixSet: OgcOpenApiGetCapabilities.getInlineTileMatrixSet(tileSet),
+            });
+        }
+        return tileSets;
+    }
+    /**
+     * The tile matrix set of a tileset among the tile matrix sets of the server (fetchTileSetsInFull): by URI, which
+     * servers give with their own ids (CubeWerx: WebMercatorQuad is smerc), then by id.
+     */
+    static matchTileMatrixSet(tileSet, tileMatrixSets) {
+        const lastSegment = (url) => url.split("?")[0].replace(/\/$/, "").split("/").pop();
+        const byUri = tileSet.tileMatrixSetURI ? tileMatrixSets.find(t => OgcOpenApiGetCapabilities.sameUri(t.uri, tileSet.tileMatrixSetURI)) : undefined;
+        if (byUri)
+            return byUri;
+        const ids = [tileSet.tileMatrixSetId,
+            tileSet.tileMatrixSetURI ? lastSegment(tileSet.tileMatrixSetURI) : undefined,
+            tileSet.tilingSchemeHref ? lastSegment(tileSet.tilingSchemeHref) : undefined].filter(id => !!id);
+        return tileMatrixSets.find(t => ids.indexOf(t.id) > -1);
+    }
+    // Both forms name the same resource: http or https, the case of the scheme and host, a trailing slash
+    static sameUri(a, b) {
+        const normalize = (uri) => uri.trim().replace(/\/$/, "")
+            .replace(/^https?:\/\/[^/]*/i, prefix => prefix.toLowerCase().replace(/^https:/, "http:"));
+        return !!a && !!b && normalize(a) === normalize(b);
+    }
+    /**
+     * The tile matrix set of a tileset: matched among the tile matrix sets of the server, or otherwise fetched from the
+     * tiling-scheme link of the tileset. A tileset in a list of tilesets is a summary that need not identify its tile
+     * matrix set, then the tileset itself is read (CubeWerx).
+     */
+    static async fetchTileMatrixSetOfTileSet(capabilities, tileSet, tileMatrixSets, options) {
+        if (capabilities === null)
+            throw { error: true, message: "No capabilities" };
+        if (tileSet.tileMatrixSet)
+            return tileSet.tileMatrixSet;
+        let identified = tileSet;
+        if (!tileSet.tileMatrixSetURI && !tileSet.tileMatrixSetId && !tileSet.tilingSchemeHref) {
+            identified = { ...tileSet, ...await OgcOpenApiGetCapabilities.fetchTileSetIdentity(capabilities, tileSet.href, options) };
+            if (identified.tileMatrixSet)
+                return identified.tileMatrixSet;
+        }
+        const match = OgcOpenApiGetCapabilities.matchTileMatrixSet(identified, tileMatrixSets);
+        if (match)
+            return match;
+        if (!identified.tilingSchemeHref) {
+            throw { error: true, message: "No tile matrix set for " + (identified.tileMatrixSetURI || identified.href) };
+        }
+        return OgcOpenApiGetCapabilities.fetchTileset(capabilities, { id: identified.tileMatrixSetId, title: "", links: [{ rel: "self", type: "application/json", title: "", href: identified.tilingSchemeHref }] }, options);
+    }
+    // What identifies the tile matrix set in a tileset: its URI, its id or its tiling-scheme link
+    static async fetchTileSetIdentity(capabilities, href, options) {
+        const data = await OgcOpenApiGetCapabilities.fetchJson(capabilities, href, options);
+        return {
+            tileMatrixSetURI: data.tileMatrixSetURI,
+            tileMatrixSetId: data.tileMatrixSetId,
+            tilingSchemeHref: OgcOpenApiGetCapabilities.getTilingSchemeHref(capabilities, data.links ? data.links : [], href),
+            tileMatrixSet: OgcOpenApiGetCapabilities.getInlineTileMatrixSet(data),
+        };
+    }
+    // A tileset can include the definition of its tile matrix set instead of linking it
+    static getInlineTileMatrixSet(tileSet) {
+        const tileMatrixSet = tileSet ? tileSet.tileMatrixSet : undefined;
+        return tileMatrixSet && typeof tileMatrixSet.id !== "undefined" && Array.isArray(tileMatrixSet.tileMatrices) && tileMatrixSet.crs ?
+            tileMatrixSet : undefined;
+    }
+    /**
+     * Fetches the tileset of a collection for one tile matrix set: the tile URL templates (rel item) and, for vector
+     * tiles, the layers contained in each tile.
+     */
+    static async fetchCollectionTileSet(capabilities, 
+    // null for a tileset of the dataset
+    currentCollection, 
+    // The id of the tile matrix set, or a tileset from fetchCollectionTileSets or fetchDatasetTileSets
+    tileMatrix, options, linkType = CollectionLinkType.Tiles) {
+        if (capabilities === null)
+            throw { error: true, message: "No capabilities" };
+        const tileSetsHref = currentCollection ?
+            OgcOpenApiGetCapabilities.getTileSetsHref(currentCollection, linkType) :
+            OgcOpenApiGetCapabilities.getDatasetTileSetsHref(capabilities, linkType);
+        const tileInfoUrl = typeof tileMatrix === "string" ? OgcOpenApiFetchTools.cleanUrl(tileSetsHref) + tileMatrix : tileMatrix.href;
+        // pygeoapi answers 500 without f=json or an Accept header
+        const data = await OgcOpenApiGetCapabilities.fetchJson(capabilities, tileInfoUrl, options);
+        const links = data.links ? data.links.filter(l => l.rel === "item" || l.rel === "items").map(a => ({ ...a, href: OgcOpenApiFetchTools.resolveUrl(a.href, tileInfoUrl, capabilities.serverOptions) })) : [];
+        if (links.length === 0)
+            throw { error: true, message: "Invalid" };
+        return {
+            dataType: data.dataType,
+            links,
+            layers: data.layers ? data.layers : [],
+            tileMatrixSetLimits: data.tileMatrixSetLimits,
+            boundingBox: data.boundingBox && Array.isArray(data.boundingBox.lowerLeft) && Array.isArray(data.boundingBox.upperRight) ? data.boundingBox : undefined,
+        };
+    }
+    /**
+     * Fetches the definition of a tile matrix set, by its JSON link as the server gives it: with the query that tells
+     * the server to answer JSON (f=json), if it has one.
+     */
+    static async fetchTileset(capabilities, tileset, options) {
+        if (capabilities === null)
+            throw { error: true, message: "No capabilities" };
+        const jsonLink = tileset.links.find(l => l.type === "application/json") || tileset.links.find(l => !l.type) || tileset.links[0];
+        if (!jsonLink)
+            throw { error: true, message: "Tile matrix set " + tileset.id + " has no link" };
+        const data = await OgcOpenApiGetCapabilities.fetchJson(capabilities, jsonLink.href, options);
+        if (typeof data.id === "undefined" || !data.tileMatrices || !data.crs)
+            throw { error: true, message: "TileSet has invalid data" };
+        return data;
+    }
+}
+//# sourceMappingURL=OgcOpenApiGetCapabilities.js.map