@basemaps/lambda-tiler 6.38.0 → 6.40.0

package/src/routes/__tests__/wmts.test.ts

@@ -9,18 +9,11 @@ import { Api, mockUrlRequest } from '../../__tests__/xyz.util.js';
 o.spec('WMTSRouting', () => {
   const sandbox = createSandbox();
   const config = new ConfigProviderMemory();
+  const imagery = new Map();
 
-  o.before(() => {
+  o.beforeEach(() => {
     sandbox.stub(ConfigLoader, 'load').resolves(config);
-  });
 
-  o.afterEach(() => {
-    config.objects.clear();
-    sandbox.restore();
-  });
-
-  o('should default to the aerial layer', async () => {
-    const imagery = new Map();
     imagery.set(Imagery3857.id, Imagery3857);
     imagery.set(Imagery2193.id, Imagery2193);
 
@@ -28,7 +21,14 @@ o.spec('WMTSRouting', () => {
     config.put(Imagery2193);
     config.put(Imagery3857);
     config.put(Provider);
+  });
 
+  o.afterEach(() => {
+    config.objects.clear();
+    sandbox.restore();
+  });
+
+  o('should default to the aerial layer', async () => {
     const req = mockUrlRequest(
       '/v1/tiles/WMTSCapabilities.xml',
       `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json`,
@@ -53,4 +53,65 @@ o.spec('WMTSRouting', () => {
       '<ResourceURL format="image/png" resourceType="tile" template="https://tiles.test/v1/tiles/ōtorohanga-urban-2021-0.1m/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=d01f7w7rnhdzg0p7fyrc9v9ard1&amp;config=Q5pC4UjWdtFLU1CYtLcRSmB49RekgDgMa5EGJnB2M" />',
     ]);
   });
+
+  o('should filter out date[after] by year', async () => {
+    const req = mockUrlRequest(
+      '/v1/tiles/WMTSCapabilities.xml',
+      `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json&date[after]=2022`,
+    );
+    const res = await handler.router.handle(req);
+
+    o(res.status).equals(200);
+    const lines = Buffer.from(res.body, 'base64').toString().split('\n');
+    const titles = lines.filter((f) => f.startsWith('      <ows:Title>')).map((f) => f.trim());
+
+    o(titles).deepEquals([
+      '<ows:Title>Aerial Imagery</ows:Title>',
+      '<ows:Title>Google Maps Compatible for the World</ows:Title>',
+      '<ows:Title>LINZ NZTM2000 Map Tile Grid V2</ows:Title>',
+    ]);
+  });
+
+  o('should filter out date[before] by year', async () => {
+    const req = mockUrlRequest(
+      '/v1/tiles/WMTSCapabilities.xml',
+      `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json&date[before]=2020`,
+    );
+    const res = await handler.router.handle(req);
+
+    o(res.status).equals(200);
+    const lines = Buffer.from(res.body, 'base64').toString().split('\n');
+    const titles = lines.filter((f) => f.startsWith('      <ows:Title>')).map((f) => f.trim());
+
+    o(titles).deepEquals([
+      '<ows:Title>Aerial Imagery</ows:Title>',
+      '<ows:Title>Google Maps Compatible for the World</ows:Title>',
+      '<ows:Title>LINZ NZTM2000 Map Tile Grid V2</ows:Title>',
+    ]);
+  });
+
+  o('should filter inclusive date[before] by year', async () => {
+    const req = mockUrlRequest(
+      '/v1/tiles/WMTSCapabilities.xml',
+      `format=png&api=${Api.key}&config=s3://linz-basemaps/config.json&date[before]=2021`,
+    );
+    const res = await handler.router.handle(req);
+
+    o(res.status).equals(200);
+    const lines = Buffer.from(res.body, 'base64').toString().split('\n');
+    const titles = lines.filter((f) => f.startsWith('      <ows:Title>')).map((f) => f.trim());
+
+    o(titles).deepEquals([
+      '<ows:Title>Aerial Imagery</ows:Title>',
+      '<ows:Title>Ōtorohanga 0.1m Urban Aerial Photos (2021)</ows:Title>',
+      '<ows:Title>Google Maps Compatible for the World</ows:Title>',
+      '<ows:Title>LINZ NZTM2000 Map Tile Grid V2</ows:Title>',
+    ]);
+
+    const resourceURLs = lines.filter((f) => f.includes('<ResourceURL')).map((f) => f.trim());
+    o(resourceURLs).deepEquals([
+      '<ResourceURL format="image/png" resourceType="tile" template="https://tiles.test/v1/tiles/aerial/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=d01f7w7rnhdzg0p7fyrc9v9ard1&amp;config=Q5pC4UjWdtFLU1CYtLcRSmB49RekgDgMa5EGJnB2M&amp;date%5Bbefore%5D=2021" />',
+      '<ResourceURL format="image/png" resourceType="tile" template="https://tiles.test/v1/tiles/ōtorohanga-urban-2021-0.1m/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.png?api=d01f7w7rnhdzg0p7fyrc9v9ard1&amp;config=Q5pC4UjWdtFLU1CYtLcRSmB49RekgDgMa5EGJnB2M" />',
+    ]);
+  });
 });

package/src/routes/attribution.ts

@@ -11,12 +11,13 @@ import {
   StacProvider,
   TileMatrixSet,
 } from '@basemaps/geo';
-import { extractYearRangeFromName, Projection, titleizeImageryName } from '@basemaps/shared';
+import { extractYearRangeFromName, extractYearRangeFromTitle, Projection } from '@basemaps/shared';
 import { BBox, MultiPolygon, multiPolygonToWgs84, Pair, union, Wgs84 } from '@linzjs/geojson';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { ConfigLoader } from '../util/config.loader.js';
 
 import { Etag } from '../util/etag.js';
+import { filterLayers, yearRangeToInterval } from '../util/filter.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 
@@ -44,23 +45,19 @@ function roundPair(p: Pair): Pair {
  * @param files in target projection
  * @return MultiPolygon in WGS84
  */
-function createCoordinates(bbox: BBox, files: NamedBounds[], proj: Projection): MultiPolygon {
+export function createCoordinates(bbox: BBox, files: NamedBounds[], proj: Projection): MultiPolygon {
   if (Wgs84.delta(bbox[0], bbox[2]) <= 0) {
     // This bounds spans more than half the globe which multiPolygonToWgs84 can't handle; just
     // return bbox as polygon
     return Wgs84.bboxToMultiPolygon(bbox);
   }
 
-  let coordinates: MultiPolygon = [];
-
+  const polygons: MultiPolygon = [];
   // merge imagery bounds
-  for (const image of files) {
-    const poly = [Bounds.fromJson(image).pad(SmoothPadding).toPolygon()] as MultiPolygon;
-    coordinates = union(coordinates, poly);
-  }
+  for (const image of files) polygons.push(Bounds.fromJson(image).pad(SmoothPadding).toPolygon());
+  const coordinates = union(polygons);
 
   const roundToWgs84 = (p: number[]): number[] => roundPair(proj.toWgs84(p) as Pair);
-
   return multiPolygonToWgs84(coordinates, roundToWgs84);
 }
 
@@ -86,30 +83,23 @@ async function tileSetAttribution(
 
   const config = await ConfigLoader.load(req);
   const imagery = await getAllImagery(config, tileSet.layers, [tileMatrix.projection]);
+  const filteredLayers = filterLayers(req, tileSet.layers);
 
   const host = await config.Provider.get(config.Provider.id('linz'));
 
-  for (const layer of tileSet.layers) {
+  for (const layer of filteredLayers) {
+    if (layer.disabled) continue;
     const imgId = layer[proj.epsg.code];
     if (imgId == null) continue;
     const im = imagery.get(imgId);
     if (im == null) continue;
+    const title = im.title;
 
     const bbox = proj.boundsToWgs84BoundingBox(im.bounds).map(roundNumber) as BBox;
 
-    const years = extractYearRangeFromName(im.name);
-    if (years[0] === -1) {
-      req.log.debug({ imagery: im.name }, 'Attribution:DefaultYear');
-      // Put it in the future so people know its a "fake" date
-      years[0] = new Date().getUTCFullYear() + 1;
-      years[1] = years[0] + 1;
-    }
-
-    const interval = [years.map((y) => `${y}-01-01T00:00:00Z`) as [string, string]];
-
-    const extent: StacExtent = { spatial: { bbox: [bbox] }, temporal: { interval } };
+    const extent: StacExtent = { spatial: { bbox: [bbox] } };
 
-    items.push({
+    const item: AttributionItem = {
       type: 'Feature',
       stac_version: Stac.Version,
       id: imgId + '_item',
@@ -119,13 +109,19 @@ async function tileSetAttribution(
       bbox,
       geometry: { type: 'MultiPolygon', coordinates: createCoordinates(bbox, im.files, proj) },
       properties: {
-        title: im.title ?? titleizeImageryName(im.name),
+        title,
         category: im.category,
-        datetime: null,
-        start_datetime: interval[0][0],
-        end_datetime: interval[0][1],
       },
-    });
+    };
+    const years = extractYearRangeFromTitle(im.title) ?? extractYearRangeFromName(im.name);
+    if (years) {
+      const interval = yearRangeToInterval(years);
+      extent.temporal = { interval: [[interval[0].toISOString(), interval[1].toISOString()]] };
+      item.properties.datetime = null;
+      item.properties.start_datetime = interval[0].toISOString();
+      item.properties.end_datetime = interval[1].toISOString();
+    }
+    items.push(item);
 
     const zoomMin = TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true);
     const zoomMax = TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true);
@@ -134,7 +130,7 @@ async function tileSetAttribution(
       license: Stac.License,
       id: im.id,
       providers: getHost(host),
-      title: im.title ?? titleizeImageryName(im.name),
+      title,
       description: 'No description',
       extent,
       links: [],

package/src/routes/tile.json.ts

@@ -2,6 +2,7 @@ import { GoogleTms, TileJson, TileMatrixSet } from '@basemaps/geo';
 import { Env, toQueryString } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { ConfigLoader } from '../util/config.loader.js';
+import { getFilters } from '../util/filter.js';
 import { NotFound } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 
@@ -31,7 +32,7 @@ export async function tileJsonGet(req: LambdaHttpRequest<TileJsonGet>): Promise<
 
   const configLocation = ConfigLoader.extract(req);
 
-  const query = toQueryString({ api: apiKey, config: configLocation });
+  const query = toQueryString({ api: apiKey, config: configLocation, ...getFilters(req) });
 
   const tileUrl =
     [host, 'v1', 'tiles', tileSet.name, tileMatrix.identifier, '{z}', '{x}', '{y}'].join('/') + `.${format[0]}${query}`;

package/src/routes/tile.style.json.ts

@@ -1,4 +1,4 @@
-import { ConfigTileSetRaster, Sources, StyleJson, TileSetType } from '@basemaps/config';
+import { ConfigTileSetRaster, Layer, Sources, StyleJson, TileSetType } from '@basemaps/config';
 import { Env, toQueryString } from '@basemaps/shared';
 import { fsa } from '@chunkd/fs';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
@@ -8,6 +8,7 @@ import { Validate } from '../util/validate.js';
 import { Etag } from '../util/etag.js';
 import { ConfigLoader } from '../util/config.loader.js';
 import { GoogleTms, ImageFormat, TileMatrixSets } from '@basemaps/geo';
+import { getFilters } from '../util/filter.js';
 
 /**
  * Convert relative URLS into a full hostname url
@@ -31,7 +32,7 @@ export function convertRelativeUrl(url?: string, apiKey?: string, config?: strin
  * @param apiKey api key to inject
  * @returns new stylejson
  */
-export function convertStyleJson(style: StyleJson, apiKey: string, config: string | null): StyleJson {
+export function convertStyleJson(style: StyleJson, apiKey: string, config: string | null, layers?: Layer[]): StyleJson {
   const sources: Sources = JSON.parse(JSON.stringify(style.sources));
   for (const [key, value] of Object.entries(sources)) {
     if (value.type === 'vector') {
@@ -49,7 +50,7 @@ export function convertStyleJson(style: StyleJson, apiKey: string, config: strin
     id: style.id,
     name: style.name,
     sources,
-    layers: style.layers,
+    layers: layers ? layers : style.layers,
     metadata: style.metadata ?? {},
     glyphs: convertRelativeUrl(style.glyphs, undefined, config),
     sprite: convertRelativeUrl(style.sprite, undefined, config),
@@ -73,7 +74,7 @@ export async function tileSetToStyle(
   if (tileFormat == null) return new LambdaHttpResponse(400, 'Invalid image format');
 
   const configLocation = ConfigLoader.extract(req);
-  const query = toQueryString({ config: configLocation, api: apiKey });
+  const query = toQueryString({ config: configLocation, api: apiKey, ...getFilters(req) });
 
   const tileUrl = fsa.join(
     Env.get(Env.PublicUrlBase) ?? '',
@@ -101,6 +102,8 @@ export async function tileSetToStyle(
 export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<LambdaHttpResponse> {
   const apiKey = Validate.apiKey(req);
   const styleName = req.params.styleName;
+  const excludeLayers = req.query.getAll('exclude');
+  const excluded = new Set(excludeLayers.map((l) => l.toLowerCase()));
 
   // Get style Config from db
   const config = await ConfigLoader.load(req);
@@ -115,7 +118,12 @@ export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<La
   }
 
   // Prepare sources and add linz source
-  const style = convertStyleJson(styleConfig.style, apiKey, ConfigLoader.extract(req));
+  const style = convertStyleJson(
+    styleConfig.style,
+    apiKey,
+    ConfigLoader.extract(req),
+    styleConfig.style.layers.filter((f) => !excluded.has(f.id.toLowerCase())),
+  );
   const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = Etag.key(data);

package/src/routes/tile.wmts.ts

@@ -8,6 +8,7 @@ import { Validate } from '../util/validate.js';
 import { WmtsCapabilities } from '../wmts.capability.js';
 import { Etag } from '../util/etag.js';
 import { ConfigLoader } from '../util/config.loader.js';
+import { filterLayers, getFilters } from '../util/filter.js';
 
 export interface WmtsCapabilitiesGet {
   Params: {
@@ -59,11 +60,12 @@ export async function wmtsCapabilitiesGet(req: LambdaHttpRequest<WmtsCapabilitie
     provider: provider ?? undefined,
     tileSet,
     tileMatrix,
-    isIndividualLayers: req.params.tileMatrix == null,
     imagery,
     apiKey,
     config: ConfigLoader.extract(req),
     formats: Validate.getRequestedFormats(req),
+    layers: req.params.tileMatrix == null ? filterLayers(req, tileSet.layers) : null,
+    filters: getFilters(req),
   }).toXml();
   if (xml == null) return NotFound();
 

package/src/routes/tile.xyz.raster.ts

@@ -9,6 +9,7 @@ import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambd
 import pLimit from 'p-limit';
 import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
+import { filterLayers } from '../util/filter.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { CoSources } from '../util/source.cache.js';
 import { TileXyz } from '../util/validate.js';
@@ -32,13 +33,15 @@ export const TileXyzRaster = {
   async getAssetsForTile(req: LambdaHttpRequest, tileSet: ConfigTileSetRaster, xyz: TileXyz): Promise<string[]> {
     const config = await ConfigLoader.load(req);
     const imagery = await getAllImagery(config, tileSet.layers, [xyz.tileMatrix.projection]);
+    const filteredLayers = filterLayers(req, tileSet.layers);
 
     const output: string[] = [];
     const tileBounds = xyz.tileMatrix.tileToSourceBounds(xyz.tile);
 
     // All zoom level config is stored as Google zoom levels
     const filterZoom = TileMatrixSet.convertZoomLevel(xyz.tile.z, xyz.tileMatrix, TileMatrixSets.get(Epsg.Google));
-    for (const layer of tileSet.layers) {
+    for (const layer of filteredLayers) {
+      if (layer.disabled) continue;
       if (layer.maxZoom != null && filterZoom > layer.maxZoom) continue;
       if (layer.minZoom != null && filterZoom < layer.minZoom) continue;
 
@@ -58,14 +61,14 @@ export const TileXyzRaster = {
       }
       if (!tileBounds.intersects(Bounds.fromJson(img.bounds))) continue;
 
-      // FIXME is this meant to be >= <=
-      if (img.overviews && img.overviews.maxZoom >= filterZoom && img.overviews.minZoom <= filterZoom) {
-        output.push(fsa.join(img.uri, img.overviews.path));
-        continue;
-      }
-
       for (const c of img.files) {
         if (!tileBounds.intersects(Bounds.fromJson(c))) continue;
+
+        if (img.overviews && img.overviews.maxZoom >= filterZoom && img.overviews.minZoom <= filterZoom) {
+          output.push(fsa.join(img.uri, img.overviews.path));
+          break;
+        }
+
         const tiffPath = fsa.join(img.uri, getTiffName(c.name));
         output.push(tiffPath);
       }

package/src/util/__test__/filter.test.ts

@@ -0,0 +1,80 @@
+import { ConfigLayer } from '@basemaps/config';
+import o from 'ospec';
+import { mockUrlRequest } from '../../__tests__/xyz.util.js';
+import { filterLayers } from '../filter.js';
+
+o.spec('filterLayers', () => {
+  const sourceLayers: ConfigLayer[] = [
+    {
+      name: 'waikato-0_625m-snc12836-2004',
+      title: 'Waikato 0.625m SNC12836 (2004-2008)',
+    },
+    {
+      name: 'hawkes-bay--manawat-whanganui-0_75m-snc30001-2002',
+      title: 'Hawkes Bay / Manawatū-Whanganui 0.75m SNC30001 (2002)',
+    },
+    {
+      name: 'canterbury-0_75m-snc25054-2000-2001',
+      title: 'Canterbury 0.75m SNC25054 (2000-2001)',
+    },
+    {
+      name: 'otago-0_375m-sn3806-1975',
+      title: 'Otago 0.375m SN3806 (1975)',
+    },
+  ];
+
+  o('should not filter with empty parameters', () => {
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js'), sourceLayers);
+    o(layers).deepEquals(sourceLayers);
+  });
+
+  o('should filter date[after]', () => {
+    const dateAfter = '2003-12-31T23:59:59.999';
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}`), sourceLayers);
+    o(layers).deepEquals([sourceLayers[0]]);
+  });
+
+  o('should filter date[before]', () => {
+    const dateBefore = '2003-01-01T00:00:00.000Z';
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[before]=${dateBefore}`), sourceLayers);
+    o(layers).deepEquals(sourceLayers.slice(1));
+  });
+
+  o('should filter date[before] in between years', () => {
+    const dateBefore = '2026-01-01T00:00:00.000Z';
+    const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2020-2028)' }];
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[before]=${dateBefore}`), layer);
+    o(layers).deepEquals(layer);
+  });
+
+  o('should filter date[after] in between years', () => {
+    const dateAfter = '2026-12-31T23:59:59.999Z';
+    const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2020-2028)' }];
+    const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}`), layer);
+    o(layers).deepEquals(layer);
+  });
+
+  o('should filter date[after] and date[before] in between years', () => {
+    const dateAfter = '2026-12-31T23:59:59.999Z';
+    const dateBefore = '2028-01-01T00:00:00.000Z';
+
+    const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2020-2028)' }];
+    const layers = filterLayers(
+      mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}&date[before]=${dateBefore}`),
+      layer,
+    );
+    o(layers).deepEquals(layer);
+  });
+
+  o('should filter date[after] and date[before] in between years with single year', () => {
+    const dateAfter = '2026-12-31T23:59:59.999Z';
+    const dateBefore = '2028-01-01T00:00:00.000Z';
+
+    const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2028)' }];
+    const layers = filterLayers(
+      mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}&date[before]=${dateBefore}`),
+      layer,
+    );
+    o(layers).deepEquals(layer);
+  });
+});

package/src/util/config.loader.ts

@@ -15,8 +15,7 @@ export class ConfigLoader {
     const config = getDefaultConfig();
     if (config.assets == null) {
       const cb = await config.ConfigBundle.get(config.ConfigBundle.id('latest'));
-      if (cb == null) throw new LambdaHttpResponse(400, 'Unable to get lastest config bundle for asset.');
-      config.assets = cb.assets;
+      if (cb) config.assets = cb.assets;
     }
     return config;
   }

package/src/util/filter.ts

@@ -0,0 +1,60 @@
+import { ConfigLayer } from '@basemaps/config';
+import { extractYearRangeFromTitle } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
+export const FilterNames = {
+  DateBefore: 'date[before]',
+  DateAfter: 'date[after]',
+};
+
+export function getFilters(req: LambdaHttpRequest): Record<string, string | undefined> {
+  return {
+    [FilterNames.DateBefore]: req.query.get(FilterNames.DateBefore) ?? undefined,
+    [FilterNames.DateAfter]: req.query.get(FilterNames.DateAfter) ?? undefined,
+  };
+}
+/**
+ * Convert the year range into full ISO date year range
+ *
+ * Expand to the full year of jan 1st 00:00 -> Dec 31st 23:59
+ */
+export function yearRangeToInterval(x: [number] | [number, number]): [Date, Date] {
+  if (x.length === 1) return [new Date(`${x[0]}-01-01T00:00:00.000Z`), new Date(`${x[0]}-12-31T23:59:59.999Z`)];
+  return [new Date(`${x[0]}-01-01T00:00:00.000Z`), new Date(`${x[1]}-12-31T23:59:59.999Z`)];
+}
+
+function parseDateAsIso(s: string | null): Date | null {
+  if (s == null) return null;
+  const date = new Date(s);
+  if (isNaN(date.getTime())) throw new LambdaHttpResponse(400, `Invalid date format: "${s}"`);
+  return date;
+}
+
+export function filterLayers(req: LambdaHttpRequest, layers: ConfigLayer[]): ConfigLayer[] {
+  const dateAfterQuery = req.query.get(FilterNames.DateAfter);
+  const dateBeforeQuery = req.query.get(FilterNames.DateBefore);
+
+  if (dateAfterQuery == null && dateBeforeQuery == null) return layers;
+  const dateAfter = parseDateAsIso(dateAfterQuery);
+  const dateBefore = parseDateAsIso(dateBeforeQuery);
+
+  const filtered = layers.filter((l) => {
+    if (l.title == null) return false;
+    const yearRange = extractYearRangeFromTitle(l.title);
+    if (yearRange == null) return false;
+
+    const ranges = yearRangeToInterval(yearRange);
+    const startYear = ranges[0];
+    const endYear = ranges[1];
+    return (dateAfter == null || endYear >= dateAfter) && (dateBefore == null || startYear <= dateBefore);
+  });
+
+  // Trace that layers have been filtered
+  req.set('layerFilter', {
+    [FilterNames.DateBefore]: dateBefore?.toISOString(),
+    [FilterNames.DateAfter]: dateAfter?.toISOString(),
+    layerCount: layers.length,
+    filterCount: filtered.length,
+  });
+  return filtered;
+}

package/src/wmts.capability.ts

@@ -28,8 +28,6 @@ export interface WmtsCapabilitiesParams {
   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 */
@@ -38,6 +36,10 @@ export interface WmtsCapabilitiesParams {
   formats?: ImageFormat[] | null;
   /** Config location */
   config?: string | null;
+  /** Specific layers to add to the WMTS */
+  layers?: ConfigLayer[] | null;
+  /** Specific DateRange filter for the wmts layers */
+  filters?: Record<string, string | undefined>;
 }
 
 /** Number of decimal places to use in lat lng */
@@ -62,21 +64,23 @@ export class WmtsCapabilities {
   tileMatrixSets = new Map<string, TileMatrixSet>();
   imagery: Map<string, ConfigImagery>;
   formats: ImageFormat[];
-  isIndividualLayers = false;
+  filters?: Record<string, string | undefined>;
 
   minZoom = 0;
   maxZoom = 32;
+  layers: ConfigLayer[] | null | undefined;
 
   constructor(params: WmtsCapabilitiesParams) {
     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.layers = params.layers;
+    this.filters = params.filters;
   }
 
   buildWgs84BoundingBox(tms: TileMatrixSet, layers: Bounds[]): VNodeElement {
@@ -159,8 +163,9 @@ export class WmtsCapabilities {
     ];
   }
 
-  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,15 +175,15 @@ export class WmtsCapabilities {
       '{TileMatrixSet}',
       '{TileMatrix}',
       '{TileCol}',
-      `{TileRow}.${suffix}${query}`,
+      `{TileRow}.${suffix}${toQueryString(query)}`,
     ].join('/');
   }
 
-  buildResourceUrl(tileSetId: string, suffix: string): VNodeElement {
+  buildResourceUrl(tileSetId: string, suffix: string, addFilter = false): VNodeElement {
     return V('ResourceURL', {
       format: 'image/' + suffix,
       resourceType: 'tile',
-      template: this.buildTileUrl(tileSetId, suffix),
+      template: this.buildTileUrl(tileSetId, suffix, addFilter),
     });
   }
 
@@ -202,7 +207,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),
@@ -241,7 +246,7 @@ export class WmtsCapabilities {
     }
 
     return V('Layer', [
-      V('ows:Title', layer.title ?? layerNameId),
+      V('ows:Title', layer.title),
       V('ows:Abstract', layer.description ?? ''),
       V('ows:Identifier', layerNameId),
       this.buildKeywords(layer),
@@ -250,7 +255,7 @@ export class WmtsCapabilities {
       this.buildStyle(),
       ...this.formats.map((fmt) => V('Format', 'image/' + fmt)),
       ...matrixSetNodes,
-      ...this.formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
+      ...this.formats.map((fmt) => this.buildResourceUrl(layerNameId, fmt, true)),
     ]);
   }
 
@@ -287,10 +292,10 @@ export class WmtsCapabilities {
     const layers: (VNodeElement | null)[] = [];
     layers.push(this.buildLayer(this.tileSet));
 
-    if (this.isIndividualLayers) {
+    if (this.layers) {
       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);
+      for (const img of this.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),
       );