@basemaps/lambda-tiler 6.15.0

package/src/tile.set.cache.ts

@@ -0,0 +1,107 @@
+import { TileSetNameParser } from '@basemaps/config';
+import { TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { Config } from '@basemaps/shared';
+import { TileSet } from './tile.set.js';
+import { TileSetRaster } from './tile.set.raster.js';
+import { TileSetVector } from './tile.set.vector.js';
+
+export class TileSetCache {
+  /** Duration to cache tile sets for */
+  CacheTime = 30_000;
+
+  /** Cache the fetch requests */
+  cache: Map<string, { time: number; value: Promise<TileSet | null> }> = new Map();
+  /** Cache initialized tile sets */
+  tileSets: Map<string, TileSet> = new Map();
+
+  id(tileSet: TileSet): string;
+  id(name: string, tileMatrix: TileMatrixSet): string;
+  id(name: string | TileSet, tileMatrix?: TileMatrixSet): string {
+    if (typeof name === 'string') {
+      const nameComp = TileSetNameParser.parse(name);
+      return `${TileSetNameParser.componentsToName(nameComp)}_${tileMatrix?.identifier}`;
+    }
+
+    return `${name.fullName}_${name.tileMatrix.identifier}`;
+  }
+
+  add(tileSet: TileSet, expiresAt = Date.now() + this.CacheTime): void {
+    const id = this.id(tileSet);
+    if (this.cache.has(id)) throw new Error('Trying to add duplicate tile set:' + id);
+    this.cache.set(id, { time: expiresAt, value: Promise.resolve(tileSet) });
+  }
+
+  get(name: string, tileMatrix: TileMatrixSet): Promise<TileSet | null> {
+    const tsId = this.id(name, tileMatrix);
+    let existing = this.cache.get(tsId);
+    // Validate the data is current every ~30 seconds
+    if (existing == null || Date.now() - existing.time > 0) {
+      const value = this.loadTileSet(name, tileMatrix);
+      existing = { time: Date.now(), value };
+      this.cache.set(tsId, existing);
+    }
+    return existing.value;
+  }
+
+  async loadTileSet(name: string, tileMatrix: TileMatrixSet): Promise<TileSet | null> {
+    const nameComp = TileSetNameParser.parse(name);
+    const tileSetId = this.id(name, tileMatrix);
+
+    if (nameComp.layer != null) {
+      const parentName = TileSetNameParser.componentsToName({ ...nameComp, layer: undefined });
+      const parent = await this.get(parentName, tileMatrix);
+      if (parent == null || parent.isVector()) return null;
+      return parent.child(nameComp.layer);
+    }
+
+    const dbId = Config.TileSet.id(name);
+    const tileSet = await Config.TileSet.get(dbId);
+    if (tileSet == null) {
+      this.cache.delete(tileSetId);
+      return null;
+    }
+
+    // If we already have a copy and it hasn't been modified just return it
+    const existing = this.tileSets.get(tileSetId);
+    if (existing?.tileSet.updatedAt === tileSet.updatedAt) {
+      return existing;
+    }
+
+    if (Config.isTileSetRaster(tileSet)) {
+      const ts = new TileSetRaster(name, tileMatrix);
+      await ts.init(tileSet);
+      this.tileSets.set(tileSetId, ts);
+      return ts;
+    }
+
+    const ts = new TileSetVector(name, tileMatrix);
+    ts.tileSet = tileSet;
+    this.tileSets.set(tileSetId, ts);
+    return ts;
+  }
+
+  async getAll(name: string, tileMatrix?: TileMatrixSet | null): Promise<TileSet[]> {
+    const nameComp = TileSetNameParser.parse(name);
+    const tileMatrices = tileMatrix == null ? Array.from(TileMatrixSets.Defaults.values()) : [tileMatrix];
+
+    const promises: Promise<TileSet | null>[] = [];
+    for (const tileMatrix of tileMatrices) promises.push(this.get(name, tileMatrix));
+    const tileMatrixSets = await Promise.all(promises);
+
+    const tileSets: TileSetRaster[] = [];
+    for (const parent of tileMatrixSets) {
+      if (parent == null) continue;
+      if (parent.isVector()) continue;
+
+      tileSets.push(parent);
+      if (nameComp.layer != null) {
+        parent.components.name = nameComp.name;
+      } else if (parent.imagery != null && parent.imagery.size > 1) {
+        for (const imageId of parent.imagery.keys()) tileSets.push(parent.child(imageId));
+      }
+    }
+    return tileSets.sort((a, b) => a.title.localeCompare(b.title));
+  }
+}
+
+export const TileSets = new TileSetCache();

package/src/tile.set.raster.ts

@@ -0,0 +1,209 @@
+import { ConfigImagery, ConfigLayer, ConfigTileSetRaster, TileSetNameParser, TileSetType } from '@basemaps/config';
+import { Bounds, Epsg, Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { Config, Env, fsa, LogType, TileDataXyz, titleizeImageryName, VectorFormat } from '@basemaps/shared';
+import { Tiler } from '@basemaps/tiler';
+import { CogTiff } from '@cogeotiff/core';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { Metrics } from '@linzjs/metrics';
+import pLimit from 'p-limit';
+import { TileEtag } from './routes/tile.etag.js';
+import { NotFound, NotModified, TileComposer } from './routes/tile.js';
+import { TiffCache } from './tiff.cache.js';
+import { TileSetHandler } from './tile.set.js';
+
+const LoadingQueue = pLimit(Env.getNumber(Env.TiffConcurrency, 5));
+
+export interface TileSetResponse {
+  buffer: Buffer;
+  metrics: Metrics;
+  layersUsed: number;
+  layersTotal: number;
+  contentType: string;
+}
+
+const DefaultResizeKernel = { in: 'lanczos3', out: 'lanczos3' } as const;
+const DefaultBackground = { r: 0, g: 0, b: 0, alpha: 0 };
+
+export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
+  type = TileSetType.Raster;
+
+  tileMatrix: TileMatrixSet;
+  tiler: Tiler;
+  imagery: Map<string, ConfigImagery>;
+  extentOverride: Bounds;
+
+  /**
+   * Return the location of a imagery `record`
+   * @param record
+   * @param name the COG to locate. Return just the directory if `null`
+   */
+  static basePath(record: ConfigImagery, name?: string): string {
+    if (name == null) return record.uri;
+    if (record.uri.endsWith('/')) throw new Error("Invalid uri ending with '/' " + record.uri);
+    return `${record.uri}/${name}.tiff`;
+  }
+
+  constructor(name: string, tileMatrix: TileMatrixSet) {
+    super(name, tileMatrix);
+    this.tiler = new Tiler(this.tileMatrix);
+  }
+
+  get title(): string {
+    return this.tileSet?.title ?? this.components.name;
+  }
+
+  get description(): string {
+    return this.tileSet?.description ?? '';
+  }
+
+  get extent(): Bounds {
+    return this.extentOverride ?? this.tileMatrix.extent;
+  }
+
+  async init(record: ConfigTileSetRaster): Promise<void> {
+    this.tileSet = record;
+    this.imagery = await Config.getAllImagery(this.tileSet.layers, this.tileMatrix.projection);
+  }
+
+  async initTiffs(tile: Tile, log: LogType): Promise<CogTiff[]> {
+    const tiffs = this.getTiffsForTile(tile, log);
+    let failed = false;
+    // Remove any tiffs that failed to load
+    const promises = tiffs.map((c) => {
+      return LoadingQueue(async () => {
+        try {
+          await c.init();
+        } catch (error) {
+          log.warn({ error, tiff: c.source.uri }, 'TiffLoadFailed');
+          failed = true;
+        }
+      });
+    });
+    await Promise.all(promises);
+    if (failed) return tiffs.filter((f) => f.images.length > 0);
+    return tiffs;
+  }
+
+  public async tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse> {
+    if (xyz.ext === VectorFormat.MapboxVectorTiles) return NotFound;
+    const tiffs = await this.initTiffs(xyz, req.log);
+    const layers = await this.tiler.tile(tiffs, xyz.x, xyz.y, xyz.z);
+
+    // Generate a unique hash given the full URI, the layers used and a renderId
+    const cacheKey = TileEtag.generate(layers, xyz);
+    req.set('layers', layers.length);
+    if (TileEtag.isNotModified(req, cacheKey)) return NotModified;
+
+    req.timer.start('tile:compose');
+    const res = await TileComposer.compose({
+      layers,
+      format: xyz.ext,
+      background: this.tileSet.background ?? DefaultBackground,
+      resizeKernel: this.tileSet.resizeKernel ?? DefaultResizeKernel,
+    });
+    req.timer.end('tile:compose');
+
+    req.set('layersUsed', res.layers);
+    req.set('allLayersUsed', res.layers === layers.length);
+    req.set('bytes', res.buffer.byteLength);
+
+    const response = new LambdaHttpResponse(200, 'ok');
+    response.header(HttpHeader.ETag, cacheKey);
+    response.header(HttpHeader.CacheControl, 'public, max-age=604800');
+    response.buffer(res.buffer, 'image/' + xyz.ext);
+    return response;
+  }
+
+  /**
+   * Get a list of tiffs in the rendering order that is needed to render the tile
+   * @param tms tile matrix set to describe the tiling scheme
+   * @param tile tile to render
+   */
+  public getTiffsForTile(tile: Tile, log?: LogType): CogTiff[] {
+    const output: CogTiff[] = [];
+    const tileBounds = this.tileMatrix.tileToSourceBounds(tile);
+
+    // All zoom level config is stored as Google zoom levels
+    const filterZoom = TileMatrixSet.convertZoomLevel(tile.z, this.tileMatrix, TileMatrixSets.get(Epsg.Google));
+    for (const layer of this.tileSet.layers) {
+      if (layer.maxZoom != null && filterZoom > layer.maxZoom) continue;
+      if (layer.minZoom != null && filterZoom < layer.minZoom) continue;
+
+      const imgId = Config.getImageId(layer, this.tileMatrix.projection);
+      if (imgId == null) {
+        log?.warn({ layer: layer.name, projection: this.tileMatrix.projection.code }, 'Failed to lookup imagery');
+        continue;
+      }
+
+      const imagery = this.imagery.get(imgId);
+      if (imagery == null) {
+        console.log('Failed', { imagery, i: this.imagery, ts: this.tileSet.layers });
+        log?.warn(
+          { layer: layer.name, projection: this.tileMatrix.projection.code, imgId },
+          'Failed to lookup imagery',
+        );
+        continue;
+      }
+      if (!tileBounds.intersects(Bounds.fromJson(imagery.bounds))) continue;
+
+      for (const tiff of this.getCogsForTile(imagery, tileBounds)) output.push(tiff);
+    }
+    return output;
+  }
+
+  private getCogsForTile(record: ConfigImagery, tileBounds: Bounds): CogTiff[] {
+    const output: CogTiff[] = [];
+    for (const c of record.files) {
+      if (!tileBounds.intersects(Bounds.fromJson(c))) continue;
+
+      const tiffKey = `${record.id}_${c.name}`;
+      let existing = TiffCache.get(tiffKey);
+      if (existing == null) {
+        const source = fsa.source(TileSetRaster.basePath(record, c.name));
+        if (source == null) {
+          throw new Error(`Failed to create CogSource from  ${TileSetRaster.basePath(record, c.name)}`);
+        }
+        existing = new CogTiff(source);
+        TiffCache.set(tiffKey, existing);
+      }
+
+      output.push(existing);
+    }
+
+    return output;
+  }
+
+  /** Look up imagery by imageryId or by image name */
+  findImagery(imgId: string): ConfigImagery | null {
+    const existing = this.imagery.get(imgId);
+    if (existing != null) return existing;
+    for (const img of this.imagery.values()) {
+      if (img.name === imgId) return img;
+    }
+    return null;
+  }
+
+  child(imgId: string): TileSetRaster {
+    const image = this.findImagery(imgId);
+    if (image == null) {
+      throw new Error('Failed to create child tile set ' + this.fullName + ' Missing imagery ' + imgId);
+    }
+    const childName = TileSetNameParser.componentsToName({ ...this.components, layer: image.name });
+    const child = new TileSetRaster(childName, this.tileMatrix);
+    // use parent data as prototype for child;
+    child.tileSet = { ...this.tileSet };
+    child.tileSet.background = undefined;
+    const title = this.tileSet?.title ?? this.tileSet?.name;
+    child.tileSet.title = `${title} ${titleizeImageryName(image.name)}`;
+    child.extentOverride = Bounds.fromJson(image.bounds);
+
+    const layer: ConfigLayer = { name: image.name, minZoom: 0, maxZoom: 100 };
+    layer[this.tileMatrix.projection.code] = image.id;
+
+    child.tileSet.layers = [layer];
+    child.imagery = new Map();
+    child.imagery.set(image.id, image);
+
+    return child;
+  }
+}

package/src/tile.set.ts

@@ -0,0 +1,44 @@
+import {
+  ConfigTileSetRaster,
+  ConfigTileSetVector,
+  TileSetNameComponents,
+  TileSetNameParser,
+  TileSetType,
+} from '@basemaps/config';
+import { TileMatrixSet } from '@basemaps/geo';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { TileDataXyz } from '@basemaps/shared';
+import { TileSets } from './tile.set.cache.js';
+import { TileSetRaster } from './tile.set.raster.js';
+import { TileSetVector } from './tile.set.vector.js';
+
+export type TileSet = TileSetVector | TileSetRaster;
+
+export abstract class TileSetHandler<T extends ConfigTileSetRaster | ConfigTileSetVector> {
+  type: TileSetType;
+  components: TileSetNameComponents;
+  tileMatrix: TileMatrixSet;
+  tileSet: T;
+  constructor(name: string, tileMatrix: TileMatrixSet) {
+    this.components = TileSetNameParser.parse(name);
+    this.tileMatrix = tileMatrix;
+  }
+
+  get id(): string {
+    return TileSets.id(this.fullName, this.tileMatrix);
+  }
+
+  get fullName(): string {
+    return TileSetNameParser.componentsToName(this.components);
+  }
+
+  isVector(): this is TileSetVector {
+    return this.type === TileSetType.Vector;
+  }
+
+  isRaster(): this is TileSetRaster {
+    return this.type === TileSetType.Raster;
+  }
+
+  abstract tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse>;
+}

package/src/tile.set.vector.ts

@@ -0,0 +1,50 @@
+import { ConfigTileSetVector, TileSetType } from '@basemaps/config';
+import { fsa, TileDataXyz, VectorFormat } from '@basemaps/shared';
+import { Cotar } from '@cotar/core';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { NotFound } from './routes/tile.js';
+import { TileSetHandler } from './tile.set.js';
+
+class CotarCache {
+  cache = new Map<string, Promise<Cotar | null>>();
+
+  get(uri: string): Promise<Cotar | null> {
+    let cotar = this.cache.get(uri);
+    if (cotar == null) {
+      cotar = Cotar.fromTar(fsa.source(uri));
+      this.cache.set(uri, cotar);
+    }
+    return cotar;
+  }
+}
+
+export const Layers = new CotarCache();
+
+export class TileSetVector extends TileSetHandler<ConfigTileSetVector> {
+  type = TileSetType.Vector;
+
+  async tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse> {
+    if (xyz.ext !== VectorFormat.MapboxVectorTiles) return NotFound;
+    if (this.tileSet.layers.length > 1) return new LambdaHttpResponse(500, 'Too many layers in tileset');
+    const [layer] = this.tileSet.layers;
+    if (layer[3857] == null) return new LambdaHttpResponse(500, 'Layer url not found from tileset Config');
+
+    req.timer.start('cotar:load');
+    const cotar = await Layers.get(layer[3857]);
+    if (cotar == null) return new LambdaHttpResponse(500, 'Failed to load VectorTiles');
+    req.timer.end('cotar:load');
+
+    // Flip Y coordinate because MBTiles files are TMS.
+    const y = (1 << xyz.z) - 1 - xyz.y;
+
+    req.timer.start('cotar:tile');
+    const tile = await cotar.get(`tiles/${xyz.z}/${xyz.x}/${y}.pbf.gz`, req.log);
+    if (tile == null) return NotFound;
+    req.timer.end('cotar:tile');
+
+    const response = new LambdaHttpResponse(200, 'Ok');
+    response.buffer(Buffer.from(tile), 'application/x-protobuf');
+    response.header(HttpHeader.ContentEncoding, 'gzip');
+    return response;
+  }
+}

package/src/validate.ts

@@ -0,0 +1,32 @@
+import { Projection, TileDataXyz } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
+export const ValidateTilePath = {
+  /**
+   * Validate that the tile request is somewhat valid
+   * - Valid projection
+   * - Valid range
+   *
+   * @throws LambdaHttpResponse for tile requests that are not valid
+   *
+   * @param req request to validate
+   * @param xyzData
+   */
+  validate(req: LambdaHttpRequest, xyzData: TileDataXyz): void {
+    const { tileMatrix, x, y, z, ext } = xyzData;
+    req.set('xyz', { x, y, z });
+    req.set('projection', tileMatrix.projection.code);
+    req.set('tileMatrix', tileMatrix.identifier);
+    req.set('extension', ext);
+    req.set('tileSet', xyzData.name);
+
+    if (z > tileMatrix.maxZoom || z < 0) throw new LambdaHttpResponse(404, `Zoom not found: ${z}`);
+
+    const zoom = tileMatrix.zooms[z];
+    if (x < 0 || x > zoom.matrixWidth) throw new LambdaHttpResponse(404, `X not found: ${x}`);
+    if (y < 0 || y > zoom.matrixHeight) throw new LambdaHttpResponse(404, `Y not found: ${y}`);
+
+    const latLon = Projection.tileCenterToLatLon(tileMatrix, xyzData);
+    req.set('location', latLon);
+  },
+};

package/src/wmts.capability.ts

@@ -0,0 +1,203 @@
+import { ConfigProvider } from '@basemaps/config';
+import { Bounds, Nztm2000QuadTms, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
+import { Projection, V, VNodeElement } from '@basemaps/shared';
+import { ImageFormatOrder } from '@basemaps/tiler';
+import { BBox, Wgs84 } from '@linzjs/geojson';
+import { TileSetRaster } from './tile.set.raster.js';
+
+const CapabilitiesAttrs = {
+  xmlns: 'http://www.opengis.net/wmts/1.0',
+  'xmlns:ows': 'http://www.opengis.net/ows/1.1',
+  'xmlns:xlink': 'http://www.w3.org/1999/xlink',
+  'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+  'xmlns:gml': 'http://www.opengis.net/gml',
+  'xsi:schemaLocation':
+    'http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd',
+  version: '1.0.0',
+};
+
+function wgs84Extent(layer: TileSetRaster): BBox {
+  return Projection.get(layer.tileMatrix).boundsToWgs84BoundingBox(layer.extent);
+}
+
+/**
+ * Default the tile matrix id to the projection of the TileMatrixSet
+ */
+function getTileMatrixId(tileMatrix: TileMatrixSet): string {
+  // TODO this should really change everything to identifier
+  if (tileMatrix.identifier === Nztm2000QuadTms.identifier) return Nztm2000QuadTms.identifier;
+  return tileMatrix.projection.toEpsgString();
+}
+
+export class WmtsCapabilities {
+  httpBase: string;
+  provider: WmtsProvider;
+
+  layers: Map<string, TileSetRaster[]> = new Map();
+
+  apiKey?: string;
+  tileMatrixSets = new Map<string, TileMatrixSet>();
+
+  constructor(httpBase: string, provider: WmtsProvider, layers: TileSetRaster[], apiKey?: string) {
+    this.httpBase = httpBase;
+    this.provider = provider;
+
+    for (const layer of layers) {
+      // TODO is grouping by name the best option
+      let existing = this.layers.get(layer.fullName);
+      if (existing == null) {
+        existing = [];
+        this.layers.set(layer.fullName, existing);
+      }
+      // TODO should a error be thrown here if the projection is invalid
+      existing.push(layer);
+
+      this.tileMatrixSets.set(layer.tileMatrix.identifier, layer.tileMatrix);
+    }
+    this.apiKey = apiKey;
+  }
+
+  buildWgs84BoundingBox(layers: TileSetRaster[], tagName = 'ows:WGS84BoundingBox'): VNodeElement {
+    let bbox = wgs84Extent(layers[0]);
+    for (let i = 1; i < layers.length; ++i) {
+      bbox = Wgs84.union(bbox, wgs84Extent(layers[i]));
+    }
+
+    return V(
+      tagName,
+      { crs: 'urn:ogc:def:crs:OGC:2:84' },
+      bbox[2] > 180
+        ? [V('ows:LowerCorner', `-180 -90`), V('ows:UpperCorner', `180 90`)]
+        : [V('ows:LowerCorner', `${bbox[0]} ${bbox[1]}`), V('ows:UpperCorner', `${bbox[2]} ${bbox[3]}`)],
+    );
+  }
+
+  buildBoundingBox(tms: TileMatrixSet, extent: Bounds): VNodeElement {
+    const bbox = extent.toBbox();
+    return V('ows:BoundingBox', { crs: tms.projection.toUrn() }, [
+      V('ows:LowerCorner', `${bbox[tms.indexX]} ${bbox[tms.indexY]}`),
+      V('ows:UpperCorner', `${bbox[tms.indexX + 2]} ${bbox[tms.indexY + 2]}`),
+    ]);
+  }
+
+  buildProvider(): VNodeElement[] {
+    const { serviceIdentification, serviceProvider } = this.provider;
+    const { contact } = serviceProvider;
+    return [
+      V('ows:ServiceIdentification', [
+        V('ows:Title', serviceIdentification.title),
+        V('ows:Abstract', serviceIdentification.description),
+        V('ows:ServiceType', 'OGC WMTS'),
+        V('ows:ServiceTypeVersion', '1.0.0'),
+        V('ows:Fees', serviceIdentification.fees),
+        V('ows:AccessConstraints', serviceIdentification.accessConstraints),
+      ]),
+
+      V('ows:ServiceProvider', [
+        V('ows:ProviderName', serviceProvider.name),
+        V('ows:ProviderSite', { 'xlink:href': serviceProvider.site }),
+        V('ows:ServiceContact', [
+          V('ows:IndividualName', contact.individualName),
+          V('ows:PositionName', contact.position),
+          V('ows:ContactInfo', [
+            V('ows:Phone', [V('ows:Voice', contact.phone)]),
+            V('ows:Address', [
+              V('ows:DeliveryPoint', contact.address.deliveryPoint),
+              V('ows:City', contact.address.city),
+              V('ows:PostalCode', contact.address.postalCode),
+              V('ows:Country', contact.address.country),
+              V('ows:ElectronicMailAddress', contact.address.email),
+            ]),
+          ]),
+        ]),
+      ]),
+    ];
+  }
+
+  buildTileUrl(tileSet: TileSetRaster, suffix: string): string {
+    const apiSuffix = this.apiKey ? `?api=${this.apiKey}` : '';
+    return [
+      this.httpBase,
+      'v1',
+      'tiles',
+      tileSet.fullName,
+      '{TileMatrixSet}',
+      '{TileMatrix}',
+      '{TileCol}',
+      `{TileRow}.${suffix}${apiSuffix}`,
+    ].join('/');
+  }
+
+  buildResourceUrl(tileSet: TileSetRaster, suffix: string): VNodeElement {
+    return V('ResourceURL', {
+      format: 'image/' + suffix,
+      resourceType: 'tile',
+      template: this.buildTileUrl(tileSet, suffix),
+    });
+  }
+
+  buildLayer(layers: TileSetRaster[]): VNodeElement {
+    const matrixSets = new Set<string>();
+    const matrixSetNodes: VNodeElement[] = [];
+    for (const layer of layers) {
+      if (matrixSets.has(layer.tileMatrix.identifier)) continue;
+      matrixSets.add(layer.tileMatrix.identifier);
+      matrixSetNodes.push(V('TileMatrixSetLink', [V('TileMatrixSet', getTileMatrixId(layer.tileMatrix))]));
+    }
+
+    const [firstLayer] = layers;
+    return V('Layer', [
+      V('ows:Title', firstLayer.title),
+      V('ows:Abstract', firstLayer.description),
+      V('ows:Identifier', firstLayer.fullName),
+      ...layers.map((layer) => this.buildBoundingBox(layer.tileMatrix, layer.extent)),
+      this.buildWgs84BoundingBox(layers),
+      this.buildStyle(),
+      ...ImageFormatOrder.map((fmt) => V('Format', 'image/' + fmt)),
+      ...matrixSetNodes,
+      ...ImageFormatOrder.map((fmt) => this.buildResourceUrl(firstLayer, fmt)),
+    ]);
+  }
+
+  buildStyle(): VNodeElement {
+    return V('Style', { isDefault: 'true' }, [V('ows:Title', 'Default Style'), V('ows:Identifier', 'default')]);
+  }
+
+  buildTileMatrixSet(tms: TileMatrixSet): VNodeElement {
+    return V('TileMatrixSet', [
+      V('ows:Title', tms.def.title),
+      tms.def.abstract ? V('ows:Abstract', tms.def.abstract) : null,
+      V('ows:Identifier', getTileMatrixId(tms)),
+      V('ows:SupportedCRS', tms.projection.toUrn()),
+      tms.def.wellKnownScaleSet ? V('WellKnownScaleSet', tms.def.wellKnownScaleSet) : null,
+      ...tms.def.tileMatrix.map((c) => {
+        return V('TileMatrix', [
+          V('ows:Identifier', c.identifier),
+          V('ScaleDenominator', c.scaleDenominator),
+          V('TopLeftCorner', c.topLeftCorner.join(' ')),
+          V('TileWidth', c.tileWidth),
+          V('TileHeight', c.tileHeight),
+          V('MatrixWidth', c.matrixWidth),
+          V('MatrixHeight', c.matrixHeight),
+        ]);
+      }),
+    ]);
+  }
+  toVNode(): VNodeElement {
+    const layers: VNodeElement[] = [];
+    for (const tileSets of this.layers.values()) {
+      layers.push(this.buildLayer(tileSets));
+    }
+    for (const tms of this.tileMatrixSets.values()) layers.push(this.buildTileMatrixSet(tms));
+
+    return V('Capabilities', CapabilitiesAttrs, [...this.buildProvider(), V('Contents', layers)]);
+  }
+
+  toString(): string {
+    return '<?xml version="1.0"?>\n' + this.toVNode().toString();
+  }
+
+  static toXml(httpBase: string, provider: ConfigProvider, tileSet: TileSetRaster[], apiKey?: string): string {
+    return new WmtsCapabilities(httpBase, provider, tileSet, apiKey).toString();
+  }
+}

package/test-dump.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Render a single tile and save it as a PNG
+ */
+import 'source-map-support/register.js';
+import './build/cli/dump.js';

package/test-imagery.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import 'source-map-support/register.js';
+import './build/cli/validate.js';

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./build"
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../shared" },
+    { "path": "../geo" },
+    { "path": "../tiler" },
+    { "path": "../tiler-sharp" },
+    { "path": "../attribution" }
+  ]
+}