@basemaps/landing 6.27.0

package/build/index.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { Component, Fragment, render } from 'preact';
+import { Footer } from './components/layout.footer.js';
+import { Header } from './components/layout.header.js';
+import { Basemaps } from './components/map.js';
+import { WindowUrl } from './url.js';
+import { isWebpSupported } from './webp.js';
+class Page extends Component {
+    render() {
+        return (_jsxs(Fragment, { children: [_jsx(Header, {}), _jsx(Basemaps, {}), _jsx(Footer, {})] }));
+    }
+}
+document.addEventListener('DOMContentLoaded', async () => {
+    const canUseWebp = await isWebpSupported();
+    if (await canUseWebp)
+        WindowUrl.ImageFormat = 'webp';
+    const mainEl = document.getElementById('main');
+    if (mainEl == null)
+        throw new Error('Missing #main');
+    render(_jsx(Page, {}), mainEl);
+});

package/build/split.d.ts

@@ -0,0 +1,11 @@
+export declare enum SplitTreatment {
+    LayerSwitcherButton = "layer-switcher-button"
+}
+export declare const SplitIo: {
+    client: Promise<import("@splitsoftware/splitio/types/splitio").IClient | null> | null;
+    _client: import("@splitsoftware/splitio/types/splitio").IClient | null;
+    getClient(): Promise<SplitIO.IClient | null>;
+    getClientSync(): SplitIO.IClient | null;
+    getTreatment(key: SplitTreatment): string | null;
+};
+//# sourceMappingURL=split.d.ts.map

package/build/split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.d.ts","sourceRoot":"","sources":["../src/split.ts"],"names":[],"mappings":"AAGA,oBAAY,cAAc;IACxB,mBAAmB,0BAA0B;CAC9C;AAED,eAAO,MAAM,OAAO;;;iBAIL,QAAQ,QAAQ,OAAO,GAAG,IAAI,CAAC;qBAwB3B,QAAQ,OAAO,GAAG,IAAI;sBAMrB,cAAc,GAAG,MAAM,GAAG,IAAI;CAKjD,CAAC"}

package/build/split.js

@@ -0,0 +1,45 @@
+import { SplitFactory } from '@splitsoftware/splitio';
+import { Config } from './config';
+export var SplitTreatment;
+(function (SplitTreatment) {
+    SplitTreatment["LayerSwitcherButton"] = "layer-switcher-button";
+})(SplitTreatment || (SplitTreatment = {}));
+export const SplitIo = {
+    client: null,
+    _client: null,
+    getClient() {
+        if (this.client != null)
+            return this.client;
+        if (Config.SplitApiKey === '') {
+            this.client = Promise.resolve(null);
+            return this.client;
+        }
+        const factory = SplitFactory({
+            core: {
+                authorizationKey: Config.SplitApiKey,
+                key: Config.ApiKey,
+            },
+        });
+        this.client = new Promise((resolve) => {
+            const client = factory.client();
+            client.on(client.Event.SDK_READY, () => {
+                SplitIo._client = client;
+                resolve(client);
+            });
+        });
+        return this.client;
+    },
+    getClientSync() {
+        if (this._client)
+            return this._client;
+        this.getClient();
+        return null;
+    },
+    getTreatment(key) {
+        const client = SplitIo.getClientSync();
+        if (client == null)
+            return null;
+        return client.getTreatment(key);
+    },
+};
+window.splitIo = SplitIo;

package/build/tile.matrix.d.ts

@@ -0,0 +1,23 @@
+import { TileMatrixSet } from '@basemaps/geo';
+import { Style } from 'maplibre-gl';
+import { MapLocation } from './url.js';
+export declare class TileGrid {
+    tileMatrix: TileMatrixSet;
+    extraZoomLevels: number;
+    constructor(tileMatrix: TileMatrixSet, extraZoomLevels?: number);
+    getStyle(layerId: string, style?: string | null): Style | string;
+}
+export declare function getTileGrid(id: string): TileGrid;
+/**
+ * Transform the location coordinate between maplibre and another tileMatrix.
+ *
+ * One of the tileMatrix or targetTileMatrix has to be GoogleTms
+ */
+export declare function locationTransform(location: MapLocation, tileMatrix: TileMatrixSet, targetTileMatrix: TileMatrixSet): MapLocation;
+/**
+ * Project a geojson object into the target tile matrix with use with maplibre
+ *
+ * *Warning* This will overwrite the existing object
+ */
+export declare function projectGeoJson(g: GeoJSON.FeatureCollection, targetTileMatrix: TileMatrixSet): void;
+//# sourceMappingURL=tile.matrix.d.ts.map

package/build/tile.matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile.matrix.d.ts","sourceRoot":"","sources":["../src/tile.matrix.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,aAAa,EAAE,MAAM,eAAe,CAAC;AAEvF,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,WAAW,EAA4B,MAAM,UAAU,CAAC;AAEjE,qBAAa,QAAQ;IACnB,UAAU,EAAE,aAAa,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;gBACZ,UAAU,EAAE,aAAa,EAAE,eAAe,SAAI;IAK1D,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,MAAM;CAgBjE;AAQD,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,CAKhD;AAKD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,aAAa,EACzB,gBAAgB,EAAE,aAAa,GAC9B,WAAW,CAgBb;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,CAAC,iBAAiB,EAAE,gBAAgB,EAAE,aAAa,GAAG,IAAI,CAgBlG"}

package/build/tile.matrix.js

@@ -0,0 +1,77 @@
+import { GoogleTms, Nztm2000QuadTms, Nztm2000Tms } from '@basemaps/geo';
+import { Projection } from '@basemaps/shared/build/proj/projection.js';
+import { WindowUrl } from './url.js';
+export class TileGrid {
+    constructor(tileMatrix, extraZoomLevels = 0) {
+        this.tileMatrix = tileMatrix;
+        this.extraZoomLevels = extraZoomLevels;
+    }
+    getStyle(layerId, style) {
+        if (layerId === 'topographic') {
+            return WindowUrl.toTileUrl("style" /* TileVectorStyle */, this.tileMatrix, layerId, style);
+        }
+        return {
+            version: 8,
+            sources: {
+                basemaps: {
+                    type: 'raster',
+                    tiles: [WindowUrl.toTileUrl("raster" /* TileRaster */, this.tileMatrix, layerId)],
+                    tileSize: 256,
+                },
+            },
+            layers: [{ id: 'LINZ Raster Basemaps', type: 'raster', source: 'basemaps' }],
+        };
+    }
+}
+const Nztm2000TileGrid = new TileGrid(Nztm2000Tms, 2);
+const Nztm2000QuadTileGrid = new TileGrid(Nztm2000QuadTms);
+const GoogleTileGrid = new TileGrid(GoogleTms);
+const Grids = [Nztm2000TileGrid, Nztm2000QuadTileGrid, GoogleTileGrid];
+export function getTileGrid(id) {
+    for (const g of Grids) {
+        if (id === g.tileMatrix.identifier)
+            return g;
+    }
+    return GoogleTileGrid;
+}
+function isGoogle(tms) {
+    return tms.identifier === GoogleTms.identifier;
+}
+/**
+ * Transform the location coordinate between maplibre and another tileMatrix.
+ *
+ * One of the tileMatrix or targetTileMatrix has to be GoogleTms
+ */
+export function locationTransform(location, tileMatrix, targetTileMatrix) {
+    if (tileMatrix.identifier === targetTileMatrix.identifier)
+        return location;
+    if (!isGoogle(tileMatrix) && !isGoogle(targetTileMatrix)) {
+        throw new Error('Either tileMatrix or targetTileMatrix must be GoogleTms');
+    }
+    // Transform the source to the the tile it would be rendered on
+    const coords = Projection.get(tileMatrix).fromWgs84([location.lon, location.lat]);
+    const point = tileMatrix.sourceToPixels(coords[0], coords[1], Math.round(location.zoom));
+    const tile = { x: point.x / tileMatrix.tileSize, y: point.y / tileMatrix.tileSize, z: Math.round(location.zoom) };
+    // Translate the tile location into the target tile matrix
+    const source = targetTileMatrix.tileToSource(tile);
+    const lonLat = Projection.get(targetTileMatrix).toWgs84([source.x, source.y]);
+    return { lon: Math.round(lonLat[0] * 1e8) / 1e8, lat: Math.round(lonLat[1] * 1e8) / 1e8, zoom: location.zoom };
+}
+/**
+ * Project a geojson object into the target tile matrix with use with maplibre
+ *
+ * *Warning* This will overwrite the existing object
+ */
+export function projectGeoJson(g, targetTileMatrix) {
+    for (const f of g.features) {
+        if (f.geometry.type !== 'Polygon')
+            throw new Error('Only polygons supported');
+        for (const poly of f.geometry.coordinates) {
+            for (const coord of poly) {
+                const output = locationTransform({ lat: coord[1], lon: coord[0], zoom: targetTileMatrix.maxZoom }, targetTileMatrix, GoogleTms);
+                coord[0] = output.lon;
+                coord[1] = output.lat;
+            }
+        }
+    }
+}

package/build/url.d.ts

@@ -0,0 +1,37 @@
+import { TileMatrixSet } from '@basemaps/geo';
+export interface LonLat {
+    lat: number;
+    lon: number;
+}
+export interface MapLocation extends LonLat {
+    zoom: number;
+}
+export declare const enum MapOptionType {
+    TileRaster = "raster",
+    TileVectorStyle = "style",
+    TileVectorXyz = "vector-xyz",
+    TileWmts = "tile-wmts",
+    Wmts = "wmts",
+    Attribution = "attribution"
+}
+export declare const WindowUrl: {
+    ImageFormat: string;
+    /**
+     * Encode a location into the window.hash
+     * Google uses ${lat},${lon},z${zoom}
+     * TODO do we want to follow this
+     */
+    toHash(loc: MapLocation): string;
+    /**
+     * Support parsing of zooms with `z14` or `14z`
+     * @param zoom string to parse zoom from
+     */
+    parseZoom(zoom: string | null): number;
+    /** Parse a location from window.hash if it exists */
+    fromHash(str: string): Partial<MapLocation>;
+    baseUrl(): string;
+    toBaseWmts(): string;
+    toImageryUrl(layerId: string, imageryType: string): string;
+    toTileUrl(urlType: MapOptionType, tileMatrix: TileMatrixSet, layerId: string, style?: string | null | undefined): string;
+};
+//# sourceMappingURL=url.d.ts.map

package/build/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../src/url.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAkB,MAAM,eAAe,CAAC;AAG9D,MAAM,WAAW,MAAM;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAY,SAAQ,MAAM;IACzC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,0BAAkB,aAAa;IAC7B,UAAU,WAAW;IACrB,eAAe,UAAU;IACzB,aAAa,eAAe;IAC5B,QAAQ,cAAc;IACtB,IAAI,SAAS;IACb,WAAW,gBAAgB;CAC5B;AAED,eAAO,MAAM,SAAS;;IAGpB;;;;OAIG;gBACS,WAAW,GAAG,MAAM;IAIhC;;;OAGG;oBACa,MAAM,GAAG,IAAI,GAAG,MAAM;IAOtC,qDAAqD;kBACvC,MAAM,GAAG,QAAQ,WAAW,CAAC;eAmBhC,MAAM;kBAOH,MAAM;0BAKE,MAAM,eAAe,MAAM,GAAG,MAAM;uBAIvC,aAAa,cAAc,aAAa,WAAW,MAAM,sCAA0B,MAAM;CAkB7G,CAAC"}

package/build/url.js

@@ -0,0 +1,78 @@
+import { TileMatrixSets } from '@basemaps/geo';
+import { Config } from './config.js';
+export const WindowUrl = {
+    ImageFormat: 'png',
+    /**
+     * Encode a location into the window.hash
+     * Google uses ${lat},${lon},z${zoom}
+     * TODO do we want to follow this
+     */
+    toHash(loc) {
+        return `#@${loc.lat.toFixed(7)},${loc.lon.toFixed(7)},z${loc.zoom}`;
+    },
+    /**
+     * Support parsing of zooms with `z14` or `14z`
+     * @param zoom string to parse zoom from
+     */
+    parseZoom(zoom) {
+        if (zoom == null || zoom === '')
+            return NaN;
+        if (zoom.startsWith('z'))
+            return parseFloat(zoom.slice(1));
+        if (zoom.endsWith('z'))
+            return parseFloat(zoom);
+        return NaN;
+    },
+    /** Parse a location from window.hash if it exists */
+    fromHash(str) {
+        const output = {};
+        const hash = str.replace('#@', '');
+        const [latS, lonS, zoomS] = hash.split(',');
+        const lat = parseFloat(latS);
+        const lon = parseFloat(lonS);
+        if (!isNaN(lat) && !isNaN(lon)) {
+            output.lat = lat;
+            output.lon = lon;
+        }
+        const newZoom = WindowUrl.parseZoom(zoomS);
+        if (!isNaN(newZoom)) {
+            output.zoom = newZoom;
+        }
+        return output;
+    },
+    baseUrl() {
+        const baseUrl = Config.BaseUrl;
+        if (baseUrl === '')
+            return window.location.origin;
+        if (!baseUrl.startsWith('http'))
+            throw new Error('BaseURL must start with http(s)://');
+        return baseUrl;
+    },
+    toBaseWmts() {
+        const api = Config.ApiKey == null || Config.ApiKey === '' ? '' : `?api=${Config.ApiKey}`;
+        return `${this.baseUrl()}/v1/tiles/WMTSCapabilities.xml${api}`;
+    },
+    toImageryUrl(layerId, imageryType) {
+        return `${this.baseUrl()}/v1/imagery/${layerId}/${imageryType}`;
+    },
+    toTileUrl(urlType, tileMatrix, layerId, style) {
+        const api = Config.ApiKey == null || Config.ApiKey === '' ? '' : `?api=${Config.ApiKey}`;
+        const isDefaultTileMatrix = TileMatrixSets.get(tileMatrix.projection).identifier === tileMatrix.identifier;
+        const projectionPath = isDefaultTileMatrix ? tileMatrix.projection.toEpsgString() : tileMatrix.identifier;
+        const baseTileUrl = `${this.baseUrl()}/v1/tiles/${layerId}/${projectionPath}`;
+        if (urlType === "raster" /* TileRaster */)
+            return `${baseTileUrl}/{z}/{x}/{y}.${WindowUrl.ImageFormat}${api}`;
+        if (urlType === "vector-xyz" /* TileVectorXyz */)
+            return `${baseTileUrl}/{z}/{x}/{y}.pbf${api}`;
+        if (urlType === "style" /* TileVectorStyle */)
+            return `${baseTileUrl}/style/${style}.json${api}`;
+        if (urlType === "wmts" /* Wmts */)
+            return `${baseTileUrl}/WMTSCapabilities.xml${api}`;
+        if (urlType === "attribution" /* Attribution */)
+            return `${baseTileUrl}/attribution.json${api}`;
+        if (urlType === "tile-wmts" /* TileWmts */) {
+            return `${baseTileUrl}/{TileMatrix}/{TileCol}/{TileRow}.${WindowUrl.ImageFormat}${api}`;
+        }
+        throw new Error('Unknown url type: ' + urlType);
+    },
+};

package/build/webp.d.ts

@@ -0,0 +1,3 @@
+/** Is WebP able to be rendered in this environment */
+export declare function isWebpSupported(): Promise<boolean>;
+//# sourceMappingURL=webp.d.ts.map

package/build/webp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webp.d.ts","sourceRoot":"","sources":["../src/webp.ts"],"names":[],"mappings":"AA6BA,sDAAsD;AACtD,wBAAgB,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC,CAKlD"}

package/build/webp.js

@@ -0,0 +1,32 @@
+const WebpImage = `data:image/webp;base64,UklGRiQAAABXRUJQVlA4IBgAAAAwAQCdASoBAAEAAwA0JaQAA3AA/vuUAAA=`;
+// Source https://stackoverflow.com/questions/5573096/detecting-webp-support
+function isCanvasWebpSupported() {
+    const elem = document.createElement('canvas');
+    if (!!(elem.getContext && elem.getContext('2d'))) {
+        // was able or not to get WebP representation
+        return elem.toDataURL('image/webp').indexOf('data:image/webp') === 0;
+    }
+    // very old browser like IE 8, canvas not supported
+    return false;
+}
+/**
+ * Is this runtime able to support webp
+ */
+function isWebpImageSupported() {
+    // Some browsers (firefox) support rendering webp but not creating with canvas
+    const img = new Image();
+    const promise = new Promise((resolve) => {
+        img.onload = () => resolve(true);
+        img.onerror = () => resolve(false);
+    });
+    img.src = WebpImage;
+    return promise;
+}
+/** Is WebP able to be rendered in this environment */
+export function isWebpSupported() {
+    return new Promise((resolve) => {
+        if (isCanvasWebpSupported())
+            return resolve(true);
+        isWebpImageSupported().then(resolve);
+    });
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@basemaps/landing",
+  "version": "6.27.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/linz/basemaps.git",
+    "directory": "packages/landing"
+  },
+  "author": {
+    "name": "Land Information New Zealand",
+    "url": "https://linz.govt.nz",
+    "organization": true
+  },
+  "type": "module",
+  "engines": {
+    "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+  },
+  "license": "MIT",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "scripts": {
+    "test": "ospec --globs 'build/**/*.test.js'",
+    "start": "TILE_HOST=${TILE_HOST:-https://dev.basemaps.linz.govt.nz} nodemon ../../scripts/bundle.js -e 'ts html css' -i 'dist/*' -- package.json",
+    "bundle": "../../scripts/bundle.js package.json",
+    "deploy:deploy": "node scripts/deploy.js"
+  },
+  "browserslist": [
+    "last 2 Chrome versions"
+  ],
+  "devDependencies": {
+    "@basemaps/attribution": "^6.26.0",
+    "@basemaps/geo": "^6.26.0",
+    "@basemaps/infra": "^6.27.0",
+    "@basemaps/shared": "^6.27.0",
+    "@linzjs/lui": "^10.11.3",
+    "@servie/events": "^3.0.0",
+    "@splitsoftware/splitio": "^10.16.1",
+    "@types/geojson": "^7946.0.7",
+    "@types/proj4": "^2.5.0",
+    "maplibre-gl": "^1.14.1-rc.2",
+    "preact": "^10.5.15",
+    "proj4": "^2.6.2",
+    "ulid": "^2.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "build"
+  ],
+  "bundle": [
+    {
+      "entry": "../../node_modules/@linzjs/lui/dist/assets/images/nz-govt-logo-rev.svg",
+      "outfile": "dist/assets/logo-nz-govt.svg"
+    },
+    {
+      "entry": "../../node_modules/@linzjs/lui/dist/assets/images/linz-logo-col-n-white-txt.svg",
+      "outfile": "dist/assets/logo-linz.svg"
+    },
+    {
+      "entry": "../../node_modules/@linzjs/lui/dist/assets/fonts",
+      "outfile": "dist/assets/fonts"
+    },
+    {
+      "entry": "static",
+      "outfile": "dist"
+    },
+    {
+      "entry": "../attribution/src/attribution.index.ts",
+      "outfile": "dist/lib/attribution.js",
+      "platform": "browser"
+    },
+    {
+      "entry": "static/examples/index.openlayers.attribution.wmts.3857.html",
+      "outdir": "dist/examples",
+      "subresourceHash": {
+        "$ATTR_FILE": "../lib/attribution.js"
+      }
+    },
+    {
+      "entry": "src/index.tsx",
+      "env": {
+        "API_KEY": null,
+        "GOOGLE_ANALYTICS": null,
+        "TILE_HOST": null,
+        "SPLIT_IO_KEY": null
+      },
+      "platform": "browser"
+    },
+    {
+      "entry": "static/index.css",
+      "external": [
+        "@linzjs/lui/dist/lui.css",
+        "maplibre-gl/dist/maplibre-gl.css"
+      ]
+    },
+    {
+      "entry": "static/index.html",
+      "subresourceHash": {
+        "$JS_FILE": "index.js",
+        "$CSS_FILE": "index.css"
+      }
+    }
+  ],
+  "gitHead": "c6aa61c20503cbc7f04cf31927f4e2b95aed34cb"
+}