@basemaps/lambda-tiler 7.9.0 → 7.10.0

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;
+}