@basemaps/lambda-tiler 6.30.0 → 6.32.1

package/src/__tests__/tile.cache.key.test.ts

@@ -1,56 +0,0 @@
-import { GoogleTms, Nztm2000Tms, ImageFormat } from '@basemaps/geo';
-import { TileDataXyz, TileType } from '@basemaps/shared';
-import { TestTiff } from '@basemaps/test';
-import { Composition } from '@basemaps/tiler';
-import o from 'ospec';
-import { TileEtag } from '../routes/tile.etag.js';
-
-o.spec('TileCacheKey', () => {
-  const oldRenderId = TileEtag.RenderId;
-
-  const xyzData: TileDataXyz = {
-    x: 0,
-    y: 0,
-    z: 0,
-    tileMatrix: GoogleTms,
-    name: 'foo',
-    ext: ImageFormat.Png,
-    type: TileType.Tile,
-  };
-
-  o.afterEach(() => {
-    TileEtag.RenderId = oldRenderId;
-  });
-
-  o('should generate a cachekey', async () => {
-    const tiff = await TestTiff.Google.init();
-    const comp: Composition = {
-      tiff,
-      source: {
-        x: 0,
-        y: 0,
-        imageId: 0,
-        width: 512,
-        height: 512,
-      },
-      x: 5,
-      y: 5,
-    };
-    const firstKey = TileEtag.generate([comp], xyzData);
-    o(firstKey).equals('8eJ7XnUeEGBI2d7mfAaK5o8KbUc0+CVaIoPzqCvkoDk=');
-
-    // Different layers should generate different keys
-    o(TileEtag.generate([comp, comp], xyzData)).notEquals(firstKey);
-
-    // Different projections should generate different keys
-    xyzData.tileMatrix = Nztm2000Tms;
-    o(TileEtag.generate([comp], xyzData)).notEquals(firstKey);
-  });
-
-  o('should change if the renderId changes', () => {
-    const keyA = TileEtag.generate([], { tileMatrix: {} } as any);
-    TileEtag.RenderId = 2;
-    const KeyB = TileEtag.generate([], { tileMatrix: {} } as any);
-    o(keyA).notEquals(KeyB);
-  });
-});

package/src/__tests__/tile.set.cache.test.ts

@@ -1,80 +0,0 @@
-import { ConfigImagery, ConfigTileSetRaster, TileSetType } from '@basemaps/config';
-import { GoogleTms } from '@basemaps/geo';
-import o from 'ospec';
-import sinon from 'sinon';
-import { TileSets } from '../tile.set.cache.js';
-import { TileSetRaster } from '../tile.set.raster.js';
-const sandbox = sinon.createSandbox();
-o.spec('TileSetCache', () => {
-  const imageOne = {
-    id: 'im_id1',
-    name: 'tasman_rural_2018-19_0-3m',
-    bounds: { x: 123, y: 456, width: 200, height: 300 },
-    files: [{ name: 'foo', x: 123, y: 456, width: 200, height: 300 }],
-    uri: 's3://foo/bar',
-  } as ConfigImagery;
-
-  const imgMap = new Map<string, ConfigImagery>();
-  imgMap.set(imageOne.id, imageOne);
-
-  o.afterEach(() => {
-    TileSets.cache.clear();
-    sandbox.restore();
-  });
-
-  o.spec('loadTileSet', () => {
-    o('load individual set', async () => {
-      TileSets.add(new TileSetRaster('aerial@head', GoogleTms));
-
-      const parentTileSet = await TileSets.get('aerial@head', GoogleTms);
-      if (parentTileSet == null || parentTileSet.type === TileSetType.Vector) throw new Error('null parentTileSet');
-      parentTileSet.imagery = imgMap;
-      parentTileSet.tileSet = {
-        name: 'parent',
-        title: 'parent aerial title',
-        background: { r: 200, g: 50, b: 100, alpha: 0.5 },
-      } as ConfigTileSetRaster;
-
-      const subTileSet = await TileSets.get('aerial@head:tasman_rural_2018-19_0-3m', GoogleTms);
-      if (subTileSet == null || subTileSet.type === TileSetType.Vector) throw new Error('null subTileSet');
-
-      o(subTileSet.title).equals('parent aerial title Tasman rural 2018-19 0.3m');
-      o(subTileSet.fullName).equals('aerial@head:tasman_rural_2018-19_0-3m');
-      o([...subTileSet.imagery.values()]).deepEquals([imageOne]);
-      const [firstLayer] = subTileSet.tileSet.layers;
-      o(firstLayer).deepEquals({
-        name: firstLayer.name,
-        [3857]: 'im_id1',
-        minZoom: 0,
-        maxZoom: 100,
-      });
-      o(subTileSet.tileSet.background).equals(undefined);
-
-      o(parentTileSet.tileSet.background).deepEquals({ r: 200, g: 50, b: 100, alpha: 0.5 });
-
-      const noTiffs = subTileSet.getTiffsForTile({ x: 0, y: 0, z: 1 });
-      o(noTiffs).deepEquals([]);
-
-      const aTiff = subTileSet.getTiffsForTile({ x: 0, y: 0, z: 0 });
-      o(aTiff.length).equals(1);
-      o(aTiff[0].source.uri).equals('s3://foo/bar/foo.tiff');
-
-      TileSets.cache.delete(subTileSet.id);
-      delete parentTileSet.tileSet.title;
-      const subTileSetB = await TileSets.get('aerial@head:tasman_rural_2018-19_0-3m', GoogleTms);
-      if (subTileSetB == null || subTileSetB.type === TileSetType.Vector) throw new Error('null subTileSetB');
-      o(subTileSetB.title).equals('parent Tasman rural 2018-19 0.3m');
-    });
-
-    o('should not throw if child does not exist', async () => {
-      TileSets.add(new TileSetRaster('aerial@head', GoogleTms));
-
-      const parentTileSet = await TileSets.get('aerial@head', GoogleTms);
-      if (parentTileSet == null || parentTileSet.type === TileSetType.Vector) throw new Error('null parentTileSet');
-      parentTileSet.imagery = imgMap;
-
-      const subTileSet = await TileSets.get('aerial@head:fake', GoogleTms);
-      o(subTileSet).equals(null);
-    });
-  });
-});

package/src/__tests__/tile.set.test.ts

@@ -1,12 +0,0 @@
-import { GoogleTms, Nztm2000Tms } from '@basemaps/geo';
-import o from 'ospec';
-import { TileSetRaster } from '../tile.set.raster.js';
-
-o.spec('tile.set', () => {
-  o('extent', () => {
-    o(new TileSetRaster('google', GoogleTms).extent.toBbox()).deepEquals([
-      -20037508.3427892, -20037508.3427892, 20037508.3427892, 20037508.3427892,
-    ]);
-    o(new TileSetRaster('nztm', Nztm2000Tms).extent.toBbox()).deepEquals([274000, 3087000, 3327000, 7173000]);
-  });
-});

package/src/__tests__/xyz.test.ts

@@ -1,318 +0,0 @@
-import { ConfigProvider, StyleJson } from '@basemaps/config';
-import { GoogleTms, Nztm2000QuadTms, TileMatrixSets } from '@basemaps/geo';
-import { Config, Env, LogConfig } from '@basemaps/shared';
-import { round } from '@basemaps/test/build/rounding.js';
-import o from 'ospec';
-import sinon from 'sinon';
-import { handleRequest } from '../index.js';
-import { TileEtag } from '../routes/tile.etag.js';
-import { TileSets } from '../tile.set.cache.js';
-import { TileComposer } from '../tile.set.raster.js';
-import { Provider } from './config.data.js';
-import { FakeTileSet, FakeTileSetVector, mockRequest } from './xyz.util.js';
-
-const sandbox = sinon.createSandbox();
-
-const TileSetNames = ['aerial', 'aerial@head', 'aerial@beta', '01E7PJFR9AMQFJ05X9G7FQ3XMW'];
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
-o.spec('LambdaXyz', () => {
-  const host = 'https://tiles.test';
-  const origPublicUrlBase = process.env[Env.PublicUrlBase];
-
-  /** 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(() => {
-    process.env[Env.PublicUrlBase] = host;
-
-    LogConfig.disable();
-    // tileMock = o.spy(() => tileMockData) as any;
-    rasterMock = o.spy(() => {
-      return {
-        buffer: rasterMockBuffer,
-      };
-    }) as any;
-
-    TileEtag.generate = generateMock;
-    TileComposer.compose = rasterMock as any;
-
-    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 () => [];
-      }
-    }
-
-    TileSets.add(new FakeTileSetVector('topographic', GoogleTms));
-
-    (Config.Provider as any).get = async (): Promise<ConfigProvider> => Provider;
-  });
-
-  o.afterEach(() => {
-    TileSets.cache.clear();
-    TileComposer.compose = origCompose;
-    TileEtag.generate = origTileEtag;
-    process.env[Env.PublicUrlBase] = origPublicUrlBase;
-    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: any) {
-      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: any) {
-      o(e.status).equals(404);
-    }
-  });
-
-  o.spec('tileJson', () => {
-    o('should 404 if invalid url is given', async () => {
-      const request = mockRequest('/v1/tiles/tile.json', 'get', apiKeyHeader);
-
-      const res = await handleRequest(request);
-      o(res.status).equals(404);
-    });
-
-    o('should serve tile json for tile_set', async () => {
-      const request = mockRequest('/v1/tiles/aerial/NZTM2000Quad/tile.json', 'get', apiKeyHeader);
-
-      const res = await handleRequest(request);
-      o(res.status).equals(200);
-      o(res.header('cache-control')).equals('no-store');
-
-      const body = Buffer.from(res.body ?? '', 'base64').toString();
-      o(JSON.parse(body)).deepEquals({
-        tiles: [`https://tiles.test/v1/tiles/aerial/NZTM2000Quad/{z}/{x}/{y}.webp?api=${apiKey}`],
-        tilejson: '3.0.0',
-      });
-    });
-
-    o('should serve vector tiles', async () => {
-      const request = mockRequest('/v1/tiles/topographic/WebMercatorQuad/tile.json', 'get', apiKeyHeader);
-
-      const res = await handleRequest(request);
-      o(res.status).equals(200);
-
-      const body = Buffer.from(res.body ?? '', 'base64').toString();
-      o(JSON.parse(body)).deepEquals({
-        tiles: [`https://tiles.test/v1/tiles/topographic/WebMercatorQuad/{z}/{x}/{y}.pbf?api=${apiKey}`],
-        tilejson: '3.0.0',
-      });
-    });
-
-    o('should serve vector tiles with min/max zoom', async () => {
-      const fakeTileSet = new FakeTileSetVector('fake-vector', GoogleTms);
-      fakeTileSet.tileSet.maxZoom = 15;
-      fakeTileSet.tileSet.minZoom = 3;
-      TileSets.add(fakeTileSet);
-      const request = mockRequest('/v1/tiles/fake-vector/WebMercatorQuad/tile.json', 'get', apiKeyHeader);
-
-      const res = await handleRequest(request);
-      o(res.status).equals(200);
-
-      const body = Buffer.from(res.body ?? '', 'base64').toString();
-      o(JSON.parse(body)).deepEquals({
-        tiles: [`https://tiles.test/v1/tiles/fake-vector/WebMercatorQuad/{z}/{x}/{y}.pbf?api=${apiKey}`],
-        maxzoom: 15,
-        minzoom: 3,
-        tilejson: '3.0.0',
-      });
-    });
-
-    o('should serve convert zoom to tile matrix', async () => {
-      const fakeTileSet = new FakeTileSetVector('fake-vector', Nztm2000QuadTms);
-      fakeTileSet.tileSet.maxZoom = 15;
-      fakeTileSet.tileSet.minZoom = 1;
-      TileSets.add(fakeTileSet);
-
-      const request = mockRequest('/v1/tiles/fake-vector/NZTM2000Quad/tile.json', 'get', apiKeyHeader);
-
-      const res = await handleRequest(request);
-      o(res.status).equals(200);
-
-      const body = Buffer.from(res.body ?? '', 'base64').toString();
-      o(JSON.parse(body)).deepEquals({
-        tiles: [`https://tiles.test/v1/tiles/fake-vector/NZTM2000Quad/{z}/{x}/{y}.pbf?api=${apiKey}`],
-        maxzoom: 13,
-        minzoom: 0,
-        tilejson: '3.0.0',
-      });
-    });
-  });
-
-  o.spec('styleJson', () => {
-    o('should not found style json', async () => {
-      const request = mockRequest('/v1/tiles/topographic/Google/style/topographic.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 () => {
-      const request = mockRequest('/v1/tiles/topographic/Google/style/topographic.json', 'get', apiKeyHeader);
-
-      const fakeStyle: StyleJson = {
-        version: 8,
-        id: 'test',
-        name: 'topographic',
-        sources: {
-          basemaps_vector: {
-            type: 'vector',
-            url: `/vector`,
-          },
-          basemaps_raster: {
-            type: 'raster',
-            tiles: [`/raster`],
-          },
-          basemaps_raster_encode: {
-            type: 'raster',
-            tiles: [`/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_topographic_production',
-        name: 'topographic',
-        style: fakeStyle,
-      };
-
-      sandbox.stub(Config.Style, 'get').resolves(fakeRecord as any);
-
-      const res = await handleRequest(request);
-      o(res.status).equals(200);
-      o(res.header('content-type')).equals('application/json');
-      o(res.header('cache-control')).equals('no-store');
-
-      const body = Buffer.from(res.body ?? '', '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}`],
-      };
-
-      fakeStyle.sprite = `${host}/sprite`;
-      fakeStyle.glyphs = `${host}/glyphs`;
-
-      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/src/api.key.ts

@@ -1,23 +0,0 @@
-import * as ulid from 'ulid';
-
-const OneHourMs = 60 * 60 * 1000;
-const OneDayMs = 24 * OneHourMs;
-const MaxApiAgeMs = 91 * OneDayMs;
-
-export function isValidApiKey(apiKey?: string | null): boolean {
-  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/src/cli/dump.ts

@@ -1,61 +0,0 @@
-import { Nztm2000Tms, ImageFormat } from '@basemaps/geo';
-import { LogConfig } from '@basemaps/shared';
-import { LambdaAlbRequest } from '@linzjs/lambda';
-import { Context } from 'aws-lambda';
-import { promises as fs } from 'fs';
-import { tileXyz } from '../routes/tile.xyz.js';
-import { TileSets } from '../tile.set.cache.js';
-import { TileSet } from '../tile.set.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?: string): Promise<TileSet> {
-  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(): Promise<void> {
-  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}`,
-    } as any,
-    {} as Context,
-    logger,
-  );
-
-  const tileData = await tileXyz(ctx);
-
-  const headers: Record<string, any> = {};
-  for (const [key, value] of tileData.headers) headers[key] = value;
-
-  logger.info({ ...tileData, _body: tileData.body?.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/src/cli/tile.set.local.ts

@@ -1,51 +0,0 @@
-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: string): boolean {
-  return fileName.toLowerCase().endsWith('.tif') || fileName.toLowerCase().endsWith('.tiff');
-}
-
-export class TileSetLocal extends TileSetRaster {
-  tiffs: CogTiff[];
-  filePath: string;
-  tileSet = {} as any;
-
-  constructor(name: string, path: string) {
-    super(name, GoogleTms);
-    this.filePath = path;
-    this.tileSet.name = name;
-    this.tileSet.title = name;
-    this.tileSet.projection = GoogleTms.projection.code;
-  }
-
-  setTitle(name: string): void {
-    this.tileSet.title = name;
-  }
-
-  async load(): Promise<boolean> {
-    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) as number);
-    this.tileMatrix = TileMatrixSets.get(projection);
-    LogConfig.get().info(
-      { path: this.filePath, count: this.tiffs.length, tileMatrix: this.tileMatrix.identifier },
-      'LoadedTiffs',
-    );
-    return true;
-  }
-
-  getTiffsForTile(): CogTiff[] {
-    return this.tiffs;
-  }
-}

package/src/cotar.cache.ts

@@ -1,54 +0,0 @@
-import { fsa } from '@chunkd/fs';
-import { Cotar } from '@cotar/core';
-import { LambdaHttpResponse } from '@linzjs/lambda';
-import { NotFound } from './routes/response.js';
-import { St } from './source.tracer.js';
-
-export class CotarCache {
-  static cache = new Map<string, Promise<Cotar | null>>();
-
-  static get(uri: string): Promise<Cotar | null> {
-    let existing = CotarCache.cache.get(uri);
-    if (existing == null) {
-      const source = fsa.source(uri);
-      St.trace(source);
-      existing = Cotar.fromTar(source);
-      CotarCache.cache.set(uri, existing);
-    }
-    return existing;
-  }
-}
-
-/**
- *  Load a cotar and look for a file inside the cotar returning the file back as a LambdaResponse
- *
- * This will also set two headers
- * - Content-Encoding if the file starts with gzip magic
- * - Content-Type from the parameter contentType
- */
-export async function serveFromCotar(
-  cotarPath: string,
-  assetPath: string,
-  contentType: string,
-): Promise<LambdaHttpResponse> {
-  const cotar = await CotarCache.get(cotarPath);
-  if (cotar == null) return NotFound;
-  const fileData = await cotar.get(assetPath);
-  if (fileData == null) return NotFound;
-  const buf = Buffer.from(fileData);
-  const ret = LambdaHttpResponse.ok().buffer(buf, contentType);
-  if (isGzip(buf)) ret.header('content-encoding', 'gzip');
-  return ret;
-}
-
-/**
- * Does a buffer look like a gzipped document instead of raw json
- *
- * Determined by checking the first two bytes are the gzip magic bytes `0x1f 0x8b`
- *
- * @see https://en.wikipedia.org/wiki/Gzip
- *
- */
-export function isGzip(b: Buffer): boolean {
-  return b[0] === 0x1f && b[1] === 0x8b;
-}