@basemaps/lambda-tiler 6.39.0 → 6.41.0

package/src/wmts.capability.ts

@@ -1,6 +1,6 @@
 import { ConfigImagery, ConfigLayer, ConfigTileSet, standardizeLayerName } from '@basemaps/config';
-import { Bounds, GoogleTms, ImageFormat, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
-import { Projection, toQueryString, V, VNodeElement } from '@basemaps/shared';
+import { Bounds, GoogleTms, ImageFormat, Projection, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
+import { toQueryString, V, VNodeElement } from '@basemaps/shared';
 import { ImageFormatOrder } from '@basemaps/tiler';
 import { BoundingBox } from '@cogeotiff/core';
 import { BBox } from '@linzjs/geojson';
@@ -20,26 +20,6 @@ function wgs84Extent(tileMatrix: TileMatrixSet, bbox: BoundingBox): BBox {
   return Projection.get(tileMatrix).boundsToWgs84BoundingBox(bbox);
 }
 
-export interface WmtsCapabilitiesParams {
-  /** Base URL for tile server */
-  httpBase: string;
-  provider?: WmtsProvider;
-  /** Tileset to export into WMTS */
-  tileSet: ConfigTileSet;
-  /** List of tile matrixes to output */
-  tileMatrix: TileMatrixSet[];
-  /** Should WMTS Layers be created for each imagery set inside this tileSet */
-  isIndividualLayers: boolean;
-  /** All the imagery used by the tileSet and tileMatrixes */
-  imagery: Map<string, ConfigImagery>;
-  /** API key to append to all resource urls */
-  apiKey?: string;
-  /** Limit the output to the following image formats other wise @see ImageFormatOrder */
-  formats?: ImageFormat[] | null;
-  /** Config location */
-  config?: string | null;
-}
-
 /** Number of decimal places to use in lat lng */
 const LngLatPrecision = 6;
 const MeterPrecision = 4;
@@ -52,31 +32,66 @@ function formatCoords(x: number, precision: number): string {
 function formatBbox(x: number, y: number, precision: number): string {
   return `${formatCoords(x, precision)} ${formatCoords(y, precision)}`;
 }
+export interface WmtsBuilderParams {
+  /** Base URL for tile server */
+  httpBase: string;
+  /** API key to append to all resource urls */
+  apiKey?: string;
+  /** Config location */
+  config?: string | null;
+  /** Specific DateRange filter for the wmts layers */
+  filters?: Record<string, string | undefined>;
+}
 
-export class WmtsCapabilities {
+export class WmtsBuilder {
   httpBase: string;
-  provider?: WmtsProvider;
-  tileSet: ConfigTileSet;
   apiKey?: string;
   config?: string | null;
-  tileMatrixSets = new Map<string, TileMatrixSet>();
-  imagery: Map<string, ConfigImagery>;
-  formats: ImageFormat[];
-  isIndividualLayers = false;
+  filters?: Record<string, string | undefined>;
 
-  minZoom = 0;
-  maxZoom = 32;
+  /** All the imagery used by the tileSet and tileMatrixes */
+  imagery: Map<string, ConfigImagery> = new Map();
+  formats: ImageFormat[] = [];
+
+  tileMatrixSets = new Map<string, TileMatrixSet>();
 
-  constructor(params: WmtsCapabilitiesParams) {
+  constructor(params: WmtsBuilderParams) {
     this.httpBase = params.httpBase;
-    this.provider = params.provider;
-    this.tileSet = params.tileSet;
-    this.config = params.config;
-    this.isIndividualLayers = params.isIndividualLayers;
-    for (const tms of params.tileMatrix) this.tileMatrixSets.set(tms.identifier, tms);
     this.apiKey = params.apiKey;
-    this.formats = params.formats ?? ImageFormatOrder;
-    this.imagery = params.imagery;
+    this.config = params.config;
+    this.filters = params.filters;
+  }
+
+  addImagery(...imagery: ConfigImagery[]): void {
+    for (const im of imagery) this.imagery.set(im.id, im);
+  }
+
+  addTileMatrix(...tileMatrix: TileMatrixSet[]): void {
+    for (const tms of tileMatrix) this.tileMatrixSets.set(tms.identifier, tms);
+  }
+
+  addFormats(...formats: ImageFormat[]): void {
+    for (const format of formats) this.formats.push(format);
+  }
+
+  getFormats(): ImageFormat[] {
+    if (this.formats.length) return this.formats;
+    return ImageFormatOrder;
+  }
+
+  getMatrixSets(tileSet: ConfigTileSet): Set<TileMatrixSet> {
+    const matrixSets = new Set<TileMatrixSet>();
+    for (const tms of this.tileMatrixSets.values()) {
+      if (tileSet.layers.find((f) => f[tms.projection.code] != null)) {
+        matrixSets.add(tms);
+      }
+    }
+    return matrixSets;
+  }
+
+  buildKeywords(tileSet: { category?: string }): VNodeElement {
+    if (tileSet.category == null) return V('ows:Keywords');
+    return V('ows:Keywords', [V('ows:Keyword', tileSet.category)]);
   }
 
   buildWgs84BoundingBox(tms: TileMatrixSet, layers: Bounds[]): VNodeElement {
@@ -124,43 +139,21 @@ export class WmtsCapabilities {
     ]);
   }
 
-  buildProvider(): VNodeElement[] {
-    if (this.provider == null) return [];
-    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),
-      ]),
+  buildStyle(): VNodeElement {
+    return V('Style', { isDefault: 'true' }, [V('ows:Title', 'Default Style'), V('ows:Identifier', 'default')]);
+  }
 
-      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),
-            ]),
-          ]),
-        ]),
-      ]),
-    ];
+  buildResourceUrl(tileSetId: string, suffix: string, addFilter = false): VNodeElement {
+    return V('ResourceURL', {
+      format: 'image/' + suffix,
+      resourceType: 'tile',
+      template: this.buildTileUrl(tileSetId, suffix, addFilter),
+    });
   }
 
-  buildTileUrl(tileSetId: string, suffix: string): string {
-    const query = toQueryString({ api: this.apiKey, config: this.config });
+  buildTileUrl(tileSetId: string, suffix: string, addFilter = false): string {
+    let query = { api: this.apiKey, config: this.config };
+    if (addFilter) query = { api: this.apiKey, config: this.config, ...this.filters };
 
     return [
       this.httpBase,
@@ -170,16 +163,22 @@ export class WmtsCapabilities {
       '{TileMatrixSet}',
       '{TileMatrix}',
       '{TileCol}',
-      `{TileRow}.${suffix}${query}`,
+      `{TileRow}.${suffix}${toQueryString(query)}`,
     ].join('/');
   }
 
-  buildResourceUrl(tileSetId: string, suffix: string): VNodeElement {
-    return V('ResourceURL', {
-      format: 'image/' + suffix,
-      resourceType: 'tile',
-      template: this.buildTileUrl(tileSetId, suffix),
-    });
+  buildFormats(): VNodeElement[] {
+    return this.getFormats().map((fmt) => V('Format', 'image/' + fmt));
+  }
+
+  buildTileMatrixLink(tileSet: ConfigTileSet): VNodeElement[] {
+    const matrixSetNodes: VNodeElement[] = [];
+    for (const tms of this.tileMatrixSets.values()) {
+      if (tileSet.layers.find((f) => f[tms.projection.code] != null)) {
+        matrixSetNodes.push(V('TileMatrixSetLink', [V('TileMatrixSet', tms.identifier)]));
+      }
+    }
+    return matrixSetNodes;
   }
 
   buildLayerFromImagery(layer: ConfigLayer): VNodeElement | null {
@@ -202,7 +201,7 @@ export class WmtsCapabilities {
     if (firstImg == null) return null;
 
     return V('Layer', [
-      V('ows:Title', layer.title ?? layerNameId),
+      V('ows:Title', layer.title),
       V('ows:Abstract', ''),
       V('ows:Identifier', layerNameId),
       this.buildKeywords(firstImg),
@@ -211,56 +210,142 @@ export class WmtsCapabilities {
       }),
       this.buildWgs84BoundingBox(firstMatrix, [Bounds.fromJson(firstImg.bounds)]),
       this.buildStyle(),
-      ...this.formats.map((fmt) => V('Format', 'image/' + fmt)),
+      ...this.getFormats().map((fmt) => V('Format', 'image/' + fmt)),
       ...matrixSetNodes,
-      ...this.formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
+      ...this.getFormats().map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
     ]);
   }
+}
 
-  buildLayer(layer: ConfigTileSet): VNodeElement {
-    const matrixSets = new Set<TileMatrixSet>();
-    const matrixSetNodes: VNodeElement[] = [];
-    for (const tms of this.tileMatrixSets.values()) {
-      if (layer.layers.find((f) => f[tms.projection.code] != null)) {
-        matrixSetNodes.push(V('TileMatrixSetLink', [V('TileMatrixSet', tms.identifier)]));
-        matrixSets.add(tms);
-      }
-    }
-    const layerNameId = standardizeLayerName(layer.name);
+export interface WmtsCapabilitiesParams {
+  provider?: WmtsProvider;
+  /** Tileset to export into WMTS */
+  tileSet: ConfigTileSet;
+  /** List of tile matrixes to output */
+  tileMatrix: TileMatrixSet[];
+  /** All the imagery used by the tileSet and tileMatrixes */
+  imagery: Map<string, ConfigImagery>;
+  /** Limit the output to the following image formats other wise @see ImageFormatOrder */
+  formats: ImageFormat[];
+  /** Specific layers to add to the WMTS */
+  layers?: ConfigLayer[];
+}
+
+/**
+ * WMTS Capabilities Builder
+ *
+ * /v1/tiles/:tileSet/:tileMatrix/WMTSCapabilities.xml
+ * /v1/tiles/:tileSet/WMTSCapabilities.xml
+ * /v1/tiles/WMTSCapabilities.xml
+ *
+ * @example
+ *
+ */
+export class WmtsCapabilities extends WmtsBuilder {
+  minZoom = 0;
+  maxZoom = 32;
+  /** Wmts tileSet layer and imagery layers information */
+  tileSet: ConfigTileSet;
+  configLayers?: ConfigLayer[];
+
+  /** Wmts Provider information */
+  provider?: WmtsProvider;
+
+  constructor(params: WmtsBuilderParams) {
+    super(params);
+  }
+
+  addTileSet(tileSet: ConfigTileSet): void {
+    this.tileSet = tileSet;
+  }
+
+  addLayers(configLayers?: ConfigLayer[]): void {
+    this.configLayers = configLayers;
+  }
+
+  addProvider(provider?: WmtsProvider): void {
+    this.provider = provider;
+  }
+
+  toProviderVNode(provider?: WmtsProvider): VNodeElement[] | [] {
+    if (provider == null) return [];
+    const { serviceIdentification, serviceProvider } = 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),
+            ]),
+          ]),
+        ]),
+      ]),
+    ];
+  }
+
+  toLayerVNode(tileSet: ConfigTileSet): VNodeElement {
+    const matrixSets = this.getMatrixSets(tileSet);
     const matrixSetList = [...matrixSets.values()];
     const firstMatrix = matrixSetList[0];
-    if (firstMatrix == null) throw new Error('No matrix sets found for layer ' + layer.name);
+    if (firstMatrix == null) throw new Error('No matrix sets found for layer ' + tileSet.name);
 
     // Prefer using the web mercator tms for bounds
     const webMercatorOrFirst = matrixSetList.find((f) => f.identifier === GoogleTms.identifier) ?? firstMatrix;
     const bounds: Bounds[] = [];
-    for (const l of layer.layers) {
+    for (const l of tileSet.layers) {
       const img = this.imagery.get(l[webMercatorOrFirst.projection.code] ?? '');
       if (img == null) continue;
       bounds.push(Bounds.fromJson(img.bounds));
     }
 
+    const layerNameId = standardizeLayerName(tileSet.name);
     return V('Layer', [
-      V('ows:Title', layer.title ?? layerNameId),
-      V('ows:Abstract', layer.description ?? ''),
+      V('ows:Title', tileSet.title),
+      V('ows:Abstract', tileSet.description ?? ''),
       V('ows:Identifier', layerNameId),
-      this.buildKeywords(layer),
-      ...[...matrixSets.values()].map((tms) => this.buildBoundingBoxFromImagery(tms, layer.layers)),
+      this.buildKeywords(tileSet),
+      ...[...matrixSets.values()].map((tms) => this.buildBoundingBoxFromImagery(tms, tileSet.layers)),
       this.buildWgs84BoundingBox(webMercatorOrFirst, bounds),
       this.buildStyle(),
-      ...this.formats.map((fmt) => V('Format', 'image/' + fmt)),
-      ...matrixSetNodes,
-      ...this.formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
+      ...this.buildFormats(),
+      ...this.buildTileMatrixLink(tileSet),
+      ...this.getFormats().map((fmt) => this.buildResourceUrl(layerNameId, fmt, true)),
     ]);
   }
 
-  buildKeywords(tileSet: { category?: string }): VNodeElement {
-    if (tileSet.category == null) return V('ows:Keywords');
-    return V('ows:Keywords', [V('ows:Keyword', tileSet.category)]);
-  }
-
-  buildStyle(): VNodeElement {
-    return V('Style', { isDefault: 'true' }, [V('ows:Title', 'Default Style'), V('ows:Identifier', 'default')]);
+  toAllImageryLayersVNode(configLayers?: ConfigLayer[]): VNodeElement[] {
+    if (configLayers == null) return [];
+    const layersVNode: VNodeElement[] = [];
+    const layerByName = new Map<string, ConfigLayer>();
+    // Dedupe the layers by unique name
+    for (const img of configLayers) layerByName.set(standardizeLayerName(img.name), img);
+    const orderedLayers = Array.from(layerByName.values()).sort((a, b) =>
+      (a.title ?? a.name).localeCompare(b.title ?? b.name),
+    );
+    for (const img of orderedLayers) {
+      const layer = this.buildLayerFromImagery(img);
+      if (layer) layersVNode.push(layer);
+    }
+    return layersVNode;
   }
 
   buildTileMatrixSet(tms: TileMatrixSet): VNodeElement {
@@ -283,26 +368,34 @@ export class WmtsCapabilities {
       }),
     ]);
   }
+
   toVNode(): VNodeElement {
-    const layers: (VNodeElement | null)[] = [];
-    layers.push(this.buildLayer(this.tileSet));
-
-    if (this.isIndividualLayers) {
-      const layerByName = new Map<string, ConfigLayer>();
-      // Dedupe the layers by unique name
-      for (const img of this.tileSet.layers) layerByName.set(standardizeLayerName(img.name), img);
-      const orderedLayers = Array.from(layerByName.values()).sort((a, b) =>
-        (a.title ?? a.name).localeCompare(b.title ?? b.name),
-      );
-      for (const img of orderedLayers) layers.push(this.buildLayerFromImagery(img));
-    }
+    // Prepare provider vNode if exists
+    const provider = this.toProviderVNode(this.provider);
+
+    // Build TileSet Layer VNodes
+    const layers: VNodeElement[] = [];
+    layers.push(this.toLayerVNode(this.tileSet));
+    const contents = layers.concat(this.toAllImageryLayersVNode(this.configLayers));
 
-    for (const tms of this.tileMatrixSets.values()) layers.push(this.buildTileMatrixSet(tms));
+    // Build TileMatrix Sets vNodes
+    for (const tms of this.tileMatrixSets.values()) contents.push(this.buildTileMatrixSet(tms));
 
-    return V('Capabilities', CapabilitiesAttrs, [...this.buildProvider(), V('Contents', layers)]);
+    return V('Capabilities', CapabilitiesAttrs, [...provider, V('Contents', contents)]);
   }
 
   toXml(): string {
     return '<?xml version="1.0" encoding="utf-8"?>\n' + this.toVNode().toString();
   }
+
+  fromParams(params: WmtsCapabilitiesParams): void {
+    for (const tileMatrix of params.tileMatrix) this.addTileMatrix(tileMatrix);
+    for (const im of params.imagery.values()) this.addImagery(im);
+    for (const format of params.formats) this.addFormats(format);
+
+    // Build wmts capabilities
+    this.addTileSet(params.tileSet);
+    this.addLayers(params.layers);
+    this.addProvider(params.provider);
+  }
 }