ogcopenapis 0.0.12 → 1.0.1

package/src/OgcOpenApiTilesModel.ts

@@ -0,0 +1,214 @@
+import {WMTSTileSetModel, type WMTSTileSetModelConstructorOptions} from "@luciad/ria/model/tileset/WMTSTileSetModel.js";
+import {WMTSRequestEncoding} from "@luciad/ria/model/tileset/WMTSRequestEncoding.js";
+import type {QuadTreeRasterTileSetStructure, TileMatrix, TileMatrixSet2DRasterTileSetStructure} from "@luciad/ria/model/tileset/RasterTileSetModel.js";
+import {RasterDataType} from "@luciad/ria/model/tileset/RasterDataType.js";
+import {RasterSamplingMode} from "@luciad/ria/model/tileset/RasterSamplingMode.js";
+import type {TileCoordinate} from "@luciad/ria/model/tileset/TileCoordinate.js";
+import type {ProxifyFunction, TileMatrixLimits, TileSetData} from "./OgcOpenApiGetCapabilities.js";
+import {type OgcOpenApiTileGrid, OgcOpenApiTileMatrixTools} from "./OgcOpenApiTileMatrixTools.js";
+import {OgcOpenApiWmtsTools} from "./OgcOpenApiWmtsTools.js";
+
+
+export interface OgcOpenApiTilesModelOptions {
+    tileMatrix: TileSetData;
+    baseURL: string;
+    collection: string;
+    dataType?: RasterDataType;
+    samplingMode?: RasterSamplingMode;
+    credentials?: boolean;
+    requestHeaders?: { [p: string]: string };
+    transparent?: boolean;
+    bgcolor?: string;
+
+    proxify?: ProxifyFunction
+}
+
+export interface OgcOpenApiTilesModelCreateOptions extends OgcOpenApiTilesModelOptions {
+    // From OgcOpenApiGetCapabilities.fetchCollectionTileSet, tiles outside these limits are not requested
+    tileMatrixSetLimits?: TileMatrixLimits[];
+    // The data extent in CRS:84, [minX, minY, maxX, maxY], such as the extent of the collection
+    extent?: number[];
+    // The media type of the tiles, image/png by default
+    format?: string;
+}
+
+// The tile structure that LuciadRIA's WMTS support derived from the tile matrix set
+interface WmtsTileStructure {
+    structure: QuadTreeRasterTileSetStructure | TileMatrixSet2DRasterTileSetStructure;
+    // The tile matrix of each level, with its OGC id and number of rows
+    tileMatrices: { id: string, matrixHeight: number }[];
+}
+
+export class OgcOpenApiTilesModel extends WMTSTileSetModel {
+    private transparent: boolean;
+    private bgcolor: string | undefined;
+    private proxy: ProxifyFunction;
+    private tileMatrixSetLimits: TileMatrixLimits[] | undefined;
+    // Not tileMatrices: WMTSTileSetModel keeps the tile matrix ids in that property
+    private ogcTileMatrices: { id: string, matrixHeight: number }[];
+    // Only for the deprecated constructor, which addresses the tiles itself with the OGC API template
+    private tileGrid: OgcOpenApiTileGrid | null;
+    private ogcTemplate: string;
+
+    /**
+     * Creates the model with LuciadRIA's WMTS support, which handles tile matrix sets that are quad-trees and
+     * tile matrix sets that are not, such as GlobalCRS84Scale.
+     */
+    static async createFromTileSet(options: OgcOpenApiTilesModelCreateOptions): Promise<OgcOpenApiTilesModel> {
+        const tileSet = options.tileMatrix;
+        // WMTS 1.0 has no other corner of origin than the top left
+        if (tileSet.tileMatrices.some(m => typeof m.cornerOfOrigin === "string" && m.cornerOfOrigin.toUpperCase() === "BOTTOMLEFT")) {
+            return new OgcOpenApiTilesModel(options);
+        }
+        const format = options.format ? options.format : "image/png";
+        const capabilities = await OgcOpenApiWmtsTools.createCapabilities({
+            layer: options.collection, tileMatrix: tileSet, template: options.baseURL, format,
+            tileMatrixSetLimits: options.tileMatrixSetLimits, extent: options.extent,
+        });
+        const wmts = WMTSTileSetModel.createFromCapabilities(capabilities, {layer: options.collection}, {format});
+        return new OgcOpenApiTilesModel(options, OgcOpenApiTilesModel.getTileStructure(wmts, tileSet));
+    }
+
+    /**
+     * @deprecated Supports quad-tree tile matrix sets only, use createFromTileSet
+     */
+    constructor(options: OgcOpenApiTilesModelCreateOptions, wmtsStructure?: WmtsTileStructure) {
+        const tileGrid = wmtsStructure ? null : OgcOpenApiTileMatrixTools.createTileGrid(options.tileMatrix);
+        const tileMatrices = wmtsStructure ? wmtsStructure.tileMatrices :
+            tileGrid.tileMatrices.map(m => ({id: m.id, matrixHeight: m.matrixHeight}));
+        const structure = wmtsStructure ? wmtsStructure.structure : {
+            reference: tileGrid.reference,
+            bounds: tileGrid.bounds,
+            levelCount: tileGrid.levelCount,
+            level0Columns: tileGrid.level0Columns,
+            level0Rows: tileGrid.level0Rows,
+            tileWidth: tileGrid.tileWidth,
+            tileHeight: tileGrid.tileHeight,
+        };
+        const template = OgcOpenApiWmtsTools.toWmtsTemplate(options.baseURL);
+        const o: WMTSTileSetModelConstructorOptions = {
+            baseURL: template,
+            url: template,
+            layer: options.collection,
+            tileMatrixSet: options.tileMatrix.id,
+            tileMatrices: tileMatrices.map(m => m.id),
+            format: options.format ? options.format : "image/png",
+            requestEncoding: WMTSRequestEncoding.REST,
+            structure,
+            // Tiles can be missing inside the limits, do not stop refining at them
+            isSparseTileSet: !!options.tileMatrixSetLimits,
+            dataType: options.dataType,
+            samplingMode: options.samplingMode,
+            credentials: options.credentials,
+            requestHeaders: options.requestHeaders ? options.requestHeaders : {},
+        }
+        super(o);
+        this.tileGrid = tileGrid;
+        this.ogcTemplate = options.baseURL;
+        this.ogcTileMatrices = tileMatrices;
+        this.tileMatrixSetLimits = options.tileMatrixSetLimits;
+        this.transparent = typeof options.transparent !== "undefined" ? options.transparent : true;
+        this.bgcolor = options.bgcolor;
+
+        this.proxy = options.proxify;
+
+        this.modelDescriptor = {
+            source: options.baseURL,
+            name: options.collection,
+            description: "OGC Open API Tiles",
+            type: this.dataType
+        };
+    }
+
+    getTileURL(baseURL: string, tile: TileCoordinate): string | null {
+        //  return this.debugAsImage(tile)
+        if (!this.hasData(tile)) return null;
+        const targetUrl = this.tileGrid ?
+            OgcOpenApiTileMatrixTools.resolveTileTemplate(this.ogcTemplate, this.tileGrid, tile) :
+            super.getTileURL(baseURL, tile);
+        if (targetUrl === null) return null;
+        let tileUrl = OgcOpenApiTileMatrixTools.appendQueryParameters(targetUrl, {
+            transparent: this.transparent,
+            bgcolor: this.transparent ? undefined : this.bgcolor
+        });
+        if (typeof this.proxy === "function") {
+            const proxyfied = this.proxy(tileUrl, {});
+            tileUrl = proxyfied.url;
+        }
+        return tileUrl
+    }
+
+    // Whether the tile is inside the tileMatrixSetLimits, all tiles are when there are no limits
+    private hasData(tile: TileCoordinate) {
+        if (!this.tileMatrixSetLimits) return true;
+        const tileMatrix = this.ogcTileMatrices[tile.level];
+        if (!tileMatrix) return false;
+        const limits = this.tileMatrixSetLimits.find(l => l.tileMatrix === tileMatrix.id);
+        const tileRow = tileMatrix.matrixHeight - 1 - tile.y;
+        return !!limits &&
+            tileRow >= limits.minTileRow && tileRow <= limits.maxTileRow &&
+            tile.x >= limits.minTileCol && tile.x <= limits.maxTileCol;
+    }
+
+    // Reads the levels of the model that LuciadRIA's WMTS support created, as a quad-tree structure when they are one
+    private static getTileStructure(wmts: WMTSTileSetModel, tileSet: TileSetData): WmtsTileStructure {
+        const levels: TileMatrix[] = [];
+        for (let level = 0; level < wmts.levelCount; level++) {
+            levels.push({
+                bounds: wmts.getBounds(level),
+                tileColumnCount: wmts.getTileColumnCount(level),
+                tileRowCount: wmts.getTileRowCount(level),
+                tileWidth: wmts.getTileWidth(level),
+                tileHeight: wmts.getTileHeight(level),
+            });
+        }
+        // The OGC tile matrix of each level, in order and with the same number of columns and rows
+        const tileMatrices: { id: string, matrixHeight: number }[] = [];
+        let next = 0;
+        for (const level of levels) {
+            while (next < tileSet.tileMatrices.length &&
+            (tileSet.tileMatrices[next].matrixWidth !== level.tileColumnCount || tileSet.tileMatrices[next].matrixHeight !== level.tileRowCount)) next++;
+            if (next >= tileSet.tileMatrices.length) throw new Error("The tile matrices of " + tileSet.id + " do not match the WMTS levels");
+            tileMatrices.push({id: tileSet.tileMatrices[next].id, matrixHeight: tileSet.tileMatrices[next].matrixHeight});
+            next++;
+        }
+        const first = levels[0];
+        const isQuadTree = levels.every((level, l) =>
+            level.tileColumnCount === first.tileColumnCount * Math.pow(2, l) &&
+            level.tileRowCount === first.tileRowCount * Math.pow(2, l) &&
+            level.tileWidth === first.tileWidth && level.tileHeight === first.tileHeight &&
+            level.bounds.equals(first.bounds));
+        // A quad-tree structure also works on a Canvas map, a structure per level only on a WebGL map
+        const structure = isQuadTree ? {
+            reference: wmts.reference,
+            bounds: first.bounds,
+            levelCount: levels.length,
+            level0Columns: first.tileColumnCount,
+            level0Rows: first.tileRowCount,
+            tileWidth: first.tileWidth,
+            tileHeight: first.tileHeight,
+        } : {
+            reference: wmts.reference,
+            bounds: first.bounds,
+            tileMatrix: levels,
+        };
+        return {structure, tileMatrices};
+    }
+
+    debugAsImage(tileCorrected: TileCoordinate) {
+        const canvas = document.createElement('canvas');
+        if (canvas) {
+            canvas.width = this.getTileWidth(tileCorrected.level) as number;
+            canvas.height = this.getTileHeight(tileCorrected.level) as number;
+            const ctx = canvas.getContext("2d");
+            if (ctx) {
+                ctx.font = "30px Arial";
+                ctx.fillText(`x:${tileCorrected.x}, y:${tileCorrected.y}, z:${tileCorrected.level}`, 10, canvas.height/2);
+            }
+            const dataURL = canvas.toDataURL();
+            return dataURL;
+        }
+        return null;
+    }
+
+}

package/src/OgcOpenApiVectorTilesModel.ts

@@ -0,0 +1,141 @@
+import {MapboxVectorTileSetModel} from "@luciad/ria/model/tileset/mapbox/MapboxVectorTileSetModel.js";
+import type {TileCoordinate} from "@luciad/ria/model/tileset/TileCoordinate.js";
+import {Bounds} from "@luciad/ria/shape/Bounds.js";
+import {getReference} from "@luciad/ria/reference/ReferenceProvider.js";
+import {createPoint} from "@luciad/ria/shape/ShapeFactory.js";
+import {createTransformation} from "@luciad/ria/transformation/TransformationFactory.js";
+import type {ProxifyFunction, TileMatrixLimits, TileSetData, TileSetLayer} from "./OgcOpenApiGetCapabilities.js";
+import {OgcOpenApiMvtTools} from "./OgcOpenApiMvtTools.js";
+import {type FetchServerOptions, OgcOpenApiFetchTools} from "./OgcOpenApiFetchTools.js";
+import {type OgcOpenApiTileGrid, OgcOpenApiTileMatrixTools} from "./OgcOpenApiTileMatrixTools.js";
+
+export interface OgcOpenApiVectorTilesModelOptions {
+    tileMatrix: TileSetData;
+    baseURL: string;
+    collection: string;
+    credentials?: boolean;
+    requestHeaders?: { [p: string]: string };
+    // From OgcOpenApiGetCapabilities.fetchCollectionTileSet, tiles outside these limits are not requested
+    tileMatrixSetLimits?: TileMatrixLimits[];
+    // The data extent, defaults to the extent of the tile matrix set
+    bounds?: Bounds;
+    styleUrl?: string;
+
+    proxify?: ProxifyFunction
+}
+
+export class OgcOpenApiVectorTilesModel extends MapboxVectorTileSetModel {
+    private tileGrid: OgcOpenApiTileGrid;
+    private tileTemplate: string;
+    private serverOptions: FetchServerOptions;
+    private tileMatrixSetLimits: TileMatrixLimits[] | undefined;
+
+    constructor(options: OgcOpenApiVectorTilesModelOptions) {
+        const tileGrid = OgcOpenApiTileMatrixTools.createTileGrid(options.tileMatrix);
+        const maxLevel = OgcOpenApiVectorTilesModel.getMaxLevel(tileGrid, options.tileMatrixSetLimits);
+        super({
+            baseURL: options.baseURL,
+            structure: {
+                reference: tileGrid.reference,
+                bounds: tileGrid.bounds,
+                level0Columns: tileGrid.level0Columns,
+                level0Rows: tileGrid.level0Rows,
+            },
+            // LuciadRIA 2026.1.1 paints nothing when minLevel > 0, levels without data are skipped in getVectorTile
+            minLevel: 0,
+            maxLevel,
+            bounds: options.bounds,
+            name: options.collection,
+            styleUrl: options.styleUrl ? options.styleUrl : null,
+            credentials: options.credentials,
+            requestHeaders: options.requestHeaders ? options.requestHeaders : {},
+        });
+        this.tileGrid = tileGrid;
+        this.tileTemplate = options.baseURL;
+        this.serverOptions = OgcOpenApiFetchTools.createFetchOptions({originalUrl: options.baseURL, proxify: options.proxify});
+        this.tileMatrixSetLimits = options.tileMatrixSetLimits;
+    }
+
+    getVectorTile(tile: TileCoordinate, signal?: AbortSignal): Promise<ArrayBuffer | null> {
+        if (!this.hasData(tile)) return Promise.resolve(null);
+        const targetUrl = OgcOpenApiTileMatrixTools.resolveTileTemplate(this.tileTemplate, this.tileGrid, tile);
+        if (targetUrl === null) return Promise.resolve(null);
+        const tileUrl = OgcOpenApiTileMatrixTools.appendQueryParameters(targetUrl, this.requestParameters ? this.requestParameters : {});
+        return OgcOpenApiFetchTools.fetch(tileUrl, {
+            method: "GET",
+            credentials: this.credentials ? "same-origin" : "omit",
+            headers: this.requestHeaders ? this.requestHeaders : {},
+            signal
+        }, this.serverOptions).then(response => {
+            // Servers answer a tile without data with 204, 404 or an empty 200
+            if (response.status === 204 || response.status === 404) return null;
+            if (response.status !== 200) throw new Error("Invalid response: " + response.status + " for " + tileUrl);
+            return response.arrayBuffer().then(content => content.byteLength > 0 ? content : null);
+        });
+    }
+
+    /**
+     * The layers in the tiles, read from a few sample tiles. For tilesets whose metadata does not list their layers,
+     * the layer names in the tiles cannot be guessed: some servers name a layer after the collection, others not.
+     * extent, in CRS:84 as [minX, minY, maxX, maxY], is where the data is, such as the extent of the collection.
+     * Resolves the layers of the first sample tile that has any, or an empty array.
+     */
+    async discoverLayers(options: { extent?: number[], maxRequests?: number } = {}): Promise<TileSetLayer[]> {
+        const maxRequests = typeof options.maxRequests === "number" ? options.maxRequests : 6;
+        for (const tile of this.getSampleTiles(options.extent).slice(0, maxRequests)) {
+            const content = await this.getVectorTile(tile).catch(() => null);
+            if (!content) continue;
+            const layers = await OgcOpenApiMvtTools.getLayers(content).catch(() => []);
+            if (layers.length > 0) return layers;
+        }
+        return [];
+    }
+
+    // Tiles likely to have data: the middle tile of the limits per level, or the tile at the center of the extent
+    private getSampleTiles(extent?: number[]): TileCoordinate[] {
+        if (this.tileMatrixSetLimits) {
+            return this.tileMatrixSetLimits
+                .map(l => OgcOpenApiTileMatrixTools.getLuciadTile(this.tileGrid, l.tileMatrix,
+                    Math.floor((l.minTileRow + l.maxTileRow) / 2), Math.floor((l.minTileCol + l.maxTileCol) / 2)))
+                .filter(tile => tile !== null)
+                .sort((a, b) => a.level - b.level);
+        }
+        if (!extent || extent.length < 4) {
+            const tiles: TileCoordinate[] = [];
+            for (let x = 0; x < this.tileGrid.level0Columns; x++) {
+                for (let y = 0; y < this.tileGrid.level0Rows; y++) tiles.push({level: 0, x, y});
+            }
+            return tiles;
+        }
+        const crs84 = getReference("CRS:84");
+        const center = createTransformation(crs84, this.tileGrid.reference)
+            .transform(createPoint(crs84, [(extent[0] + extent[2]) / 2, (extent[1] + extent[3]) / 2]));
+        const bounds = this.tileGrid.bounds;
+        return [0, 2, 4, 6, 8, 10, 12].filter(level => level < this.tileGrid.levelCount).map(level => {
+            const columns = this.tileGrid.level0Columns * Math.pow(2, level);
+            const rows = this.tileGrid.level0Rows * Math.pow(2, level);
+            const x = Math.floor((center.x - bounds.x) / (bounds.width / columns));
+            const y = Math.floor((center.y - bounds.y) / (bounds.height / rows));
+            return {level, x: Math.min(Math.max(x, 0), columns - 1), y: Math.min(Math.max(y, 0), rows - 1)};
+        });
+    }
+
+    // Whether the tile is inside the tileMatrixSetLimits, all tiles are when there are no limits
+    private hasData(tile: TileCoordinate) {
+        if (!this.tileMatrixSetLimits) return true;
+        const ogcTile = OgcOpenApiTileMatrixTools.getOgcTile(this.tileGrid, tile);
+        if (ogcTile === null) return false;
+        const limits = this.tileMatrixSetLimits.find(l => l.tileMatrix === ogcTile.tileMatrix);
+        return !!limits &&
+            ogcTile.tileRow >= limits.minTileRow && ogcTile.tileRow <= limits.maxTileRow &&
+            ogcTile.tileCol >= limits.minTileCol && ogcTile.tileCol <= limits.maxTileCol;
+    }
+
+    // The deepest level in the tileMatrixSetLimits, LuciadRIA over-zooms beyond it
+    private static getMaxLevel(tileGrid: OgcOpenApiTileGrid, tileMatrixSetLimits?: TileMatrixLimits[]) {
+        const levels = tileMatrixSetLimits ?
+            tileMatrixSetLimits.map(l => tileGrid.tileMatrices.findIndex(m => m.id === l.tileMatrix)).filter(level => level > -1) :
+            [];
+        return levels.length === 0 ? tileGrid.levelCount - 1 : Math.max(...levels);
+    }
+}

package/src/OgcOpenApiWmtsTools.ts

@@ -0,0 +1,114 @@
+import {WMTSCapabilities} from "@luciad/ria/model/capabilities/WMTSCapabilities.js";
+import {WMTSRequestEncoding} from "@luciad/ria/model/tileset/WMTSRequestEncoding.js";
+import {CoordinateType} from "@luciad/ria/reference/CoordinateType.js";
+import {getReference} from "@luciad/ria/reference/ReferenceProvider.js";
+import {OgcOpenApiCrsTools} from "./OgcOpenApiCrsTools.js";
+import type {TileMatrixLimits, TileSetData} from "./OgcOpenApiGetCapabilities.js";
+
+/**
+ * Describes an OGC API tileset as a WMTS 1.0 layer, so that LuciadRIA's WMTS support reads its tile matrix set:
+ * quad-trees and tile matrix sets that are not quad-trees, with their tile matrix limits.
+ */
+export interface OgcOpenApiWmtsLayer {
+    layer: string;
+    tileMatrix: TileSetData;
+    // The OGC API tile URL template, with {tileMatrix}, {tileRow} and {tileCol}
+    template: string;
+    format: string;
+    tileMatrixSetLimits?: TileMatrixLimits[];
+    // The data extent in CRS:84, [minX, minY, maxX, maxY]
+    extent?: number[];
+}
+
+// Meters per degree at the equator, to derive a scale denominator from the cell size of a geographic tile matrix set
+const METERS_PER_DEGREE = 2 * Math.PI * 6378137 / 360;
+// The standardized rendering pixel size of WMTS, 0.28 mm
+const PIXEL_SIZE = 0.00028;
+
+class OgcOpenApiWmtsTools {
+
+    /**
+     * WMTS uses {TileMatrix}, {TileRow} and {TileCol} where OGC API Tiles uses {tileMatrix}, {tileRow} and {tileCol}
+     */
+    public static toWmtsTemplate(template: string) {
+        return template.replace("{tileMatrix}", "{TileMatrix}").replace("{tileRow}", "{TileRow}").replace("{tileCol}", "{TileCol}");
+    }
+
+    // http://www.opengis.net/def/crs/EPSG/0/3857 becomes urn:ogc:def:crs:EPSG::3857
+    public static toCrsUrn(crs: string) {
+        const match = /^https?:\/\/www\.opengis\.net\/def\/crs\/([^/]+)\/([^/]+)\/([^/]+)$/.exec(crs.replace(/[<>]/g, "").trim());
+        if (!match) return crs;
+        const [, authority, version, code] = match;
+        return "urn:ogc:def:crs:" + authority + ":" + (version === "0" ? "" : version) + ":" + code;
+    }
+
+    public static toCapabilitiesXml(description: OgcOpenApiWmtsLayer): string {
+        const tileSet = description.tileMatrix;
+        const isGeographic = getReference(OgcOpenApiCrsTools.getReferenceName(tileSet.crs)).coordinateType === CoordinateType.GEODETIC;
+        const matrices = tileSet.tileMatrices.map(m => {
+            const scaleDenominator = typeof m.scaleDenominator === "number" ? m.scaleDenominator :
+                m.cellSize * (isGeographic ? METERS_PER_DEGREE : 1) / PIXEL_SIZE;
+            return "<TileMatrix>" +
+                OgcOpenApiWmtsTools.element("ows:Identifier", m.id) +
+                OgcOpenApiWmtsTools.element("ScaleDenominator", scaleDenominator) +
+                // Both pointOfOrigin and TopLeftCorner are in the axis order of the CRS
+                OgcOpenApiWmtsTools.element("TopLeftCorner", m.pointOfOrigin[0] + " " + m.pointOfOrigin[1]) +
+                OgcOpenApiWmtsTools.element("TileWidth", m.tileWidth) +
+                OgcOpenApiWmtsTools.element("TileHeight", m.tileHeight) +
+                OgcOpenApiWmtsTools.element("MatrixWidth", m.matrixWidth) +
+                OgcOpenApiWmtsTools.element("MatrixHeight", m.matrixHeight) +
+                "</TileMatrix>";
+        }).join("");
+        const limits = description.tileMatrixSetLimits && description.tileMatrixSetLimits.length > 0 ?
+            "<TileMatrixSetLimits>" + description.tileMatrixSetLimits.map(l => "<TileMatrixLimits>" +
+                OgcOpenApiWmtsTools.element("TileMatrix", l.tileMatrix) +
+                OgcOpenApiWmtsTools.element("MinTileRow", l.minTileRow) +
+                OgcOpenApiWmtsTools.element("MaxTileRow", l.maxTileRow) +
+                OgcOpenApiWmtsTools.element("MinTileCol", l.minTileCol) +
+                OgcOpenApiWmtsTools.element("MaxTileCol", l.maxTileCol) +
+                "</TileMatrixLimits>").join("") + "</TileMatrixSetLimits>" : "";
+        const extent = description.extent && description.extent.length >= 4 ?
+            "<ows:WGS84BoundingBox>" +
+            OgcOpenApiWmtsTools.element("ows:LowerCorner", description.extent[0] + " " + description.extent[1]) +
+            OgcOpenApiWmtsTools.element("ows:UpperCorner", description.extent[2] + " " + description.extent[3]) +
+            "</ows:WGS84BoundingBox>" : "";
+        return '<?xml version="1.0" encoding="UTF-8"?>' +
+            '<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.opengis.net/ows/1.1" version="1.0.0">' +
+            "<ows:ServiceIdentification><ows:Title>OGC API Tiles</ows:Title><ows:ServiceType>OGC WMTS</ows:ServiceType>" +
+            "<ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion></ows:ServiceIdentification>" +
+            "<Contents><Layer>" +
+            OgcOpenApiWmtsTools.element("ows:Title", description.layer) +
+            OgcOpenApiWmtsTools.element("ows:Identifier", description.layer) +
+            extent +
+            '<Style isDefault="true"><ows:Identifier>default</ows:Identifier></Style>' +
+            OgcOpenApiWmtsTools.element("Format", description.format) +
+            "<TileMatrixSetLink>" + OgcOpenApiWmtsTools.element("TileMatrixSet", tileSet.id) + limits + "</TileMatrixSetLink>" +
+            '<ResourceURL format="' + OgcOpenApiWmtsTools.escape(description.format) + '" resourceType="tile" template="' +
+            OgcOpenApiWmtsTools.escape(OgcOpenApiWmtsTools.toWmtsTemplate(description.template)) + '"/>' +
+            "</Layer><TileMatrixSet>" +
+            OgcOpenApiWmtsTools.element("ows:Identifier", tileSet.id) +
+            OgcOpenApiWmtsTools.element("ows:SupportedCRS", OgcOpenApiWmtsTools.toCrsUrn(tileSet.crs)) +
+            matrices +
+            "</TileMatrixSet></Contents></Capabilities>";
+    }
+
+    /**
+     * LuciadRIA's WMTSCapabilities for the tileset. The document is passed as a data URL, so it is not requested.
+     */
+    public static createCapabilities(description: OgcOpenApiWmtsLayer): Promise<WMTSCapabilities> {
+        const url = "data:application/xml;charset=utf-8," + encodeURIComponent(OgcOpenApiWmtsTools.toCapabilitiesXml(description));
+        return WMTSCapabilities.fromURL(url, {preferredRequestEncoding: WMTSRequestEncoding.REST});
+    }
+
+    private static element(name: string, value: string | number) {
+        return "<" + name + ">" + OgcOpenApiWmtsTools.escape(String(value)) + "</" + name + ">";
+    }
+
+    private static escape(value: string) {
+        return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    }
+}
+
+export {
+    OgcOpenApiWmtsTools
+}

package/lib/OgcOpenApiGetCollectionTiles.d.ts

@@ -1,7 +0,0 @@
-import { OgcOpenApiCapabilitiesCollection, OgcOpenApiCapabilitiesObject } from "./OgcOpenApiGetCapabilities";
-declare class OgcOpenApiGetCollectionTiles {
-    private collection;
-    private capabilities;
-    constructor(collection: OgcOpenApiCapabilitiesCollection, capabilities: OgcOpenApiCapabilitiesObject);
-}
-export { OgcOpenApiGetCollectionTiles };

package/lib/OgcOpenApiGetCollectionTiles.js

@@ -1,7 +0,0 @@
-class OgcOpenApiGetCollectionTiles {
-    constructor(collection, capabilities) {
-        this.collection = collection;
-        this.capabilities = capabilities;
-    }
-}
-export { OgcOpenApiGetCollectionTiles };