@basemaps/lambda-tiler 6.15.0

package/build/routes/api.js

@@ -0,0 +1,16 @@
+import { LambdaHttpResponse, HttpHeader } from '@linzjs/lambda';
+const OkResponse = new LambdaHttpResponse(200, 'ok');
+OkResponse.header(HttpHeader.CacheControl, 'no-store');
+export async function Health() {
+    return OkResponse;
+}
+export async function Ping() {
+    return OkResponse;
+}
+export async function Version() {
+    var _a;
+    const response = new LambdaHttpResponse(200, 'ok');
+    response.header(HttpHeader.CacheControl, 'no-store');
+    response.json({ version: (_a = process.env.GIT_VERSION) !== null && _a !== void 0 ? _a : 'dev', hash: process.env.GIT_HASH });
+    return response;
+}

package/build/routes/attribution.d.ts

@@ -0,0 +1,10 @@
+import { ConfigImagery, ConfigLayer, ConfigProvider } from '@basemaps/config';
+import { AttributionCollection, StacCollection, StacExtent } from '@basemaps/geo';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { TileSetRaster } from '../tile.set.raster.js';
+export declare function createAttributionCollection(tileSet: TileSetRaster, stac: StacCollection | null | undefined, imagery: ConfigImagery, layer: ConfigLayer, host: ConfigProvider, extent: StacExtent): AttributionCollection;
+/**
+ * Create a LambdaHttpResponse for a attribution request
+ */
+export declare function attribution(req: LambdaHttpRequest): Promise<LambdaHttpResponse>;
+//# sourceMappingURL=attribution.d.ts.map

package/build/routes/attribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribution.d.ts","sourceRoot":"","sources":["../../src/routes/attribution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EACL,qBAAqB,EAOrB,cAAc,EACd,UAAU,EAEX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAc,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAcnF,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAsEtD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,EACvC,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,UAAU,GACjB,qBAAqB,CAsBvB;AAiFD;;GAEG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAkCrF"}

package/build/routes/attribution.js

@@ -0,0 +1,199 @@
+import { Bounds, GoogleTms, Stac, TileMatrixSet, } from '@basemaps/geo';
+import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
+import { CompositeError, Config, extractYearRangeFromName, fsa, Projection, setNameAndProjection, tileAttributionFromPath, titleizeImageryName, } from '@basemaps/shared';
+import { multiPolygonToWgs84, union, Wgs84 } from '@linzjs/geojson';
+import { createHash } from 'crypto';
+import { TileSets } from '../tile.set.cache.js';
+import { Router } from '../router.js';
+/** Amount to pad imagery bounds to avoid fragmenting polygons  */
+const SmoothPadding = 1 + 1e-10; // about 1/100th of a millimeter at equator
+const NotFound = new LambdaHttpResponse(404, 'Not Found');
+const Precision = 10 ** 8;
+/**
+ * Limit precision to 8 decimal places.
+ */
+function roundNumber(n) {
+    return Math.round(n * Precision) / Precision;
+}
+function roundPair(p) {
+    return [roundNumber(p[0]), roundNumber(p[1])];
+}
+/**
+ * Convert a list of COG file bounds into a MultiPolygon. If the bounds spans more than half the
+ * globe then return a simple MultiPolygon for the bounding box.
+
+ * @param bbox in WGS84
+ * @param files in target projection
+ * @return MultiPolygon in WGS84
+ */
+function createCoordinates(bbox, files, proj) {
+    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 = [];
+    // merge imagery bounds
+    for (const image of files) {
+        const poly = [Bounds.fromJson(image).pad(SmoothPadding).toPolygon()];
+        coordinates = union(coordinates, poly);
+    }
+    const roundToWgs84 = (p) => roundPair(proj.toWgs84(p));
+    return multiPolygonToWgs84(coordinates, roundToWgs84);
+}
+async function readStac(uri) {
+    try {
+        return await fsa.readJson(uri);
+    }
+    catch (err) {
+        if (CompositeError.isCompositeError(err) && err.code < 500) {
+            return null;
+        }
+        throw err;
+    }
+}
+/** Attempt to find the GSD from a stack summary object */
+function getGsd(un) {
+    if (un == null)
+        return null;
+    const gsd = un['gsd'];
+    if (gsd == null)
+        return null;
+    if (!Array.isArray(gsd))
+        return null;
+    if (isNaN(gsd[0]))
+        return null;
+    return gsd[0];
+}
+export function createAttributionCollection(tileSet, stac, imagery, layer, host, extent) {
+    var _a, _b, _c, _d, _e;
+    const tileMatrix = tileSet.tileMatrix;
+    return {
+        stac_version: Stac.Version,
+        license: (_a = stac === null || stac === void 0 ? void 0 : stac.license) !== null && _a !== void 0 ? _a : Stac.License,
+        id: imagery.id,
+        providers: (_b = stac === null || stac === void 0 ? void 0 : stac.providers) !== null && _b !== void 0 ? _b : [
+            { name: host.serviceProvider.name, url: host.serviceProvider.site, roles: ['host'] },
+        ],
+        title: (_c = stac === null || stac === void 0 ? void 0 : stac.title) !== null && _c !== void 0 ? _c : titleizeImageryName(imagery.name),
+        description: (_d = stac === null || stac === void 0 ? void 0 : stac.description) !== null && _d !== void 0 ? _d : 'No description',
+        extent,
+        links: [],
+        summaries: {
+            gsd: [(_e = getGsd(stac === null || stac === void 0 ? void 0 : stac.summaries)) !== null && _e !== void 0 ? _e : imagery.resolution / 1000],
+            'linz:zoom': {
+                min: TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true),
+                max: TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true),
+            },
+            'linz:priority': [1000 + tileSet.tileSet.layers.indexOf(layer)],
+        },
+    };
+}
+/**
+ * Build a Single File STAC for the given TileSet.
+ *
+ * For now this is the minimal set required for attribution. This can be embellished later with
+ * links and assets for a more comprehensive STAC file.
+ */
+async function tileSetAttribution(tileSet) {
+    const proj = Projection.get(tileSet.tileMatrix);
+    const stacFiles = new Map();
+    const cols = [];
+    const items = [];
+    // read all stac files in parallel
+    for (const layer of tileSet.tileSet.layers) {
+        const imgId = Config.getImageId(layer, proj.epsg);
+        if (imgId == null)
+            continue;
+        const im = tileSet.imagery.get(imgId);
+        if (im == null)
+            continue;
+        if (stacFiles.get(im.uri) == null) {
+            stacFiles.set(im.uri, readStac(fsa.join(im.uri, 'collection.json')));
+        }
+    }
+    const host = await Config.Provider.get(Config.Provider.id('linz'));
+    if (host == null)
+        return null;
+    for (const layer of tileSet.tileSet.layers) {
+        const imgId = Config.getImageId(layer, proj.epsg);
+        if (imgId == null)
+            continue;
+        const im = tileSet.imagery.get(imgId);
+        if (im == null)
+            continue;
+        const stac = await stacFiles.get(im.uri);
+        const bbox = proj.boundsToWgs84BoundingBox(im.bounds).map(roundNumber);
+        let interval = stac === null || stac === void 0 ? void 0 : stac.extent.temporal.interval;
+        if (interval == null) {
+            const years = extractYearRangeFromName(im.name);
+            if (years[0] === -1) {
+                throw new Error('Missing date in imagery name: ' + im.name);
+            }
+            interval = [years.map((y) => `${y}-01-01T00:00:00Z`)];
+        }
+        const extent = { spatial: { bbox: [bbox] }, temporal: { interval } };
+        items.push({
+            type: 'Feature',
+            stac_version: Stac.Version,
+            id: imgId + '_item',
+            collection: imgId,
+            assets: {},
+            links: [],
+            bbox,
+            geometry: {
+                type: 'MultiPolygon',
+                coordinates: createCoordinates(bbox, im.files, proj),
+            },
+            properties: {
+                datetime: null,
+                start_datetime: interval[0][0],
+                end_datetime: interval[0][1],
+            },
+        });
+        cols.push(createAttributionCollection(tileSet, stac, im, layer, host, extent));
+    }
+    return {
+        id: tileSet.id,
+        type: 'FeatureCollection',
+        stac_version: Stac.Version,
+        stac_extensions: ['single-file-stac'],
+        title: tileSet.title,
+        description: tileSet.description,
+        features: items,
+        collections: cols,
+        links: [],
+    };
+}
+/**
+ * Create a LambdaHttpResponse for a attribution request
+ */
+export async function attribution(req) {
+    const action = Router.action(req);
+    const data = tileAttributionFromPath(action.rest);
+    if (data == null)
+        return NotFound;
+    setNameAndProjection(req, data);
+    req.timer.start('tileset:load');
+    const tileSet = await TileSets.get(data.name, data.tileMatrix);
+    req.timer.end('tileset:load');
+    if (tileSet == null || tileSet.isVector())
+        return NotFound;
+    const cacheKey = createHash('sha256').update(JSON.stringify(tileSet.tileSet)).digest('base64');
+    const ifNoneMatch = req.header(HttpHeader.IfNoneMatch);
+    if (ifNoneMatch != null && ifNoneMatch.indexOf(cacheKey) > -1) {
+        req.set('cache', { key: cacheKey, hit: true, match: ifNoneMatch });
+        return new LambdaHttpResponse(304, 'Not modified');
+    }
+    req.timer.start('stac:load');
+    const attributions = await tileSetAttribution(tileSet);
+    req.timer.end('stac:load');
+    if (attributions == null)
+        return NotFound;
+    const response = new LambdaHttpResponse(200, 'ok');
+    response.header(HttpHeader.ETag, cacheKey);
+    // Keep fresh for one day; otherwise use cache but refresh cache for next time
+    response.header(HttpHeader.CacheControl, 'public, max-age=86400, stale-while-revalidate=604800');
+    response.json(attributions);
+    return response;
+}

package/build/routes/health.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { TileDataXyz } from '@basemaps/shared';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+interface TestTile extends TileDataXyz {
+    buf?: Buffer;
+}
+export declare const TestTiles: TestTile[];
+export declare function getTestBuffer(test: TestTile): Promise<Buffer>;
+export declare function updateExpectedTile(test: TestTile, newTileData: Buffer, difference: Buffer): Promise<void>;
+/**
+ * Health request get health TileSets and validate with test TileSets
+ * - Valid response from get heath tile request
+ * - Valid tile get from the request
+ *
+ * @throws LambdaHttpResponse for failure health test
+ */
+export declare function Health(req: LambdaHttpRequest): Promise<LambdaHttpResponse>;
+export {};
+//# sourceMappingURL=health.d.ts.map

package/build/routes/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/routes/health.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,WAAW,EAAY,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAc,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAQnF,UAAU,QAAS,SAAQ,WAAW;IACpC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,SAAS,EAAE,QAAQ,EAG/B,CAAC;AAGF,wBAAsB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAYnE;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO/G;AAED;;;;;;GAMG;AACH,wBAAsB,MAAM,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAgChF"}

package/build/routes/health.js

@@ -0,0 +1,75 @@
+import { GoogleTms, Nztm2000QuadTms } from '@basemaps/geo';
+import { TileType } from '@basemaps/shared';
+import { ImageFormat } from '@basemaps/tiler';
+import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
+import * as fs from 'fs';
+import * as path from 'path';
+import PixelMatch from 'pixelmatch';
+import Sharp from 'sharp';
+import url from 'url';
+import { TileSets } from '../tile.set.cache.js';
+export const TestTiles = [
+    { type: TileType.Tile, name: 'health', tileMatrix: GoogleTms, ext: ImageFormat.PNG, x: 252, y: 156, z: 8 },
+    { type: TileType.Tile, name: 'health', tileMatrix: Nztm2000QuadTms, ext: ImageFormat.PNG, x: 30, y: 33, z: 6 },
+];
+const TileSize = 256;
+export async function getTestBuffer(test) {
+    if (Buffer.isBuffer(test.buf))
+        return test.buf;
+    const expectedFile = `static/expected_tile_${test.tileMatrix.identifier}_${test.x}_${test.y}_z${test.z}.${test.ext}`;
+    // Initiate test img buffer if not defined
+    try {
+        return await fs.promises.readFile(expectedFile);
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+        const otherFile = path.join(path.dirname(url.fileURLToPath(import.meta.url)), '..', '..', expectedFile);
+        return await fs.promises.readFile(otherFile);
+    }
+}
+export async function updateExpectedTile(test, newTileData, difference) {
+    const expectedFileName = `static/expected_tile_${test.tileMatrix.identifier}_${test.x}_${test.y}_z${test.z}.${test.ext}`;
+    await fs.promises.writeFile(expectedFileName, newTileData);
+    const imgPng = await Sharp(difference, { raw: { width: TileSize, height: TileSize, channels: 4 } })
+        .png()
+        .toBuffer();
+    await fs.promises.writeFile(`${expectedFileName}.diff.png`, imgPng);
+}
+/**
+ * Health request get health TileSets and validate with test TileSets
+ * - Valid response from get heath tile request
+ * - Valid tile get from the request
+ *
+ * @throws LambdaHttpResponse for failure health test
+ */
+export async function Health(req) {
+    for (const test of TestTiles) {
+        const tileSet = await TileSets.get('health', test.tileMatrix);
+        if (tileSet == null)
+            throw new LambdaHttpResponse(500, 'TileSet: "health" not found');
+        // Get the parse response tile to raw buffer
+        const response = await tileSet.tile(req, test);
+        if (response.status !== 200)
+            return new LambdaHttpResponse(500, response.statusDescription);
+        if (!Buffer.isBuffer(response._body))
+            throw new LambdaHttpResponse(500, 'Not a Buffer response content.');
+        const resImgBuffer = await Sharp(response._body).raw().toBuffer();
+        // Get test tile to compare
+        const testBuffer = await getTestBuffer(test);
+        test.buf = testBuffer;
+        const testImgBuffer = await Sharp(testBuffer).raw().toBuffer();
+        const outputBuffer = Buffer.alloc(testImgBuffer.length);
+        const missMatchedPixels = PixelMatch(testImgBuffer, resImgBuffer, outputBuffer, TileSize, TileSize);
+        if (missMatchedPixels) {
+            /** Uncomment this to overwite the expected files */
+            // await updateExpectedTile(test, response._body as Buffer, outputBuffer);
+            req.log.error({ missMatchedPixels, projection: test.tileMatrix.identifier, xyz: { x: test.x, y: test.y, z: test.z } }, 'Health:MissMatch');
+            return new LambdaHttpResponse(500, 'TileSet does not match.');
+        }
+    }
+    // Return Ok response when all health test passed.
+    const OkResponse = new LambdaHttpResponse(200, 'ok');
+    OkResponse.header(HttpHeader.CacheControl, 'no-store');
+    return OkResponse;
+}

package/build/routes/tile.d.ts

@@ -0,0 +1,23 @@
+import { TileMatrixSet } from '@basemaps/geo';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { TileMakerSharp } from '@basemaps/tiler-sharp';
+import { TileSetRaster } from '../tile.set.raster.js';
+export declare const TileComposer: TileMakerSharp;
+export declare const NotFound: LambdaHttpResponse;
+export declare const NotModified: LambdaHttpResponse;
+export interface TileJson {
+    tiles: string[];
+    minzoom: number;
+    maxzoom: number;
+    format: string;
+    tilejson: string;
+}
+export declare const TileRoute: {
+    tile(req: LambdaHttpRequest): Promise<LambdaHttpResponse>;
+    wmtsLoadTileSets(name: string, tileMatrix: TileMatrixSet | null): Promise<TileSetRaster[]>;
+    wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse>;
+    tileJson(req: LambdaHttpRequest): Promise<LambdaHttpResponse>;
+    styleJson(req: LambdaHttpRequest, fileName: string): Promise<LambdaHttpResponse>;
+};
+export declare function Tiles(req: LambdaHttpRequest): Promise<LambdaHttpResponse>;
+//# sourceMappingURL=tile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tile.d.ts","sourceRoot":"","sources":["../../src/routes/tile.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAc,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEnF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAIvD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAQtD,eAAO,MAAM,YAAY,gBAA0B,CAAC;AAEpD,eAAO,MAAM,QAAQ,oBAA2C,CAAC;AACjE,eAAO,MAAM,WAAW,oBAA8C,CAAC;AAEvE,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,SAAS;cACJ,iBAAiB,GAAG,QAAQ,kBAAkB,CAAC;2BAelC,MAAM,cAAc,aAAa,GAAG,IAAI,GAAG,QAAQ,aAAa,EAAE,CAAC;cAUhF,iBAAiB,GAAG,QAAQ,kBAAkB,CAAC;kBAiC3C,iBAAiB,GAAG,QAAQ,kBAAkB,CAAC;mBA8B9C,iBAAiB,YAAY,MAAM,GAAG,QAAQ,kBAAkB,CAAC;CA8DvF,CAAC;AACF,wBAAsB,KAAK,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAgB/E"}

package/build/routes/tile.etag.d.ts

@@ -0,0 +1,11 @@
+import { Composition } from '@basemaps/tiler';
+import { TileDataXyz } from '@basemaps/shared';
+import { LambdaHttpRequest } from '@linzjs/lambda';
+export declare const TileEtag: {
+    RenderId: number;
+    key(object: Record<string, unknown>): string;
+    /** Generate a unique ETag for this tile */
+    generate(compositions: Composition[], xyzData: TileDataXyz): string;
+    isNotModified(req: LambdaHttpRequest, cacheKey: string): boolean;
+};
+//# sourceMappingURL=tile.etag.d.ts.map

package/build/routes/tile.etag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile.etag.d.ts","sourceRoot":"","sources":["../../src/routes/tile.etag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAc,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAG/D,eAAO,MAAM,QAAQ;;gBAIP,OAAO,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;IAI5C,2CAA2C;2BACpB,WAAW,EAAE,WAAW,WAAW,GAAG,MAAM;uBAUhD,iBAAiB,YAAY,MAAM,GAAG,OAAO;CAUjE,CAAC"}

package/build/routes/tile.etag.js

@@ -0,0 +1,29 @@
+import { createHash } from 'crypto';
+import { HttpHeader } from '@linzjs/lambda';
+import { basename } from 'path';
+export const TileEtag = {
+    // To force a full cache invalidation change this number
+    RenderId: 1,
+    key(object) {
+        return createHash('sha256').update(JSON.stringify(object)).digest('base64');
+    },
+    /** Generate a unique ETag for this tile */
+    generate(compositions, xyzData) {
+        // We cannot serialize the CogTiff inside of composition so replace it with the source name
+        const layers = compositions.map((c) => {
+            return { ...c, tiff: basename(c.tiff.source.uri) };
+        });
+        const xyz = { ...xyzData, tileMatrix: xyzData.tileMatrix.identifier };
+        return TileEtag.key({ xyz, layers, RenderId: TileEtag.RenderId });
+    },
+    isNotModified(req, cacheKey) {
+        // If the user has supplied a IfNoneMatch Header and it contains the full sha256 sum for our
+        // etag this tile has not been modified.
+        const ifNoneMatch = req.header(HttpHeader.IfNoneMatch);
+        if (ifNoneMatch != null && ifNoneMatch.indexOf(cacheKey) > -1) {
+            req.set('cache', { key: cacheKey, hit: true, match: ifNoneMatch });
+            return true;
+        }
+        return false;
+    },
+};

package/build/routes/tile.js

@@ -0,0 +1,180 @@
+import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
+import { Config, Env, setNameAndProjection, TileSetName, tileWmtsFromPath, tileXyzFromPath } from '@basemaps/shared';
+import { TileMakerSharp } from '@basemaps/tiler-sharp';
+import { createHash } from 'crypto';
+import { isValidApiKey } from '../api.key.js';
+import { TileSets } from '../tile.set.cache.js';
+import { WmtsCapabilities } from '../wmts.capability.js';
+import { attribution } from './attribution.js';
+import { TileEtag } from './tile.etag.js';
+import { Router } from '../router.js';
+import { ValidateTilePath } from '../validate.js';
+import { URL } from 'url';
+export const TileComposer = new TileMakerSharp(256);
+export const NotFound = new LambdaHttpResponse(404, 'Not Found');
+export const NotModified = new LambdaHttpResponse(304, 'Not modified');
+export const TileRoute = {
+    async tile(req) {
+        const action = Router.action(req);
+        const xyzData = tileXyzFromPath(action.rest);
+        if (xyzData == null)
+            return NotFound;
+        ValidateTilePath.validate(req, xyzData);
+        req.timer.start('tileset:load');
+        const tileSet = await TileSets.get(xyzData.name, xyzData.tileMatrix);
+        req.timer.end('tileset:load');
+        if (tileSet == null)
+            return NotFound;
+        const res = await tileSet.tile(req, xyzData);
+        return res;
+    },
+    async wmtsLoadTileSets(name, tileMatrix) {
+        if (tileMatrix != null) {
+            const ts = await TileSets.get(name, tileMatrix);
+            if (ts == null || ts.isVector())
+                return [];
+            return [ts];
+        }
+        if (name === '')
+            name = TileSetName.aerial;
+        return (await TileSets.getAll(name, tileMatrix)).filter((f) => f.type === 'raster');
+    },
+    async wmts(req) {
+        var _a;
+        const action = Router.action(req);
+        const wmtsData = tileWmtsFromPath(action.rest);
+        if (wmtsData == null)
+            return NotFound;
+        setNameAndProjection(req, wmtsData);
+        const host = (_a = Env.get(Env.PublicUrlBase)) !== null && _a !== void 0 ? _a : '';
+        req.timer.start('tileset:load');
+        const tileSets = await TileRoute.wmtsLoadTileSets(wmtsData.name, wmtsData.tileMatrix);
+        req.timer.end('tileset:load');
+        if (tileSets.length === 0)
+            return NotFound;
+        const providerId = Config.Provider.id('linz');
+        const provider = await Config.Provider.get(providerId);
+        if (provider == null)
+            return NotFound;
+        const apiKey = Router.apiKey(req);
+        const xml = WmtsCapabilities.toXml(host, provider, tileSets, apiKey);
+        if (xml == null)
+            return NotFound;
+        const data = Buffer.from(xml);
+        const cacheKey = createHash('sha256').update(data).digest('base64');
+        if (TileEtag.isNotModified(req, cacheKey))
+            return NotModified;
+        const response = new LambdaHttpResponse(200, 'ok');
+        response.header(HttpHeader.ETag, cacheKey);
+        response.header(HttpHeader.CacheControl, 'max-age=0');
+        response.buffer(data, 'text/xml');
+        req.set('bytes', data.byteLength);
+        return response;
+    },
+    async tileJson(req) {
+        var _a;
+        const { version, rest, name } = Router.action(req);
+        const apiKey = Router.apiKey(req);
+        const host = (_a = Env.get(Env.PublicUrlBase)) !== null && _a !== void 0 ? _a : '';
+        const tileUrl = `${host}/${version}/${name}/${rest[0]}/${rest[1]}/{z}/{x}/{y}.pbf?api=${apiKey}`;
+        const tileJson = {
+            tiles: [tileUrl],
+            minzoom: 0,
+            maxzoom: 15,
+            format: 'pbf',
+            tilejson: '2.0.0',
+        };
+        const json = JSON.stringify(tileJson);
+        const data = Buffer.from(json);
+        const cacheKey = createHash('sha256').update(data).digest('base64');
+        if (TileEtag.isNotModified(req, cacheKey))
+            return NotModified;
+        const response = new LambdaHttpResponse(200, 'ok');
+        response.header(HttpHeader.ETag, cacheKey);
+        response.header(HttpHeader.CacheControl, 'max-age=120');
+        response.buffer(data, 'application/json');
+        req.set('bytes', data.byteLength);
+        return response;
+    },
+    async styleJson(req, fileName) {
+        var _a;
+        const apiKey = Router.apiKey(req);
+        if (apiKey == null)
+            return new LambdaHttpResponse(400, 'Invalid API Key.');
+        const styleName = fileName.split('.json')[0];
+        const host = (_a = Env.get(Env.PublicUrlBase)) !== null && _a !== void 0 ? _a : '';
+        // Get style Config from db
+        const dbId = Config.Style.id(styleName);
+        const styleConfig = await Config.Style.get(dbId);
+        if (styleConfig == null)
+            return NotFound;
+        // Prepare sources and add linz source
+        const style = styleConfig.style;
+        const sources = {};
+        for (const [key, value] of Object.entries(style.sources)) {
+            if (value.type === 'vector') {
+                if (value.url.includes(host)) {
+                    const url = new URL(value.url);
+                    url.searchParams.set('api', apiKey);
+                    value.url = url.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
+                }
+            }
+            else if (value.type === 'raster' && Array.isArray(value.tiles)) {
+                for (let i = 0; i < value.tiles.length; i++) {
+                    const tile = value.tiles[i];
+                    if (tile.includes(host)) {
+                        const url = new URL(tile);
+                        url.searchParams.set('api', apiKey);
+                        value.tiles[i] = url.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
+                    }
+                }
+            }
+            sources[key] = value;
+        }
+        // prepare Style.json
+        const styleJson = {
+            /** Style.json version 8 */
+            version: 8,
+            id: style.id,
+            name: style.name,
+            sources,
+            layers: style.layers,
+            metadata: style.metadata || {},
+            glyphs: style.glyphs || '',
+            sprite: style.sprite || '',
+        };
+        const json = JSON.stringify(styleJson);
+        const data = Buffer.from(json);
+        const cacheKey = createHash('sha256').update(data).digest('base64');
+        if (TileEtag.isNotModified(req, cacheKey))
+            return NotModified;
+        const response = new LambdaHttpResponse(200, 'ok');
+        response.header(HttpHeader.ETag, cacheKey);
+        response.header(HttpHeader.CacheControl, 'max-age=120');
+        response.buffer(data, 'application/json');
+        req.set('bytes', data.byteLength);
+        return response;
+    },
+};
+export async function Tiles(req) {
+    const { rest } = Router.action(req);
+    if (rest.length < 1)
+        return NotFound;
+    const apiKey = Router.apiKey(req);
+    const apiKeyHash = createHash('sha256')
+        .update(apiKey !== null && apiKey !== void 0 ? apiKey : '')
+        .digest('base64');
+    req.set('api', apiKeyHash);
+    if (!isValidApiKey(apiKey))
+        return new LambdaHttpResponse(400, 'Invalid API Key');
+    const fileName = rest[rest.length - 1].toLowerCase();
+    if (fileName === 'attribution.json')
+        return attribution(req);
+    if (fileName === 'wmtscapabilities.xml')
+        return TileRoute.wmts(req);
+    if (fileName === 'tile.json')
+        return TileRoute.tileJson(req);
+    if (fileName.endsWith('json') && rest[rest.length - 2] === 'style')
+        return TileRoute.styleJson(req, fileName);
+    return TileRoute.tile(req);
+}

package/build/tiff.cache.d.ts

@@ -0,0 +1,17 @@
+import { CogTiff } from '@cogeotiff/core';
+/** Limit the caching of tiffs */
+export declare class TiffCache {
+    static cacheA: Map<string, CogTiff>;
+    static cacheB: Map<string, CogTiff>;
+    /** 256 MB Cache */
+    static MaxCacheSizeBytes: number;
+    static get(id: string): CogTiff | null;
+    /** Reset the cache */
+    static clear(): void;
+    static set(id: string, tiff: CogTiff): void;
+    /** Validate the size of the cache has not exploded */
+    static check(): void;
+    /** Calculate the total number of bytes used by this tiff cache */
+    static get currentSize(): number;
+}
+//# sourceMappingURL=tiff.cache.d.ts.map

package/build/tiff.cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff.cache.d.ts","sourceRoot":"","sources":["../src/tiff.cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,iCAAiC;AACjC,qBAAa,SAAS;IACpB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAa;IAChD,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAa;IAEhD,mBAAmB;IACnB,MAAM,CAAC,iBAAiB,SAAqB;IAE7C,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI;IAYtC,sBAAsB;IACtB,MAAM,CAAC,KAAK,IAAI,IAAI;IAKpB,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI;IAK3C,sDAAsD;IACtD,MAAM,CAAC,KAAK,IAAI,IAAI;IAOpB,kEAAkE;IAClE,MAAM,KAAK,WAAW,IAAI,MAAM,CAM/B;CACF"}

package/build/tiff.cache.js

@@ -0,0 +1,45 @@
+/** Limit the caching of tiffs */
+export class TiffCache {
+    static get(id) {
+        const cacheA = TiffCache.cacheA.get(id);
+        if (cacheA)
+            return cacheA;
+        const cacheB = TiffCache.cacheB.get(id);
+        if (cacheB == null)
+            return null;
+        // If a object is still useful move it into the main cache
+        TiffCache.cacheA.set(id, cacheB);
+        TiffCache.cacheB.delete(id);
+        return cacheB;
+    }
+    /** Reset the cache */
+    static clear() {
+        this.cacheA.clear();
+        this.cacheB.clear();
+    }
+    static set(id, tiff) {
+        TiffCache.cacheA.set(id, tiff);
+        TiffCache.check();
+    }
+    /** Validate the size of the cache has not exploded */
+    static check() {
+        if (TiffCache.MaxCacheSizeBytes <= 0)
+            return;
+        if (TiffCache.currentSize <= TiffCache.MaxCacheSizeBytes)
+            return;
+        TiffCache.cacheB = TiffCache.cacheA;
+        TiffCache.cacheA = new Map();
+    }
+    /** Calculate the total number of bytes used by this tiff cache */
+    static get currentSize() {
+        let size = 0;
+        for (const value of TiffCache.cacheA.values()) {
+            size += value.source.chunkSize * value.source.chunks.size;
+        }
+        return size;
+    }
+}
+TiffCache.cacheA = new Map();
+TiffCache.cacheB = new Map();
+/** 256 MB Cache */
+TiffCache.MaxCacheSizeBytes = 256 * 1024 * 1024;