@basemaps/lambda-tiler 6.15.0

package/build/tile.set.cache.d.ts

@@ -0,0 +1,21 @@
+import { TileMatrixSet } from '@basemaps/geo';
+import { TileSet } from './tile.set.js';
+export declare class TileSetCache {
+    /** Duration to cache tile sets for */
+    CacheTime: number;
+    /** Cache the fetch requests */
+    cache: Map<string, {
+        time: number;
+        value: Promise<TileSet | null>;
+    }>;
+    /** Cache initialized tile sets */
+    tileSets: Map<string, TileSet>;
+    id(tileSet: TileSet): string;
+    id(name: string, tileMatrix: TileMatrixSet): string;
+    add(tileSet: TileSet, expiresAt?: number): void;
+    get(name: string, tileMatrix: TileMatrixSet): Promise<TileSet | null>;
+    loadTileSet(name: string, tileMatrix: TileMatrixSet): Promise<TileSet | null>;
+    getAll(name: string, tileMatrix?: TileMatrixSet | null): Promise<TileSet[]>;
+}
+export declare const TileSets: TileSetCache;
+//# sourceMappingURL=tile.set.cache.d.ts.map

package/build/tile.set.cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile.set.cache.d.ts","sourceRoot":"","sources":["../src/tile.set.cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAkB,MAAM,eAAe,CAAC;AAE9D,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAIxC,qBAAa,YAAY;IACvB,sCAAsC;IACtC,SAAS,SAAU;IAEnB,+BAA+B;IAC/B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAA;KAAE,CAAC,CAAa;IACjF,kCAAkC;IAClC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAa;IAE3C,EAAE,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM;IAC5B,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,GAAG,MAAM;IAUnD,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,SAA8B,GAAG,IAAI;IAMpE,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAY/D,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAqC7E,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,aAAa,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;CAsBlF;AAED,eAAO,MAAM,QAAQ,cAAqB,CAAC"}

package/build/tile.set.cache.js

@@ -0,0 +1,96 @@
+import { TileSetNameParser } from '@basemaps/config';
+import { TileMatrixSets } from '@basemaps/geo';
+import { Config } from '@basemaps/shared';
+import { TileSetRaster } from './tile.set.raster.js';
+import { TileSetVector } from './tile.set.vector.js';
+export class TileSetCache {
+    constructor() {
+        /** Duration to cache tile sets for */
+        this.CacheTime = 30000;
+        /** Cache the fetch requests */
+        this.cache = new Map();
+        /** Cache initialized tile sets */
+        this.tileSets = new Map();
+    }
+    id(name, tileMatrix) {
+        if (typeof name === 'string') {
+            const nameComp = TileSetNameParser.parse(name);
+            return `${TileSetNameParser.componentsToName(nameComp)}_${tileMatrix === null || tileMatrix === void 0 ? void 0 : tileMatrix.identifier}`;
+        }
+        return `${name.fullName}_${name.tileMatrix.identifier}`;
+    }
+    add(tileSet, expiresAt = Date.now() + this.CacheTime) {
+        const id = this.id(tileSet);
+        if (this.cache.has(id))
+            throw new Error('Trying to add duplicate tile set:' + id);
+        this.cache.set(id, { time: expiresAt, value: Promise.resolve(tileSet) });
+    }
+    get(name, tileMatrix) {
+        const tsId = this.id(name, tileMatrix);
+        let existing = this.cache.get(tsId);
+        // Validate the data is current every ~30 seconds
+        if (existing == null || Date.now() - existing.time > 0) {
+            const value = this.loadTileSet(name, tileMatrix);
+            existing = { time: Date.now(), value };
+            this.cache.set(tsId, existing);
+        }
+        return existing.value;
+    }
+    async loadTileSet(name, tileMatrix) {
+        const nameComp = TileSetNameParser.parse(name);
+        const tileSetId = this.id(name, tileMatrix);
+        if (nameComp.layer != null) {
+            const parentName = TileSetNameParser.componentsToName({ ...nameComp, layer: undefined });
+            const parent = await this.get(parentName, tileMatrix);
+            if (parent == null || parent.isVector())
+                return null;
+            return parent.child(nameComp.layer);
+        }
+        const dbId = Config.TileSet.id(name);
+        const tileSet = await Config.TileSet.get(dbId);
+        if (tileSet == null) {
+            this.cache.delete(tileSetId);
+            return null;
+        }
+        // If we already have a copy and it hasn't been modified just return it
+        const existing = this.tileSets.get(tileSetId);
+        if ((existing === null || existing === void 0 ? void 0 : existing.tileSet.updatedAt) === tileSet.updatedAt) {
+            return existing;
+        }
+        if (Config.isTileSetRaster(tileSet)) {
+            const ts = new TileSetRaster(name, tileMatrix);
+            await ts.init(tileSet);
+            this.tileSets.set(tileSetId, ts);
+            return ts;
+        }
+        const ts = new TileSetVector(name, tileMatrix);
+        ts.tileSet = tileSet;
+        this.tileSets.set(tileSetId, ts);
+        return ts;
+    }
+    async getAll(name, tileMatrix) {
+        const nameComp = TileSetNameParser.parse(name);
+        const tileMatrices = tileMatrix == null ? Array.from(TileMatrixSets.Defaults.values()) : [tileMatrix];
+        const promises = [];
+        for (const tileMatrix of tileMatrices)
+            promises.push(this.get(name, tileMatrix));
+        const tileMatrixSets = await Promise.all(promises);
+        const tileSets = [];
+        for (const parent of tileMatrixSets) {
+            if (parent == null)
+                continue;
+            if (parent.isVector())
+                continue;
+            tileSets.push(parent);
+            if (nameComp.layer != null) {
+                parent.components.name = nameComp.name;
+            }
+            else if (parent.imagery != null && parent.imagery.size > 1) {
+                for (const imageId of parent.imagery.keys())
+                    tileSets.push(parent.child(imageId));
+            }
+        }
+        return tileSets.sort((a, b) => a.title.localeCompare(b.title));
+    }
+}
+export const TileSets = new TileSetCache();

package/build/tile.set.d.ts

@@ -0,0 +1,20 @@
+import { ConfigTileSetRaster, ConfigTileSetVector, TileSetNameComponents, TileSetType } from '@basemaps/config';
+import { TileMatrixSet } from '@basemaps/geo';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { TileDataXyz } from '@basemaps/shared';
+import { TileSetRaster } from './tile.set.raster.js';
+import { TileSetVector } from './tile.set.vector.js';
+export declare type TileSet = TileSetVector | TileSetRaster;
+export declare abstract class TileSetHandler<T extends ConfigTileSetRaster | ConfigTileSetVector> {
+    type: TileSetType;
+    components: TileSetNameComponents;
+    tileMatrix: TileMatrixSet;
+    tileSet: T;
+    constructor(name: string, tileMatrix: TileMatrixSet);
+    get id(): string;
+    get fullName(): string;
+    isVector(): this is TileSetVector;
+    isRaster(): this is TileSetRaster;
+    abstract tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse>;
+}
+//# sourceMappingURL=tile.set.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tile.set.d.ts","sourceRoot":"","sources":["../src/tile.set.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EAErB,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,oBAAY,OAAO,GAAG,aAAa,GAAG,aAAa,CAAC;AAEpD,8BAAsB,cAAc,CAAC,CAAC,SAAS,mBAAmB,GAAG,mBAAmB;IACtF,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,qBAAqB,CAAC;IAClC,UAAU,EAAE,aAAa,CAAC;IAC1B,OAAO,EAAE,CAAC,CAAC;gBACC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa;IAKnD,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,QAAQ,IAAI,IAAI,IAAI,aAAa;IAIjC,QAAQ,IAAI,IAAI,IAAI,aAAa;IAIjC,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;CACrF"}

package/build/tile.set.js

@@ -0,0 +1,20 @@
+import { TileSetNameParser, TileSetType, } from '@basemaps/config';
+import { TileSets } from './tile.set.cache.js';
+export class TileSetHandler {
+    constructor(name, tileMatrix) {
+        this.components = TileSetNameParser.parse(name);
+        this.tileMatrix = tileMatrix;
+    }
+    get id() {
+        return TileSets.id(this.fullName, this.tileMatrix);
+    }
+    get fullName() {
+        return TileSetNameParser.componentsToName(this.components);
+    }
+    isVector() {
+        return this.type === TileSetType.Vector;
+    }
+    isRaster() {
+        return this.type === TileSetType.Raster;
+    }
+}

package/build/tile.set.raster.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import { ConfigImagery, ConfigTileSetRaster, TileSetType } from '@basemaps/config';
+import { Bounds, Tile, TileMatrixSet } from '@basemaps/geo';
+import { LogType, TileDataXyz } from '@basemaps/shared';
+import { Tiler } from '@basemaps/tiler';
+import { CogTiff } from '@cogeotiff/core';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { Metrics } from '@linzjs/metrics';
+import { TileSetHandler } from './tile.set.js';
+export interface TileSetResponse {
+    buffer: Buffer;
+    metrics: Metrics;
+    layersUsed: number;
+    layersTotal: number;
+    contentType: string;
+}
+export declare class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
+    type: TileSetType;
+    tileMatrix: TileMatrixSet;
+    tiler: Tiler;
+    imagery: Map<string, ConfigImagery>;
+    extentOverride: Bounds;
+    /**
+     * Return the location of a imagery `record`
+     * @param record
+     * @param name the COG to locate. Return just the directory if `null`
+     */
+    static basePath(record: ConfigImagery, name?: string): string;
+    constructor(name: string, tileMatrix: TileMatrixSet);
+    get title(): string;
+    get description(): string;
+    get extent(): Bounds;
+    init(record: ConfigTileSetRaster): Promise<void>;
+    initTiffs(tile: Tile, log: LogType): Promise<CogTiff[]>;
+    tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse>;
+    /**
+     * Get a list of tiffs in the rendering order that is needed to render the tile
+     * @param tms tile matrix set to describe the tiling scheme
+     * @param tile tile to render
+     */
+    getTiffsForTile(tile: Tile, log?: LogType): CogTiff[];
+    private getCogsForTile;
+    /** Look up imagery by imageryId or by image name */
+    findImagery(imgId: string): ConfigImagery | null;
+    child(imgId: string): TileSetRaster;
+}
+//# sourceMappingURL=tile.set.raster.d.ts.map

package/build/tile.set.raster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile.set.raster.d.ts","sourceRoot":"","sources":["../src/tile.set.raster.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,aAAa,EAAe,mBAAmB,EAAqB,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACnH,OAAO,EAAE,MAAM,EAAQ,IAAI,EAAE,aAAa,EAAkB,MAAM,eAAe,CAAC;AAClF,OAAO,EAAoB,OAAO,EAAE,WAAW,EAAqC,MAAM,kBAAkB,CAAC;AAC7G,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAc,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACnF,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAK1C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAI/C,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAKD,qBAAa,aAAc,SAAQ,cAAc,CAAC,mBAAmB,CAAC;IACpE,IAAI,cAAsB;IAE1B,UAAU,EAAE,aAAa,CAAC;IAC1B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACpC,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;gBAMjD,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa;IAKnD,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEK,IAAI,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAKhD,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAmBhD,IAAI,CAAC,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8BxF;;;;OAIG;IACI,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE;IAgC5D,OAAO,CAAC,cAAc;IAsBtB,oDAAoD;IACpD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAShD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa;CAuBpC"}

package/build/tile.set.raster.js

@@ -0,0 +1,181 @@
+import { TileSetNameParser, TileSetType } from '@basemaps/config';
+import { Bounds, Epsg, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
+import { Config, Env, fsa, titleizeImageryName, VectorFormat } from '@basemaps/shared';
+import { Tiler } from '@basemaps/tiler';
+import { CogTiff } from '@cogeotiff/core';
+import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
+import pLimit from 'p-limit';
+import { TileEtag } from './routes/tile.etag.js';
+import { NotFound, NotModified, TileComposer } from './routes/tile.js';
+import { TiffCache } from './tiff.cache.js';
+import { TileSetHandler } from './tile.set.js';
+const LoadingQueue = pLimit(Env.getNumber(Env.TiffConcurrency, 5));
+const DefaultResizeKernel = { in: 'lanczos3', out: 'lanczos3' };
+const DefaultBackground = { r: 0, g: 0, b: 0, alpha: 0 };
+export class TileSetRaster extends TileSetHandler {
+    constructor(name, tileMatrix) {
+        super(name, tileMatrix);
+        this.type = TileSetType.Raster;
+        this.tiler = new Tiler(this.tileMatrix);
+    }
+    /**
+     * Return the location of a imagery `record`
+     * @param record
+     * @param name the COG to locate. Return just the directory if `null`
+     */
+    static basePath(record, name) {
+        if (name == null)
+            return record.uri;
+        if (record.uri.endsWith('/'))
+            throw new Error("Invalid uri ending with '/' " + record.uri);
+        return `${record.uri}/${name}.tiff`;
+    }
+    get title() {
+        var _a, _b;
+        return (_b = (_a = this.tileSet) === null || _a === void 0 ? void 0 : _a.title) !== null && _b !== void 0 ? _b : this.components.name;
+    }
+    get description() {
+        var _a, _b;
+        return (_b = (_a = this.tileSet) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : '';
+    }
+    get extent() {
+        var _a;
+        return (_a = this.extentOverride) !== null && _a !== void 0 ? _a : this.tileMatrix.extent;
+    }
+    async init(record) {
+        this.tileSet = record;
+        this.imagery = await Config.getAllImagery(this.tileSet.layers, this.tileMatrix.projection);
+    }
+    async initTiffs(tile, log) {
+        const tiffs = this.getTiffsForTile(tile, log);
+        let failed = false;
+        // Remove any tiffs that failed to load
+        const promises = tiffs.map((c) => {
+            return LoadingQueue(async () => {
+                try {
+                    await c.init();
+                }
+                catch (error) {
+                    log.warn({ error, tiff: c.source.uri }, 'TiffLoadFailed');
+                    failed = true;
+                }
+            });
+        });
+        await Promise.all(promises);
+        if (failed)
+            return tiffs.filter((f) => f.images.length > 0);
+        return tiffs;
+    }
+    async tile(req, xyz) {
+        var _a, _b;
+        if (xyz.ext === VectorFormat.MapboxVectorTiles)
+            return NotFound;
+        const tiffs = await this.initTiffs(xyz, req.log);
+        const layers = await this.tiler.tile(tiffs, xyz.x, xyz.y, xyz.z);
+        // Generate a unique hash given the full URI, the layers used and a renderId
+        const cacheKey = TileEtag.generate(layers, xyz);
+        req.set('layers', layers.length);
+        if (TileEtag.isNotModified(req, cacheKey))
+            return NotModified;
+        req.timer.start('tile:compose');
+        const res = await TileComposer.compose({
+            layers,
+            format: xyz.ext,
+            background: (_a = this.tileSet.background) !== null && _a !== void 0 ? _a : DefaultBackground,
+            resizeKernel: (_b = this.tileSet.resizeKernel) !== null && _b !== void 0 ? _b : DefaultResizeKernel,
+        });
+        req.timer.end('tile:compose');
+        req.set('layersUsed', res.layers);
+        req.set('allLayersUsed', res.layers === layers.length);
+        req.set('bytes', res.buffer.byteLength);
+        const response = new LambdaHttpResponse(200, 'ok');
+        response.header(HttpHeader.ETag, cacheKey);
+        response.header(HttpHeader.CacheControl, 'public, max-age=604800');
+        response.buffer(res.buffer, 'image/' + xyz.ext);
+        return response;
+    }
+    /**
+     * Get a list of tiffs in the rendering order that is needed to render the tile
+     * @param tms tile matrix set to describe the tiling scheme
+     * @param tile tile to render
+     */
+    getTiffsForTile(tile, log) {
+        const output = [];
+        const tileBounds = this.tileMatrix.tileToSourceBounds(tile);
+        // All zoom level config is stored as Google zoom levels
+        const filterZoom = TileMatrixSet.convertZoomLevel(tile.z, this.tileMatrix, TileMatrixSets.get(Epsg.Google));
+        for (const layer of this.tileSet.layers) {
+            if (layer.maxZoom != null && filterZoom > layer.maxZoom)
+                continue;
+            if (layer.minZoom != null && filterZoom < layer.minZoom)
+                continue;
+            const imgId = Config.getImageId(layer, this.tileMatrix.projection);
+            if (imgId == null) {
+                log === null || log === void 0 ? void 0 : log.warn({ layer: layer.name, projection: this.tileMatrix.projection.code }, 'Failed to lookup imagery');
+                continue;
+            }
+            const imagery = this.imagery.get(imgId);
+            if (imagery == null) {
+                console.log('Failed', { imagery, i: this.imagery, ts: this.tileSet.layers });
+                log === null || log === void 0 ? void 0 : log.warn({ layer: layer.name, projection: this.tileMatrix.projection.code, imgId }, 'Failed to lookup imagery');
+                continue;
+            }
+            if (!tileBounds.intersects(Bounds.fromJson(imagery.bounds)))
+                continue;
+            for (const tiff of this.getCogsForTile(imagery, tileBounds))
+                output.push(tiff);
+        }
+        return output;
+    }
+    getCogsForTile(record, tileBounds) {
+        const output = [];
+        for (const c of record.files) {
+            if (!tileBounds.intersects(Bounds.fromJson(c)))
+                continue;
+            const tiffKey = `${record.id}_${c.name}`;
+            let existing = TiffCache.get(tiffKey);
+            if (existing == null) {
+                const source = fsa.source(TileSetRaster.basePath(record, c.name));
+                if (source == null) {
+                    throw new Error(`Failed to create CogSource from  ${TileSetRaster.basePath(record, c.name)}`);
+                }
+                existing = new CogTiff(source);
+                TiffCache.set(tiffKey, existing);
+            }
+            output.push(existing);
+        }
+        return output;
+    }
+    /** Look up imagery by imageryId or by image name */
+    findImagery(imgId) {
+        const existing = this.imagery.get(imgId);
+        if (existing != null)
+            return existing;
+        for (const img of this.imagery.values()) {
+            if (img.name === imgId)
+                return img;
+        }
+        return null;
+    }
+    child(imgId) {
+        var _a, _b, _c;
+        const image = this.findImagery(imgId);
+        if (image == null) {
+            throw new Error('Failed to create child tile set ' + this.fullName + ' Missing imagery ' + imgId);
+        }
+        const childName = TileSetNameParser.componentsToName({ ...this.components, layer: image.name });
+        const child = new TileSetRaster(childName, this.tileMatrix);
+        // use parent data as prototype for child;
+        child.tileSet = { ...this.tileSet };
+        child.tileSet.background = undefined;
+        const title = (_b = (_a = this.tileSet) === null || _a === void 0 ? void 0 : _a.title) !== null && _b !== void 0 ? _b : (_c = this.tileSet) === null || _c === void 0 ? void 0 : _c.name;
+        child.tileSet.title = `${title} ${titleizeImageryName(image.name)}`;
+        child.extentOverride = Bounds.fromJson(image.bounds);
+        const layer = { name: image.name, minZoom: 0, maxZoom: 100 };
+        layer[this.tileMatrix.projection.code] = image.id;
+        child.tileSet.layers = [layer];
+        child.imagery = new Map();
+        child.imagery.set(image.id, image);
+        return child;
+    }
+}

package/build/tile.set.vector.d.ts

@@ -0,0 +1,16 @@
+import { ConfigTileSetVector, TileSetType } from '@basemaps/config';
+import { TileDataXyz } from '@basemaps/shared';
+import { Cotar } from '@cotar/core';
+import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import { TileSetHandler } from './tile.set.js';
+declare class CotarCache {
+    cache: Map<string, Promise<Cotar | null>>;
+    get(uri: string): Promise<Cotar | null>;
+}
+export declare const Layers: CotarCache;
+export declare class TileSetVector extends TileSetHandler<ConfigTileSetVector> {
+    type: TileSetType;
+    tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse>;
+}
+export {};
+//# sourceMappingURL=tile.set.vector.d.ts.map

package/build/tile.set.vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile.set.vector.d.ts","sourceRoot":"","sources":["../src/tile.set.vector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAO,WAAW,EAAgB,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAc,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEnF,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,cAAM,UAAU;IACd,KAAK,qCAA4C;IAEjD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;CAQxC;AAED,eAAO,MAAM,MAAM,YAAmB,CAAC;AAEvC,qBAAa,aAAc,SAAQ,cAAc,CAAC,mBAAmB,CAAC;IACpE,IAAI,cAAsB;IAEpB,IAAI,CAAC,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAwBlF"}

package/build/tile.set.vector.js

@@ -0,0 +1,51 @@
+import { TileSetType } from '@basemaps/config';
+import { fsa, VectorFormat } from '@basemaps/shared';
+import { Cotar } from '@cotar/core';
+import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
+import { NotFound } from './routes/tile.js';
+import { TileSetHandler } from './tile.set.js';
+class CotarCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(uri) {
+        let cotar = this.cache.get(uri);
+        if (cotar == null) {
+            cotar = Cotar.fromTar(fsa.source(uri));
+            this.cache.set(uri, cotar);
+        }
+        return cotar;
+    }
+}
+export const Layers = new CotarCache();
+export class TileSetVector extends TileSetHandler {
+    constructor() {
+        super(...arguments);
+        this.type = TileSetType.Vector;
+    }
+    async tile(req, xyz) {
+        if (xyz.ext !== VectorFormat.MapboxVectorTiles)
+            return NotFound;
+        if (this.tileSet.layers.length > 1)
+            return new LambdaHttpResponse(500, 'Too many layers in tileset');
+        const [layer] = this.tileSet.layers;
+        if (layer[3857] == null)
+            return new LambdaHttpResponse(500, 'Layer url not found from tileset Config');
+        req.timer.start('cotar:load');
+        const cotar = await Layers.get(layer[3857]);
+        if (cotar == null)
+            return new LambdaHttpResponse(500, 'Failed to load VectorTiles');
+        req.timer.end('cotar:load');
+        // Flip Y coordinate because MBTiles files are TMS.
+        const y = (1 << xyz.z) - 1 - xyz.y;
+        req.timer.start('cotar:tile');
+        const tile = await cotar.get(`tiles/${xyz.z}/${xyz.x}/${y}.pbf.gz`, req.log);
+        if (tile == null)
+            return NotFound;
+        req.timer.end('cotar:tile');
+        const response = new LambdaHttpResponse(200, 'Ok');
+        response.buffer(Buffer.from(tile), 'application/x-protobuf');
+        response.header(HttpHeader.ContentEncoding, 'gzip');
+        return response;
+    }
+}

package/build/validate.d.ts

@@ -0,0 +1,16 @@
+import { TileDataXyz } from '@basemaps/shared';
+import { LambdaHttpRequest } from '@linzjs/lambda';
+export declare const ValidateTilePath: {
+    /**
+     * Validate that the tile request is somewhat valid
+     * - Valid projection
+     * - Valid range
+     *
+     * @throws LambdaHttpResponse for tile requests that are not valid
+     *
+     * @param req request to validate
+     * @param xyzData
+     */
+    validate(req: LambdaHttpRequest, xyzData: TileDataXyz): void;
+};
+//# sourceMappingURL=validate.d.ts.map

package/build/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAsB,MAAM,gBAAgB,CAAC;AAEvE,eAAO,MAAM,gBAAgB;IAC3B;;;;;;;;;OASG;kBACW,iBAAiB,WAAW,WAAW,GAAG,IAAI;CAiB7D,CAAC"}

package/build/validate.js

@@ -0,0 +1,31 @@
+import { Projection } from '@basemaps/shared';
+import { LambdaHttpResponse } from '@linzjs/lambda';
+export const ValidateTilePath = {
+    /**
+     * Validate that the tile request is somewhat valid
+     * - Valid projection
+     * - Valid range
+     *
+     * @throws LambdaHttpResponse for tile requests that are not valid
+     *
+     * @param req request to validate
+     * @param xyzData
+     */
+    validate(req, xyzData) {
+        const { tileMatrix, x, y, z, ext } = xyzData;
+        req.set('xyz', { x, y, z });
+        req.set('projection', tileMatrix.projection.code);
+        req.set('tileMatrix', tileMatrix.identifier);
+        req.set('extension', ext);
+        req.set('tileSet', xyzData.name);
+        if (z > tileMatrix.maxZoom || z < 0)
+            throw new LambdaHttpResponse(404, `Zoom not found: ${z}`);
+        const zoom = tileMatrix.zooms[z];
+        if (x < 0 || x > zoom.matrixWidth)
+            throw new LambdaHttpResponse(404, `X not found: ${x}`);
+        if (y < 0 || y > zoom.matrixHeight)
+            throw new LambdaHttpResponse(404, `Y not found: ${y}`);
+        const latLon = Projection.tileCenterToLatLon(tileMatrix, xyzData);
+        req.set('location', latLon);
+    },
+};

package/build/wmts.capability.d.ts

@@ -0,0 +1,24 @@
+import { ConfigProvider } from '@basemaps/config';
+import { Bounds, TileMatrixSet, WmtsProvider } from '@basemaps/geo';
+import { VNodeElement } from '@basemaps/shared';
+import { TileSetRaster } from './tile.set.raster.js';
+export declare class WmtsCapabilities {
+    httpBase: string;
+    provider: WmtsProvider;
+    layers: Map<string, TileSetRaster[]>;
+    apiKey?: string;
+    tileMatrixSets: Map<string, TileMatrixSet>;
+    constructor(httpBase: string, provider: WmtsProvider, layers: TileSetRaster[], apiKey?: string);
+    buildWgs84BoundingBox(layers: TileSetRaster[], tagName?: string): VNodeElement;
+    buildBoundingBox(tms: TileMatrixSet, extent: Bounds): VNodeElement;
+    buildProvider(): VNodeElement[];
+    buildTileUrl(tileSet: TileSetRaster, suffix: string): string;
+    buildResourceUrl(tileSet: TileSetRaster, suffix: string): VNodeElement;
+    buildLayer(layers: TileSetRaster[]): VNodeElement;
+    buildStyle(): VNodeElement;
+    buildTileMatrixSet(tms: TileMatrixSet): VNodeElement;
+    toVNode(): VNodeElement;
+    toString(): string;
+    static toXml(httpBase: string, provider: ConfigProvider, tileSet: TileSetRaster[], apiKey?: string): string;
+}
+//# sourceMappingURL=wmts.capability.d.ts.map

package/build/wmts.capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wmts.capability.d.ts","sourceRoot":"","sources":["../src/wmts.capability.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAmB,aAAa,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAiB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAG/D,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA0BrD,qBAAa,gBAAgB;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,YAAY,CAAC;IAEvB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAAa;IAEjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,6BAAoC;gBAEtC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM;IAmB9F,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,OAAO,SAAyB,GAAG,YAAY;IAe9F,gBAAgB,CAAC,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY;IAQlE,aAAa,IAAI,YAAY,EAAE;IAkC/B,YAAY,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAc5D,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY;IAQtE,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,YAAY;IAuBjD,UAAU,IAAI,YAAY;IAI1B,kBAAkB,CAAC,GAAG,EAAE,aAAa,GAAG,YAAY;IAoBpD,OAAO,IAAI,YAAY;IAUvB,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;CAG5G"}