@basemaps/lambda-tiler 6.15.0

package/build/__test__/xyz.test.js

@@ -0,0 +1,282 @@
+import { TileMatrixSets } from '@basemaps/geo';
+import { Config, Env, LogConfig, VNodeParser } from '@basemaps/shared';
+import { round } from '@basemaps/test/build/rounding.js';
+import o from 'ospec';
+import { handleRequest } from '../index.js';
+import { TileComposer } from '../routes/tile.js';
+import { TileEtag } from '../routes/tile.etag.js';
+import { TileSets } from '../tile.set.cache.js';
+import { FakeTileSet, mockRequest, Provider } from './xyz.util.js';
+import sinon from 'sinon';
+const sandbox = sinon.createSandbox();
+const TileSetNames = ['aerial', 'aerial@head', 'aerial@beta', '01E7PJFR9AMQFJ05X9G7FQ3XMW'];
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+o.spec('LambdaXyz', () => {
+    /** Generate mock ALBEvent */
+    let rasterMock = o.spy();
+    const generateMock = o.spy(() => 'foo');
+    const rasterMockBuffer = Buffer.from([1]);
+    const origTileEtag = TileEtag.generate;
+    const origCompose = TileComposer.compose;
+    const apiKey = 'd01f7w7rnhdzg0p7fyrc9v9ard1';
+    const apiKeyHeader = { 'x-linz-api-key': 'd01f7w7rnhdzg0p7fyrc9v9ard1' };
+    o.beforeEach(() => {
+        LogConfig.disable();
+        // tileMock = o.spy(() => tileMockData) as any;
+        rasterMock = o.spy(() => {
+            return {
+                buffer: rasterMockBuffer,
+            };
+        });
+        TileEtag.generate = generateMock;
+        TileComposer.compose = rasterMock;
+        const allMatrix = [...TileMatrixSets.All.values()];
+        for (const tileSetName of TileSetNames) {
+            for (const tileMatrix of allMatrix) {
+                const tileSet = new FakeTileSet(tileSetName, tileMatrix);
+                TileSets.add(tileSet);
+                tileSet.getTiffsForTile = () => [];
+                tileSet.initTiffs = async () => [];
+            }
+        }
+        Config.Provider.get = async () => Provider;
+    });
+    o.afterEach(() => {
+        TileSets.cache.clear();
+        TileComposer.compose = origCompose;
+        TileEtag.generate = origTileEtag;
+        sandbox.restore();
+    });
+    o('should export handler', async () => {
+        const base = await import('../index.js');
+        o(typeof base.handler).equals('function');
+    });
+    TileSetNames.forEach((tileSetName) => {
+        o(`should generate a tile 0,0,0 for ${tileSetName}.png`, async () => {
+            o.timeout(200);
+            const request = mockRequest(`/v1/tiles/${tileSetName}/global-mercator/0/0/0.png`, 'get', apiKeyHeader);
+            const res = await handleRequest(request);
+            o(res.status).equals(200);
+            o(res.header('content-type')).equals('image/png');
+            o(res.header('eTaG')).equals('foo');
+            o(res.body).equals(rasterMockBuffer.toString('base64'));
+            // Validate the session information has been set correctly
+            o(request.logContext['tileSet']).equals(tileSetName);
+            o(request.logContext['xyz']).deepEquals({ x: 0, y: 0, z: 0 });
+            o(round(request.logContext['location'])).deepEquals({ lat: 0, lon: 0 });
+        });
+    });
+    o('should generate a tile 0,0,0 for webp', async () => {
+        const request = mockRequest('/v1/tiles/aerial/3857/0/0/0.webp', 'get', apiKeyHeader);
+        const res = await handleRequest(request);
+        o(res.status).equals(200);
+        o(res.header('content-type')).equals('image/webp');
+        o(res.header('eTaG')).equals('foo');
+        o(res.body).equals(rasterMockBuffer.toString('base64'));
+        // Validate the session information has been set correctly
+        o(request.logContext['xyz']).deepEquals({ x: 0, y: 0, z: 0 });
+        o(round(request.logContext['location'])).deepEquals({ lat: 0, lon: 0 });
+    });
+    ['png', 'webp', 'jpeg'].forEach((fmt) => {
+        o(`should 200 with empty ${fmt} if a tile is out of bounds`, async () => {
+            // tiler.tile = async () => [];
+            const res = await handleRequest(mockRequest(`/v1/tiles/aerial/global-mercator/0/0/0.${fmt}`, 'get', apiKeyHeader));
+            o(res.status).equals(200);
+            o(res.header('content-type')).equals(`image/${fmt}`);
+            o(rasterMock.calls.length).equals(1);
+        });
+    });
+    o('should 304 if a tile is not modified', async () => {
+        const key = 'foo';
+        const request = mockRequest('/v1/tiles/aerial/global-mercator/0/0/0.png', 'get', {
+            'if-none-match': key,
+            ...apiKeyHeader,
+        });
+        const res = await handleRequest(request);
+        o(res.status).equals(304);
+        o(res.header('eTaG')).equals(undefined);
+        o(rasterMock.calls.length).equals(0);
+        o(request.logContext['cache']).deepEquals({ key, match: key, hit: true });
+    });
+    o('should 404 if a tile is outside of the range', async () => {
+        try {
+            const res = await handleRequest(mockRequest('/v1/tiles/aerial/global-mercator/25/0/0.png', 'get', apiKeyHeader));
+            o(res.status).equals(404);
+        }
+        catch (e) {
+            o(e.status).equals(404);
+        }
+        try {
+            const res = await handleRequest(mockRequest('/v1/tiles/aerial/2193/17/0/0.png', 'get', apiKeyHeader));
+            o(res.status).equals(404);
+        }
+        catch (e) {
+            o(e.status).equals(404);
+        }
+    });
+    o.spec('WMTSCapabilities', () => {
+        const origPublicUrlBase = process.env[Env.PublicUrlBase];
+        o.after(() => {
+            process.env[Env.PublicUrlBase] = origPublicUrlBase;
+        });
+        o('should 304 if a xml is not modified', async () => {
+            o.timeout(1000);
+            const key = 'NuirTK8fozzCJV1iG1FznmdHhKvk6WaWuDhhEA1d40c=';
+            const request = mockRequest('/v1/tiles/WMTSCapabilities.xml', 'get', {
+                'if-none-match': key,
+                ...apiKeyHeader,
+            });
+            const res = await handleRequest(request);
+            if (res.status === 200) {
+                o(res.header('eTaG')).equals(key); // this line is useful for discovering the new etag
+                return;
+            }
+            o(res.status).equals(304);
+            o(rasterMock.calls.length).equals(0);
+            o(request.logContext['cache']).deepEquals({ key, match: key, hit: true });
+        });
+        o('should serve WMTSCapabilities for tile_set', async () => {
+            var _a;
+            console.log('\n\nTestStart');
+            process.env[Env.PublicUrlBase] = 'https://tiles.test';
+            const request = mockRequest('/v1/tiles/aerial@beta/WMTSCapabilities.xml', 'get', apiKeyHeader);
+            const res = await handleRequest(request);
+            o(res.status).equals(200);
+            o(res.header('content-type')).equals('text/xml');
+            o(res.header('cache-control')).equals('max-age=0');
+            const body = Buffer.from((_a = res.body) !== null && _a !== void 0 ? _a : '', 'base64').toString();
+            o(body.slice(0, 100)).equals('<?xml version="1.0"?>\n' + '<Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.op');
+            const vdom = await VNodeParser.parse(body);
+            const url = vdom.tags('ResourceURL').next().value;
+            o(url === null || url === void 0 ? void 0 : url.toString()).equals('<ResourceURL format="image/jpeg" resourceType="tile" ' +
+                `template="https://tiles.test/v1/tiles/aerial@beta/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.jpeg?api=${apiKey}" />`);
+        });
+    });
+    o.spec('tileJson', () => {
+        const origPublicUrlBase = process.env[Env.PublicUrlBase];
+        o.after(() => {
+            process.env[Env.PublicUrlBase] = origPublicUrlBase;
+        });
+        o('should 304 if a json is not modified', async () => {
+            const key = 'XecTdbcdjCyzB1MHOOQbrOkD2TTJ0ORh4JuXqhxXEE0=';
+            const request = mockRequest('/v1/tiles/tile.json', 'get', { 'if-none-match': key, ...apiKeyHeader });
+            const res = await handleRequest(request);
+            if (res.status === 200) {
+                o(res.header('eTaG')).equals(key); // this line is useful for discovering the new etag
+                return;
+            }
+            o(res.status).equals(304);
+            o(rasterMock.calls.length).equals(0);
+            o(request.logContext['cache']).deepEquals({ key, match: key, hit: true });
+        });
+        o('should serve tile json for tile_set', async () => {
+            var _a;
+            process.env[Env.PublicUrlBase] = 'https://tiles.test';
+            const request = mockRequest('/v1/tiles/topolike/Google/tile.json', 'get', apiKeyHeader);
+            const res = await handleRequest(request);
+            o(res.status).equals(200);
+            o(res.header('content-type')).equals('application/json');
+            o(res.header('cache-control')).equals('max-age=120');
+            const body = Buffer.from((_a = res.body) !== null && _a !== void 0 ? _a : '', 'base64').toString();
+            o(JSON.parse(body)).deepEquals({
+                tiles: [`https://tiles.test/v1/tiles/topolike/Google/{z}/{x}/{y}.pbf?api=${apiKey}`],
+                minzoom: 0,
+                maxzoom: 15,
+                format: 'pbf',
+                tilejson: '2.0.0',
+            });
+        });
+    });
+    o.spec('styleJson', () => {
+        const origPublicUrlBase = process.env[Env.PublicUrlBase];
+        o.after(() => {
+            process.env[Env.PublicUrlBase] = origPublicUrlBase;
+        });
+        o('should not found style json', async () => {
+            process.env[Env.PublicUrlBase] = 'https://tiles.test';
+            const request = mockRequest('/v1/tiles/topolike/Google/style/topolike.json', 'get', apiKeyHeader);
+            sandbox.stub(Config.Style, 'get').resolves(null);
+            const res = await handleRequest(request);
+            o(res.status).equals(404);
+        });
+        o('should serve style json', async () => {
+            var _a;
+            const host = 'https://tiles.test';
+            process.env[Env.PublicUrlBase] = host;
+            const request = mockRequest('/v1/tiles/topolike/Google/style/topolike.json', 'get', apiKeyHeader);
+            const fakeStyle = {
+                version: 8,
+                id: 'test',
+                name: 'topolike',
+                sources: {
+                    basemaps_vector: {
+                        type: 'vector',
+                        url: `${host}/vector`,
+                    },
+                    basemaps_raster: {
+                        type: 'raster',
+                        tiles: [`${host}/raster`],
+                    },
+                    basemaps_raster_encode: {
+                        type: 'raster',
+                        tiles: [`${host}/raster/{z}/{x}/{y}.webp`], // Shouldn't encode the {}
+                    },
+                    test_vector: {
+                        type: 'vector',
+                        url: 'vector.url.co.nz',
+                    },
+                    test_raster: {
+                        type: 'raster',
+                        tiles: ['raster.url.co.nz'],
+                    },
+                },
+                layers: [
+                    {
+                        layout: {
+                            visibility: 'visible',
+                        },
+                        paint: {
+                            'background-color': 'rgba(206, 229, 242, 1)',
+                        },
+                        id: 'Background',
+                        type: 'background',
+                        minzoom: 0,
+                    },
+                ],
+                glyphs: 'glyphs',
+                sprite: 'sprite',
+                metadata: { id: 'test' },
+            };
+            const fakeRecord = {
+                id: 'st_topolike_production',
+                name: 'topolike',
+                style: fakeStyle,
+            };
+            sandbox.stub(Config.Style, 'get').resolves(fakeRecord);
+            const res = await handleRequest(request);
+            o(res.status).equals(200);
+            o(res.header('content-type')).equals('application/json');
+            o(res.header('cache-control')).equals('max-age=120');
+            const body = Buffer.from((_a = res.body) !== null && _a !== void 0 ? _a : '', 'base64').toString();
+            fakeStyle.sources.basemaps_vector = {
+                type: 'vector',
+                url: `${host}/vector?api=${apiKey}`,
+            };
+            fakeStyle.sources.basemaps_raster = {
+                type: 'raster',
+                tiles: [`${host}/raster?api=${apiKey}`],
+            };
+            fakeStyle.sources.basemaps_raster_encode = {
+                type: 'raster',
+                tiles: [`${host}/raster/{z}/{x}/{y}.webp?api=${apiKey}`],
+            };
+            o(JSON.parse(body)).deepEquals(fakeStyle);
+        });
+    });
+    ['/favicon.ico', '/index.html', '/foo/bar'].forEach((path) => {
+        o('should error on invalid paths: ' + path, async () => {
+            const res = await handleRequest(mockRequest(path, 'get', apiKeyHeader));
+            o(res.status).equals(404);
+        });
+    });
+});

package/build/__test__/xyz.util.d.ts

@@ -0,0 +1,10 @@
+import { ConfigProvider } from '@basemaps/config';
+import { TileMatrixSet } from '@basemaps/geo';
+import { LambdaHttpRequest } from '@linzjs/lambda';
+import { TileSetRaster } from '../tile.set.raster.js';
+export declare function mockRequest(path: string, method?: string, headers?: Record<string, string>): LambdaHttpRequest;
+export declare class FakeTileSet extends TileSetRaster {
+    constructor(name: string, tileMatrix: TileMatrixSet, title?: string, description?: string);
+}
+export declare const Provider: ConfigProvider;
+//# sourceMappingURL=xyz.util.d.ts.map

package/build/__test__/xyz.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xyz.util.d.ts","sourceRoot":"","sources":["../../src/__test__/xyz.util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAoB,MAAM,gBAAgB,CAAC;AAErE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAGtD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,SAAQ,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,iBAAiB,CAajH;AAED,qBAAa,WAAY,SAAQ,aAAa;gBAChC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,KAAK,SAAkB,EAAE,WAAW,SAAwB;CAIlH;AAED,eAAO,MAAM,QAAQ,EAAE,cA4BtB,CAAC"}

package/build/__test__/xyz.util.js

@@ -0,0 +1,48 @@
+import { LambdaAlbRequest } from '@linzjs/lambda';
+import { LogConfig } from '@basemaps/shared';
+import { TileSetRaster } from '../tile.set.raster.js';
+export function mockRequest(path, method = 'get', headers = {}) {
+    return new LambdaAlbRequest({
+        requestContext: null,
+        httpMethod: method.toUpperCase(),
+        path,
+        headers,
+        body: null,
+        isBase64Encoded: false,
+    }, {}, LogConfig.get());
+}
+export class FakeTileSet extends TileSetRaster {
+    constructor(name, tileMatrix, title = `${name}:title`, description = `${name}:description`) {
+        super(name, tileMatrix);
+        this.tileSet = { title, description };
+    }
+}
+export const Provider = {
+    createdAt: Date.now(),
+    name: 'main',
+    id: 'pv_main_production',
+    updatedAt: Date.now(),
+    version: 1,
+    serviceIdentification: {
+        accessConstraints: 'the accessConstraints',
+        description: 'the description',
+        fees: 'the fees',
+        title: 'the title',
+    },
+    serviceProvider: {
+        contact: {
+            address: {
+                city: 'the city',
+                country: 'the country',
+                deliveryPoint: 'the deliveryPoint',
+                email: 'email address',
+                postalCode: 'the postalCode',
+            },
+            individualName: 'the contact name',
+            phone: 'the phone',
+            position: 'the position',
+        },
+        name: 'the name',
+        site: 'https://example.provider.com',
+    },
+};

package/build/api.key.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidApiKey(apiKey?: string | null): boolean;
+//# sourceMappingURL=api.key.d.ts.map

package/build/api.key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.key.d.ts","sourceRoot":"","sources":["../src/api.key.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAgB7D"}

package/build/api.key.js

@@ -0,0 +1,23 @@
+import * as ulid from 'ulid';
+const OneHourMs = 60 * 60 * 1000;
+const OneDayMs = 24 * OneHourMs;
+const MaxApiAgeMs = 91 * OneDayMs;
+export function isValidApiKey(apiKey) {
+    if (apiKey == null)
+        return false;
+    if (!apiKey.startsWith('c') && !apiKey.startsWith('d'))
+        return false;
+    const ulidId = apiKey.slice(1).toUpperCase();
+    try {
+        const ulidTime = ulid.decodeTime(ulidId);
+        if (apiKey.startsWith('d'))
+            return true;
+        if (Date.now() - ulidTime > MaxApiAgeMs) {
+            return false;
+        }
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}

package/build/cli/dump.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dump.d.ts.map

package/build/cli/dump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dump.d.ts","sourceRoot":"","sources":["../../src/cli/dump.ts"],"names":[],"mappings":""}

package/build/cli/dump.js

@@ -0,0 +1,48 @@
+import { Nztm2000Tms } from '@basemaps/geo';
+import { LogConfig } from '@basemaps/shared';
+import { ImageFormat } from '@basemaps/tiler';
+import { LambdaAlbRequest } from '@linzjs/lambda';
+import { promises as fs } from 'fs';
+import { TileRoute } from '../routes/tile.js';
+import { TileSets } from '../tile.set.cache.js';
+import { TileSetLocal } from './tile.set.local.js';
+const xyz = { x: 0, y: 0, z: 0 };
+const tileMatrix = Nztm2000Tms;
+const tileSetName = 'aerial';
+const ext = ImageFormat.PNG;
+/** Load a tileset form a file path otherwise default to the hard coded one from AWS */
+async function getTileSet(filePath) {
+    if (filePath != null) {
+        const tileSet = new TileSetLocal('local', filePath);
+        await tileSet.load();
+        TileSets.add(tileSet);
+        return tileSet;
+    }
+    const tileSet = await TileSets.get(tileSetName, tileMatrix);
+    if (tileSet == null)
+        throw new Error('Missing');
+    return tileSet;
+}
+/**
+ * Utility to render a single tile then save it as a png
+ */
+async function main() {
+    var _a;
+    const logger = LogConfig.get();
+    const filePath = process.argv[2];
+    const tileSet = await getTileSet(filePath);
+    logger.info({ ...xyz, projection: tileMatrix.projection.code, tileMatrix: tileMatrix.identifier }, 'RenderTile');
+    const ctx = new LambdaAlbRequest({
+        httpMethod: 'get',
+        path: `/v1/tiles/${tileSet.fullName}/${tileMatrix.identifier}/${xyz.z}/${xyz.x}/${xyz.y}.${ext}`,
+    }, {}, logger);
+    const tileData = await TileRoute.tile(ctx);
+    const headers = {};
+    for (const [key, value] of tileData.headers)
+        headers[key] = value;
+    logger.info({ ...tileData, _body: (_a = tileData.body) === null || _a === void 0 ? void 0 : _a.length, headers }, 'Done');
+    if (tileData._body != null) {
+        await fs.writeFile(`output_${xyz.x}_${xyz.y}_z${xyz.z}.${ext}`, tileData._body);
+    }
+}
+main().catch(console.error);

package/build/cli/serve.d.ts

@@ -0,0 +1,2 @@
+import 'source-map-support/register.js';
+//# sourceMappingURL=serve.d.ts.map

package/build/cli/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":"AAMA,OAAO,gCAAgC,CAAC"}

package/build/cli/serve.js

@@ -0,0 +1,116 @@
+import { Epsg } from '@basemaps/geo';
+import { Env, LogConfig } from '@basemaps/shared';
+import { HttpHeader, LambdaAlbRequest } from '@linzjs/lambda';
+import express from 'express';
+import path from 'path';
+import 'source-map-support/register.js';
+import * as ulid from 'ulid';
+import url from 'url';
+import * as lambda from '../index.js';
+import { TileSets } from '../tile.set.cache.js';
+import { WmtsCapabilities } from '../wmts.capability.js';
+import { Provider } from '../__test__/xyz.util.js';
+import { TileSetLocal } from './tile.set.local.js';
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const app = express();
+const port = Env.getNumber('PORT', 5050);
+async function handleRequest(ctx, res, startTime, logger, logInfo = {}) {
+    try {
+        const data = await lambda.handleRequest(ctx);
+        res.status(data.status);
+        if (data.headers) {
+            for (const [header, value] of data.headers) {
+                res.header(header, String(value));
+            }
+        }
+        if (data.status < 299 && data.status > 199) {
+            res.end(data.body);
+        }
+        else {
+            res.end();
+        }
+        const duration = Date.now() - startTime;
+        logger.info({ ...ctx.logContext, ...logInfo, metrics: ctx.timer.metrics, status: data.status, duration }, 'Done');
+    }
+    catch (e) {
+        logger.fatal({ ...ctx.logContext, err: e }, 'FailedToRender');
+        res.status(500);
+        res.end();
+    }
+}
+function useAws() {
+    app.get('/v1/*', async (req, res) => {
+        const startTime = Date.now();
+        const requestId = ulid.ulid();
+        const logger = LogConfig.get().child({ id: requestId });
+        const ctx = new LambdaAlbRequest({
+            httpMethod: 'get',
+            path: req.path,
+            queryStringParameters: req.query,
+        }, { awsRequestId: requestId }, logger);
+        const ifNoneMatch = req.header(HttpHeader.IfNoneMatch);
+        if (ifNoneMatch != null) {
+            ctx.headers.set(HttpHeader.IfNoneMatch.toLowerCase(), ifNoneMatch);
+        }
+        await handleRequest(ctx, res, startTime, logger);
+    });
+    app.use(express.static(__dirname + '/../../../landing/dist/'));
+    LogConfig.get().info({ port, base: process.env[Env.PublicUrlBase], aws: process.env['AWS_PROFILE'] }, 'Listen');
+}
+async function useLocal() {
+    let projection = Epsg.Google.code;
+    const filePath = process.argv[2];
+    const tileSetName = 'local';
+    if (filePath != null) {
+        const tileSet = new TileSetLocal(tileSetName, filePath);
+        await tileSet.load();
+        const tiffFiles = tileSet.tiffs.map((c) => c.source.uri).join(', ');
+        // TODO is there a better name for this
+        tileSet.setTitle(`Local - ${tiffFiles}`);
+        TileSets.add(tileSet);
+        LogConfig.get().info({ tileSets: [...TileSets.cache.keys()] }, 'LoadedTileSets');
+        projection = tileSet.tileMatrix.projection.code;
+    }
+    app.get('/v1/tiles/:imageryName/:projection/:z/:x/:y.:ext', async (req, res) => {
+        const startTime = Date.now();
+        const requestId = ulid.ulid();
+        const logger = LogConfig.get().child({ id: requestId });
+        const { x, y, z, ext, imageryName, projection } = req.params;
+        const ctx = new LambdaAlbRequest({
+            httpMethod: 'get',
+            path: `/v1/tiles/${imageryName}/${projection}/${z}/${x}/${y}.${ext}`,
+        }, {}, logger);
+        await handleRequest(ctx, res, startTime, logger, { tile: { x, y, z } });
+    });
+    app.get('/v1/WMTSCapabilities.xml', async (req, res) => {
+        var _a;
+        const startTime = Date.now();
+        const requestId = ulid.ulid();
+        const logger = LogConfig.get().child({ id: requestId });
+        const tileSets = await Promise.all([...TileSets.cache.values()].map((c) => c.value));
+        const xml = WmtsCapabilities.toXml((_a = Env.get(Env.PublicUrlBase)) !== null && _a !== void 0 ? _a : '', Provider, tileSets.filter((f) => (f === null || f === void 0 ? void 0 : f.type) === 'raster'));
+        res.header('content-type', 'application/xml');
+        res.send(xml);
+        res.end();
+        const duration = Date.now() - startTime;
+        logger.info({ path: req.url, duration, status: 200 }, 'Done');
+    });
+    app.use(express.static(__dirname + '/../../../landing/dist/'));
+    const url = Env.get(Env.PublicUrlBase) + `/?i=${tileSetName}&p=${projection}`;
+    const wmts = Env.get(Env.PublicUrlBase) + `/v1/WMTSCapabilities.xml`;
+    const xyz = Env.get(Env.PublicUrlBase) + `/v1/tiles/${tileSetName}/${projection}/{z}/{x}/{y}.png`;
+    LogConfig.get().info({ url, wmts, xyz }, 'Listen');
+}
+async function main() {
+    if (Env.get(Env.PublicUrlBase) == null || Env.get(Env.PublicUrlBase) === '') {
+        process.env[Env.PublicUrlBase] = `http://localhost:${port}`;
+    }
+    if (process.argv.length < 3) {
+        useAws();
+    }
+    else {
+        await useLocal();
+    }
+    await new Promise((resolve) => app.listen(port, resolve));
+}
+main().catch((e) => console.error(e));

package/build/cli/tile.set.local.d.ts

@@ -0,0 +1,12 @@
+import { CogTiff } from '@cogeotiff/core';
+import { TileSetRaster } from '../tile.set.raster.js';
+export declare class TileSetLocal extends TileSetRaster {
+    tiffs: CogTiff[];
+    filePath: string;
+    tileSet: any;
+    constructor(name: string, path: string);
+    setTitle(name: string): void;
+    load(): Promise<boolean>;
+    getTiffsForTile(): CogTiff[];
+}
+//# sourceMappingURL=tile.set.local.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tile.set.local.d.ts","sourceRoot":"","sources":["../../src/cli/tile.set.local.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAc,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAMtD,qBAAa,YAAa,SAAQ,aAAa;IAC7C,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,MAAa;gBAER,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAQtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAItB,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAqB9B,eAAe,IAAI,OAAO,EAAE;CAG7B"}

package/build/cli/tile.set.local.js

@@ -0,0 +1,39 @@
+import { Epsg, GoogleTms, TileMatrixSets } from '@basemaps/geo';
+import { fsa, LogConfig } from '@basemaps/shared';
+import { CogTiff, TiffTagGeo } from '@cogeotiff/core';
+import { TileSetRaster } from '../tile.set.raster.js';
+function isTiff(fileName) {
+    return fileName.toLowerCase().endsWith('.tif') || fileName.toLowerCase().endsWith('.tiff');
+}
+export class TileSetLocal extends TileSetRaster {
+    constructor(name, path) {
+        super(name, GoogleTms);
+        this.tileSet = {};
+        this.filePath = path;
+        this.tileSet.name = name;
+        this.tileSet.title = name;
+        this.tileSet.projection = GoogleTms.projection.code;
+    }
+    setTitle(name) {
+        this.tileSet.title = name;
+    }
+    async load() {
+        if (this.tiffs != null)
+            return true;
+        const fileList = isTiff(this.filePath) ? [this.filePath] : await fsa.toArray(fsa.list(this.filePath));
+        const files = fileList.filter(isTiff);
+        if (files.length === 0)
+            throw new Error(`No tiff files found in ${this.filePath}`);
+        this.tiffs = files.map((filePath) => new CogTiff(fsa.source(filePath)));
+        // Read in the projection information
+        const [firstTiff] = this.tiffs;
+        await firstTiff.init(true);
+        const projection = Epsg.get(firstTiff.getImage(0).valueGeo(TiffTagGeo.ProjectedCSTypeGeoKey));
+        this.tileMatrix = TileMatrixSets.get(projection);
+        LogConfig.get().info({ path: this.filePath, count: this.tiffs.length, tileMatrix: this.tileMatrix.identifier }, 'LoadedTiffs');
+        return true;
+    }
+    getTiffsForTile() {
+        return this.tiffs;
+    }
+}

package/build/cli/validate.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate.d.ts.map

package/build/cli/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/cli/validate.ts"],"names":[],"mappings":""}