@basemaps/lambda-tiler 7.7.0 → 7.10.0

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

@@ -1,20 +1,41 @@
-import { ConfigId, ConfigPrefix, ConfigTileSetRaster, Layer, Sources, StyleJson, TileSetType } from '@basemaps/config';
+import {
+  BasemapsConfigProvider,
+  ConfigId,
+  ConfigPrefix,
+  ConfigTileSetRaster,
+  Layer,
+  Sources,
+  StyleJson,
+  TileSetType,
+} from '@basemaps/config';
 import { DefaultExaggeration } from '@basemaps/config/build/config/vector.style.js';
-import { GoogleTms, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { GoogleTms, Nztm2000QuadTms, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Env, toQueryString } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { URL } from 'url';
 
 import { ConfigLoader } from '../util/config.loader.js';
 import { Etag } from '../util/etag.js';
+import { convertStyleToNztmStyle } from '../util/nztm.style.js';
 import { NotFound, NotModified } from '../util/response.js';
 import { Validate } from '../util/validate.js';
 
 /**
- * Convert relative URLS into a full hostname url
+ * Convert relative URL into a full hostname URL, converting {tileMatrix} into the provided tileMatrix
+ *
+ * Will also add query parameters of apiKey and configuration if provided
+ *
+ * @example
+ * ```typescript
+ * convertRelativeUrl("/v1/tiles/aerial/{tileMatrix}/{z}/{x}/{y}.webp", NZTM2000Quad)
+ * "https://basemaps.linz.govt.nz/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.webp?api=c..."
+ * ```
+ *
  * @param url possible url to update
  * @param apiKey ApiKey to append with ?api= if required
- * @returns Updated Url or empty string if url is empty
+ * @param tileMatrix replace {tileMatrix} with the tile matrix
+ *
+ * @returns Updated URL or empty string if url is empty
  */
 export function convertRelativeUrl(
   url?: string,
@@ -33,64 +54,82 @@ export function convertRelativeUrl(
 }
 
 /**
- * Create a new style json that has absolute urls to the current host and  API Keys where required
+ * Update the style JSON to have absolute urls to the current host and API Keys where required
+ *
  * @param style style to update
+ * @param tileMatrix convert the tile matrix to the target tile matrix
  * @param apiKey api key to inject
- * @returns new stylejson
+ * @param config optional configuration url to use
+ * @param layers replace the layers in the style json
+ * @returns new style JSON
  */
-export function convertStyleJson(
-  style: StyleJson,
-  tileMatrix: TileMatrixSet,
-  apiKey: string,
-  config: string | null,
-  layers?: Layer[],
-): StyleJson {
-  const sources = JSON.parse(JSON.stringify(style.sources)) as Sources;
-  for (const [key, value] of Object.entries(sources)) {
+export function setStyleUrls(style: StyleJson, tileMatrix: TileMatrixSet, apiKey: string, config: string | null): void {
+  for (const [key, value] of Object.entries(style.sources ?? {})) {
     if (value.type === 'vector') {
-      if (tileMatrix !== GoogleTms) {
-        throw new LambdaHttpResponse(400, `TileMatrix is not supported for the vector source ${value.url}.`);
-      }
       value.url = convertRelativeUrl(value.url, tileMatrix, apiKey, config);
     } else if ((value.type === 'raster' || value.type === 'raster-dem') && Array.isArray(value.tiles)) {
       for (let i = 0; i < value.tiles.length; i++) {
         value.tiles[i] = convertRelativeUrl(value.tiles[i], tileMatrix, apiKey, config);
       }
     }
-    sources[key] = value;
+    style.sources[key] = value;
   }
 
-  const styleJson: StyleJson = {
-    version: 8,
-    id: style.id,
-    name: style.name,
-    sources,
-    layers: layers ? layers : style.layers,
-  };
-
-  if (style.metadata) styleJson.metadata = style.metadata;
-  if (style.glyphs) styleJson.glyphs = convertRelativeUrl(style.glyphs, undefined, undefined, config);
-  if (style.sprite) styleJson.sprite = convertRelativeUrl(style.sprite, undefined, undefined, config);
-  if (style.sky) styleJson.sky = style.sky;
-
-  return styleJson;
+  if (style.glyphs) style.glyphs = convertRelativeUrl(style.glyphs, undefined, undefined, config);
+  if (style.sprite) style.sprite = convertRelativeUrl(style.sprite, undefined, undefined, config);
 }
 
-export interface StyleGet {
-  Params: {
-    styleName: string;
-  };
+export interface StyleConfig {
+  /** Name of the terrain layer */
+  terrain?: string | null;
+  /** Combine layer with the labels layer */
+  labels: boolean;
 }
 
+/**
+ * Turn on the terrain setting in the style json
+ */
 function setStyleTerrain(style: StyleJson, terrain: string, tileMatrix: TileMatrixSet): void {
   const source = Object.keys(style.sources).find((s) => s === terrain);
-  if (source == null) throw new LambdaHttpResponse(400, `Terrain: ${terrain} is not exists in the style source.`);
+  if (source == null) throw new LambdaHttpResponse(400, `Terrain: ${terrain} does not exists in the style source.`);
   style.terrain = {
     source,
     exaggeration: DefaultExaggeration[tileMatrix.identifier] ?? DefaultExaggeration[GoogleTms.identifier],
   };
 }
 
+/**
+ * Merge the "labels" layer into the style json
+ */
+async function setStyleLabels(req: LambdaHttpRequest<StyleGet>, style: StyleJson): Promise<void> {
+  const config = await ConfigLoader.load(req);
+  const labels = await config.Style.get('labels');
+
+  if (labels == null) {
+    req.log.warn('LabelsStyle:Missing');
+    return;
+  }
+
+  const layerId = new Set<string>();
+  for (const l of style.layers) layerId.add(l.id);
+
+  for (const newLayers of labels.style.layers) {
+    if (layerId.has(newLayers.id)) {
+      throw new LambdaHttpResponse(400, 'Cannot merge styles with duplicate layerIds: ' + newLayers.id);
+    }
+  }
+
+  if (style.glyphs == null) style.glyphs = labels.style.glyphs;
+  if (style.sprite == null) style.sprite = labels.style.sprite;
+  if (style.sky == null) style.sky = labels.style.sky;
+
+  Object.assign(style.sources, labels.style.sources);
+  style.layers = style.layers.concat(labels.style.layers);
+}
+
+/**
+ * Ensure that a "LINZ-Terrain" layer is force added into the output styleJSON source
+ */
 async function ensureTerrain(
   req: LambdaHttpRequest<StyleGet>,
   tileMatrix: TileMatrixSet,
@@ -98,28 +137,33 @@ async function ensureTerrain(
   style: StyleJson,
 ): Promise<void> {
   const config = await ConfigLoader.load(req);
-  const terrain = await config.TileSet.get('ts_elevation');
-  if (terrain) {
-    const configLocation = ConfigLoader.extract(req);
-    const elevationQuery = toQueryString({ config: configLocation, api: apiKey, pipeline: 'terrain-rgb' });
-    style.sources['LINZ-Terrain'] = {
-      type: 'raster-dem',
-      tileSize: 256,
-      maxzoom: 18,
-      tiles: [convertRelativeUrl(`/v1/tiles/elevation/${tileMatrix.identifier}/{z}/{x}/{y}.png${elevationQuery}`)],
-    };
-  }
+  const terrain = await config.TileSet.get('elevation');
+  if (terrain == null) return;
+  const configLocation = ConfigLoader.extract(req);
+  const elevationQuery = toQueryString({ config: configLocation, api: apiKey, pipeline: 'terrain-rgb' });
+  style.sources['LINZ-Terrain'] = {
+    type: 'raster-dem',
+    tileSize: 256,
+    maxzoom: 18, // TODO: this should be configurable based on the elevation layer
+    tiles: [convertRelativeUrl(`/v1/tiles/elevation/${tileMatrix.identifier}/{z}/{x}/{y}.png${elevationQuery}`)],
+  };
 }
 
-export async function tileSetToStyle(
+/**
+ * Generate a StyleJSON from a tileset
+ * @returns
+ */
+export function tileSetToStyle(
   req: LambdaHttpRequest<StyleGet>,
   tileSet: ConfigTileSetRaster,
   tileMatrix: TileMatrixSet,
   apiKey: string,
-  terrain?: string,
-): Promise<LambdaHttpResponse> {
+): StyleJson {
+  // If the style has outputs defined it has a different process for generating the stylejson
+  if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey);
+
   const [tileFormat] = Validate.getRequestedFormats(req) ?? ['webp'];
-  if (tileFormat == null) return new LambdaHttpResponse(400, 'Invalid image format');
+  if (tileFormat == null) throw new LambdaHttpResponse(400, 'Invalid image format');
 
   const pipeline = Validate.pipeline(tileSet, tileFormat, req.query.get('pipeline'));
   const pipelineName = pipeline?.name === 'rgba' ? undefined : pipeline?.name;
@@ -132,155 +176,134 @@ export async function tileSetToStyle(
     `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`;
 
   const styleId = `basemaps-${tileSet.name}`;
-  const style: StyleJson = {
+  return {
     id: ConfigId.prefix(ConfigPrefix.Style, tileSet.name),
     name: tileSet.name,
     version: 8,
     sources: { [styleId]: { type: 'raster', tiles: [tileUrl], tileSize: 256 } },
     layers: [{ id: styleId, type: 'raster', source: styleId }],
   };
-
-  // Ensure elevation for individual tilesets
-  await ensureTerrain(req, tileMatrix, apiKey, style);
-
-  // Add terrain in style
-  if (terrain) setStyleTerrain(style, terrain, tileMatrix);
-
-  const data = Buffer.from(JSON.stringify(style));
-
-  const cacheKey = Etag.key(data);
-  if (Etag.isNotModified(req, cacheKey)) return NotModified();
-
-  const response = new LambdaHttpResponse(200, 'ok');
-  response.header(HttpHeader.ETag, cacheKey);
-  response.header(HttpHeader.CacheControl, 'no-store');
-  response.buffer(data, 'application/json');
-  req.set('bytes', data.byteLength);
-  return response;
 }
 
-export async function tileSetOutputToStyle(
+/**
+ * generate a style from a tile set which has a output
+ */
+export function tileSetOutputToStyle(
   req: LambdaHttpRequest<StyleGet>,
   tileSet: ConfigTileSetRaster,
   tileMatrix: TileMatrixSet,
   apiKey: string,
-  terrain?: string,
-): Promise<LambdaHttpResponse> {
+): StyleJson {
+  if (tileSet.outputs == null) throw new LambdaHttpResponse(400, 'TileSet does not have any outputs to generate');
   const configLocation = ConfigLoader.extract(req);
-  const query = toQueryString({ config: configLocation, api: apiKey });
 
   const styleId = `basemaps-${tileSet.name}`;
   const sources: Sources = {};
   const layers: Layer[] = [];
 
-  if (tileSet.outputs) {
-    //for loop output.
-    for (const output of tileSet.outputs) {
-      const format = output.format?.[0] ?? 'webp';
-      const urlBase = Env.get(Env.PublicUrlBase) ?? '';
-      const tileUrl = `${urlBase}/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${format}${query}`;
-
-      if (output.name === 'terrain-rgb') {
-        // Add both raster source and dem raster source for terrain-rgb output
-        sources[`${styleId}-${output.name}`] = {
-          type: 'raster',
-          tiles: [tileUrl + `&pipeline=${output.name}`],
-          tileSize: 256,
-        };
-        sources[`${styleId}-${output.name}-dem`] = {
-          type: 'raster-dem',
-          tiles: [tileUrl + `&pipeline=${output.name}`],
-          tileSize: 256,
-        };
-      } else {
-        // Add raster source other outputs
-        sources[`${styleId}-${output.name}`] = {
-          type: 'raster',
-          tiles: [tileUrl + `&pipeline=${output.name}`],
-          tileSize: 256,
-        };
-      }
+  for (const output of tileSet.outputs) {
+    const format = output.format?.[0] ?? 'webp';
+    const urlBase = Env.get(Env.PublicUrlBase) ?? '';
+    const query = toQueryString({ config: configLocation, api: apiKey, pipeline: output.name });
+
+    const tileUrl = `${urlBase}/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${format}${query}`;
+
+    if (output.name === 'terrain-rgb') {
+      // Add both raster source and dem raster source for terrain-rgb output
+      sources[`${styleId}-${output.name}`] = { type: 'raster', tiles: [tileUrl], tileSize: 256 };
+      sources[`${styleId}-${output.name}-dem`] = { type: 'raster-dem', tiles: [tileUrl], tileSize: 256 };
+    } else {
+      // Add raster source other outputs
+      sources[`${styleId}-${output.name}`] = { type: 'raster', tiles: [tileUrl], tileSize: 256 };
     }
   }
 
   // Add first raster source as default layer
   for (const source of Object.keys(sources)) {
     if (sources[source].type === 'raster') {
-      layers.push({
-        id: styleId,
-        type: 'raster',
-        source,
-      });
+      layers.push({ id: styleId, type: 'raster', source });
       break;
     }
   }
 
-  const style: StyleJson = {
+  return {
     id: ConfigId.prefix(ConfigPrefix.Style, tileSet.name),
     name: tileSet.name,
     version: 8,
     sources,
     layers,
   };
+}
 
-  // Ensure elevation for style json config
-  await ensureTerrain(req, tileMatrix, apiKey, style);
-
-  // Add terrain in style
-  if (terrain) setStyleTerrain(style, terrain, tileMatrix);
-
-  const data = Buffer.from(JSON.stringify(style));
-
-  const cacheKey = Etag.key(data);
-  if (Etag.isNotModified(req, cacheKey)) return Promise.resolve(NotModified());
+async function generateStyleFromTileSet(
+  req: LambdaHttpRequest<StyleGet>,
+  config: BasemapsConfigProvider,
+  tileSetName: string,
+  tileMatrix: TileMatrixSet,
+  apiKey: string,
+): Promise<StyleJson> {
+  const tileSet = await config.TileSet.get(tileSetName);
+  if (tileSet == null) throw NotFound();
+  if (tileSet.type !== TileSetType.Raster) {
+    throw new LambdaHttpResponse(400, 'Only raster tile sets can generate style JSON');
+  }
+  if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey);
+  else return tileSetToStyle(req, tileSet, tileMatrix, apiKey);
+}
 
-  const response = new LambdaHttpResponse(200, 'ok');
-  response.header(HttpHeader.ETag, cacheKey);
-  response.header(HttpHeader.CacheControl, 'no-store');
-  response.buffer(data, 'application/json');
-  req.set('bytes', data.byteLength);
-  return Promise.resolve(response);
+export interface StyleGet {
+  Params: {
+    styleName: string;
+  };
 }
 
 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()));
+
   const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
   if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
+
+  // Remove layers from the output style json
+  const excludeLayers = req.query.getAll('exclude');
+  const excluded = new Set(excludeLayers.map((l) => l.toLowerCase()));
+  if (excluded.size > 0) req.set('excludedLayers', [...excluded]);
+
+  /**
+   * Configuration options used for the landing page:
+   * "terrain" - force add a terrain layer
+   * "labels" - merge the labels style with the current style
+   *
+   * TODO: (2024-08) this is not a very scalable way of configuring styles, it would be good to provide a styleJSON merge
+   */
   const terrain = req.query.get('terrain') ?? undefined;
+  const labels = Boolean(req.query.get('labels') ?? false);
+  req.set('styleConfig', { terrain, labels });
 
   // Get style Config from db
   const config = await ConfigLoader.load(req);
-  const dbId = config.Style.id(styleName);
-  const styleConfig = await config.Style.get(dbId);
-  if (styleConfig == null) {
-    // Were we given a tileset name instead, generated
-    const tileSet = await config.TileSet.get(config.TileSet.id(styleName));
-    if (tileSet == null) return NotFound();
-    if (tileSet.type !== TileSetType.Raster) return NotFound();
-    if (tileSet.outputs) return await tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey, terrain);
-    else return await tileSetToStyle(req, tileSet, tileMatrix, apiKey, terrain);
-  }
-
-  // Prepare sources and add linz source
-  const style = convertStyleJson(
-    styleConfig.style,
-    tileMatrix,
-    apiKey,
-    ConfigLoader.extract(req),
-    styleConfig.style.layers.filter((f) => !excluded.has(f.id.toLowerCase())),
-  );
+  const styleConfig = await config.Style.get(styleName);
+  const styleSource =
+    styleConfig?.style ?? (await generateStyleFromTileSet(req, config, styleName, tileMatrix, apiKey));
 
+  const targetStyle = structuredClone(styleSource);
   // Ensure elevation for style json config
   // TODO: We should remove this after adding terrain source into style configs. PR-916
-  await ensureTerrain(req, tileMatrix, apiKey, style);
+  await ensureTerrain(req, tileMatrix, apiKey, targetStyle);
 
   // Add terrain in style
-  if (terrain) setStyleTerrain(style, terrain, tileMatrix);
+  if (terrain) setStyleTerrain(targetStyle, terrain, tileMatrix);
+  if (labels) await setStyleLabels(req, targetStyle);
+
+  // convert sources to full URLS and convert style between projections
+  setStyleUrls(targetStyle, tileMatrix, apiKey, ConfigLoader.extract(req));
+
+  if (tileMatrix.identifier === Nztm2000QuadTms.identifier) convertStyleToNztmStyle(targetStyle, false);
+
+  // filter out any excluded layers
+  if (excluded.size > 0) targetStyle.layers = targetStyle.layers.filter((f) => !excluded.has(f.id.toLowerCase()));
 
-  const data = Buffer.from(JSON.stringify(style));
+  const data = Buffer.from(JSON.stringify(targetStyle));
 
   const cacheKey = Etag.key(data);
   if (Etag.isNotModified(req, cacheKey)) return NotModified();

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

@@ -109,7 +109,6 @@ export const TileXyzRaster = {
     }
 
     // Remove with typescript >=5.5.0
-
     return (await Promise.all(toLoad)).filter((f) => f != null);
   },
 

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

@@ -1,5 +1,4 @@
 import { ConfigTileSetVector } from '@basemaps/config';
-import { GoogleTms } from '@basemaps/geo';
 import { fsa } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 
@@ -13,12 +12,17 @@ export const tileXyzVector = {
   /** Serve a MVT vector tile */
   async tile(req: LambdaHttpRequest, tileSet: ConfigTileSetVector, xyz: TileXyz): Promise<LambdaHttpResponse> {
     if (xyz.tileType !== 'pbf') return NotFound();
-    if (xyz.tileMatrix.identifier !== GoogleTms.identifier) return NotFound();
 
-    if (tileSet.layers.length > 1) return new LambdaHttpResponse(500, 'Too many layers in tileset');
-    const [layer] = tileSet.layers;
-    const layerId = layer[3857];
-    if (layerId == null) return new LambdaHttpResponse(500, 'Layer url not found from tileset Config');
+    // Vector tiles cannot be merged (yet!)
+    if (tileSet.layers.length > 1) {
+      return new LambdaHttpResponse(500, `Too many layers in vector tileset ${tileSet.layers.length}`);
+    }
+
+    const epsgCode = xyz.tileMatrix.projection.code;
+    const layerId = tileSet.layers[0][epsgCode];
+    if (layerId == null) {
+      return new LambdaHttpResponse(404, `No data found for tile matrix: ${xyz.tileMatrix.identifier}`);
+    }
 
     // Flip Y coordinate because MBTiles files are TMS.
     const y = (1 << xyz.tile.z) - 1 - xyz.tile.y;

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

@@ -0,0 +1,36 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { fsa, FsMemory } from '@chunkd/fs';
+
+import { SourceCache } from '../source.cache.js';
+
+describe('CoSourceCache', () => {
+  it('should not exit if a promise rejection happens for tiff', async () => {
+    const cache = new SourceCache(5);
+
+    const mem = new FsMemory();
+    const tiffLoc = new URL('memory://foo/bar.tiff');
+    await mem.write(tiffLoc, Buffer.from('ABC123'));
+    fsa.register('memory://', mem);
+
+    let failCount = 0;
+    await cache.getCog(tiffLoc).catch(() => failCount++);
+    assert.equal(cache.cache.currentSize, 0);
+    assert.equal(failCount, 1);
+  });
+
+  it('should not exit if a promise rejection happens for tar', async () => {
+    const cache = new SourceCache(5);
+
+    const mem = new FsMemory();
+    const tiffLoc = new URL('memory://foo/bar.tar');
+    await mem.write(tiffLoc, Buffer.from('ABC123'));
+    fsa.register('memory://', mem);
+
+    let failCount = 0;
+    await cache.getCotar(tiffLoc).catch(() => failCount++);
+    assert.equal(cache.cache.currentSize, 0);
+    assert.equal(failCount, 1);
+  });
+});

package/src/util/__test__/nztm.style.test.ts

@@ -0,0 +1,100 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { StyleJson } from '@basemaps/config';
+
+import { convertStyleToNztmStyle } from '../nztm.style.js';
+
+describe('NZTM2000QuadStyle', () => {
+  const fakeStyle: StyleJson = {
+    version: 8,
+    id: 'test',
+    name: 'topographic',
+    sources: {},
+    layers: [],
+    glyphs: '/glyphs',
+    sprite: '/sprite',
+    metadata: { id: 'test' },
+  };
+
+  it('should not modify the source style', () => {
+    const baseStyle = {
+      ...fakeStyle,
+      terrain: { exaggeration: 1.1, source: 'abc' },
+    };
+
+    convertStyleToNztmStyle(baseStyle);
+    assert.equal(baseStyle.terrain?.exaggeration, 1.1);
+
+    convertStyleToNztmStyle(baseStyle, false);
+    assert.equal(baseStyle.terrain?.exaggeration, 4.4);
+  });
+
+  it('should convert min/maxzooms', () => {
+    const newStyle = convertStyleToNztmStyle({
+      ...fakeStyle,
+      layers: [{ minzoom: 5, maxzoom: 10, id: 'something', type: '' }],
+    });
+
+    assert.deepEqual(newStyle.layers[0], { minzoom: 3, maxzoom: 8, id: 'something', type: '' });
+  });
+
+  it('should offset terrain', () => {
+    const newStyle = convertStyleToNztmStyle({
+      ...fakeStyle,
+      terrain: { exaggeration: 1.1, source: 'abc' },
+    });
+
+    assert.deepEqual(newStyle.terrain, { exaggeration: 4.4, source: 'abc' });
+  });
+
+  it('should convert stops inside of paint and layout', () => {
+    const newStyle = convertStyleToNztmStyle({
+      ...fakeStyle,
+      layers: [
+        {
+          layout: {
+            'line-width': {
+              stops: [
+                [16, 0.75],
+                [24, 1.5],
+              ],
+            },
+          },
+
+          paint: {
+            'line-width': {
+              stops: [
+                [16, 0.75],
+                [24, 1.5],
+              ],
+            },
+          },
+          id: 'something',
+          type: '',
+        },
+      ],
+    });
+
+    assert.deepEqual(newStyle.layers[0], {
+      layout: {
+        'line-width': {
+          stops: [
+            [14, 0.75],
+            [22, 1.5],
+          ],
+        },
+      },
+      paint: {
+        'line-width': {
+          stops: [
+            [14, 0.75],
+            [22, 1.5],
+          ],
+        },
+      },
+      id: 'something',
+      type: '',
+    });
+  });
+});

package/src/util/nztm.style.ts

@@ -0,0 +1,44 @@
+import { StyleJson } from '@basemaps/config';
+
+/**
+ * limited checking to cast a unknown paint/layout into one with stops
+ */
+function hasStops(x: unknown): x is { stops: [number, unknown][] } {
+  if (x == null) return false;
+  return Array.isArray((x as { stops: unknown })['stops']);
+}
+
+/**
+ * Convert a style json from a WebMercatorQuad style into a NZTM2000Quad style,
+ * This creates a clone of the source style and does not modify the source
+ *
+ * NZTM2000Quad is offset from WebMercatorQuad by two zoom levels
+ *
+ * @param inputStyle style to convert
+ * @param clone Should the input style be cloned or modified
+ * @returns a new style converted into NZTM2000Quad zooms
+ */
+export function convertStyleToNztmStyle(inputStyle: StyleJson, clone: boolean = true): StyleJson {
+  const style = clone ? structuredClone(inputStyle) : inputStyle;
+
+  for (const layer of style.layers) {
+    // Adjust the min/max zoom
+    if (layer.minzoom) layer.minzoom = Math.max(0, layer.minzoom - 2);
+    if (layer.maxzoom) layer.maxzoom = Math.max(0, layer.maxzoom - 2);
+
+    // Check all the pain and layout for "stops" then adjust the stops by two
+    const stylesToCheck = [layer.paint, layer.layout];
+    for (const obj of stylesToCheck) {
+      if (obj == null) continue;
+      for (const val of Object.values(obj)) {
+        if (!hasStops(val)) continue;
+        for (const stop of val.stops) stop[0] = Math.max(0, stop[0] - 2);
+      }
+    }
+  }
+
+  /** Based on {@link DefaultExaggeration} offsetting by 2 two levels changes the exaggeration needed by approx 4x */
+  if (style.terrain) style.terrain.exaggeration = style.terrain.exaggeration * 4;
+
+  return style;
+}