@basemaps/lambda-tiler 6.15.0

package/src/routes/attribution.ts

@@ -0,0 +1,245 @@
+import { ConfigImagery, ConfigLayer, ConfigProvider } from '@basemaps/config';
+import {
+  AttributionCollection,
+  AttributionItem,
+  AttributionStac,
+  Bounds,
+  GoogleTms,
+  NamedBounds,
+  Stac,
+  StacCollection,
+  StacExtent,
+  TileMatrixSet,
+} from '@basemaps/geo';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+import {
+  CompositeError,
+  Config,
+  extractYearRangeFromName,
+  fsa,
+  Projection,
+  setNameAndProjection,
+  tileAttributionFromPath,
+  titleizeImageryName,
+} from '@basemaps/shared';
+import { BBox, MultiPolygon, multiPolygonToWgs84, Pair, union, Wgs84 } from '@linzjs/geojson';
+import { createHash } from 'crypto';
+import { TileSets } from '../tile.set.cache.js';
+import { TileSetRaster } from '../tile.set.raster.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: number): number {
+  return Math.round(n * Precision) / Precision;
+}
+
+function roundPair(p: Pair): Pair {
+  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: BBox, files: NamedBounds[], proj: Projection): MultiPolygon {
+  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: MultiPolygon = [];
+
+  // merge imagery bounds
+  for (const image of files) {
+    const poly = [Bounds.fromJson(image).pad(SmoothPadding).toPolygon()] as MultiPolygon;
+    coordinates = union(coordinates, poly);
+  }
+
+  const roundToWgs84 = (p: number[]): number[] => roundPair(proj.toWgs84(p) as Pair);
+
+  return multiPolygonToWgs84(coordinates, roundToWgs84);
+}
+
+async function readStac(uri: string): Promise<StacCollection | null> {
+  try {
+    return await fsa.readJson<StacCollection>(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?: Record<string, unknown>): number | null {
+  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: TileSetRaster,
+  stac: StacCollection | null | undefined,
+  imagery: ConfigImagery,
+  layer: ConfigLayer,
+  host: ConfigProvider,
+  extent: StacExtent,
+): AttributionCollection {
+  const tileMatrix = tileSet.tileMatrix;
+  return {
+    stac_version: Stac.Version,
+    license: stac?.license ?? Stac.License,
+    id: imagery.id,
+    providers: stac?.providers ?? [
+      { name: host.serviceProvider.name, url: host.serviceProvider.site, roles: ['host'] },
+    ],
+    title: stac?.title ?? titleizeImageryName(imagery.name),
+    description: stac?.description ?? 'No description',
+    extent,
+    links: [],
+    summaries: {
+      gsd: [getGsd(stac?.summaries) ?? 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: TileSetRaster): Promise<AttributionStac | null> {
+  const proj = Projection.get(tileSet.tileMatrix);
+  const stacFiles = new Map<string, Promise<StacCollection | null>>();
+  const cols: AttributionCollection[] = [];
+  const items: AttributionItem[] = [];
+
+  // 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) as BBox;
+
+    let interval: [string, string][] | undefined = 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`) as [string, string]];
+    }
+    const extent: StacExtent = { 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: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  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/src/routes/health.ts

@@ -0,0 +1,84 @@
+import { GoogleTms, Nztm2000QuadTms } from '@basemaps/geo';
+import { TileDataXyz, TileType } from '@basemaps/shared';
+import { ImageFormat } from '@basemaps/tiler';
+import { HttpHeader, LambdaHttpRequest, 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';
+
+interface TestTile extends TileDataXyz {
+  buf?: Buffer;
+}
+
+export const TestTiles: TestTile[] = [
+  { 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: TestTile): Promise<Buffer> {
+  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: any) {
+    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: TestTile, newTileData: Buffer, difference: Buffer): Promise<void> {
+  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: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  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/src/routes/tile.etag.ts

@@ -0,0 +1,36 @@
+import { Composition } from '@basemaps/tiler';
+import { createHash } from 'crypto';
+import { TileDataXyz } from '@basemaps/shared';
+import { HttpHeader, LambdaHttpRequest } from '@linzjs/lambda';
+import { basename } from 'path';
+
+export const TileEtag = {
+  // To force a full cache invalidation change this number
+  RenderId: 1,
+
+  key(object: Record<string, unknown>): string {
+    return createHash('sha256').update(JSON.stringify(object)).digest('base64');
+  },
+
+  /** Generate a unique ETag for this tile */
+  generate(compositions: Composition[], xyzData: TileDataXyz): string {
+    // 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: LambdaHttpRequest, cacheKey: string): boolean {
+    // 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/src/routes/tile.ts

@@ -0,0 +1,198 @@
+import { Sources, StyleJson } from '@basemaps/config';
+import { TileMatrixSet } from '@basemaps/geo';
+import { HttpHeader, LambdaHttpRequest, 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 { TileSetRaster } from '../tile.set.raster.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 interface TileJson {
+  tiles: string[];
+  minzoom: number;
+  maxzoom: number;
+  format: string;
+  tilejson: string;
+}
+
+export const TileRoute = {
+  async tile(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+    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: string, tileMatrix: TileMatrixSet | null): Promise<TileSetRaster[]> {
+    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') as TileSetRaster[];
+  },
+
+  async wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+    const action = Router.action(req);
+    const wmtsData = tileWmtsFromPath(action.rest);
+    if (wmtsData == null) return NotFound;
+    setNameAndProjection(req, wmtsData);
+    const host = Env.get(Env.PublicUrlBase) ?? '';
+
+    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: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+    const { version, rest, name } = Router.action(req);
+    const apiKey = Router.apiKey(req);
+    const host = Env.get(Env.PublicUrlBase) ?? '';
+    const tileUrl = `${host}/${version}/${name}/${rest[0]}/${rest[1]}/{z}/{x}/{y}.pbf?api=${apiKey}`;
+
+    const tileJson: 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: LambdaHttpRequest, fileName: string): Promise<LambdaHttpResponse> {
+    const apiKey = Router.apiKey(req);
+    if (apiKey == null) return new LambdaHttpResponse(400, 'Invalid API Key.');
+    const styleName = fileName.split('.json')[0];
+    const host = Env.get(Env.PublicUrlBase) ?? '';
+
+    // 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: 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: 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: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  const { rest } = Router.action(req);
+  if (rest.length < 1) return NotFound;
+  const apiKey = Router.apiKey(req);
+  const apiKeyHash = createHash('sha256')
+    .update(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/src/tiff.cache.ts

@@ -0,0 +1,51 @@
+import { ChunkSourceBase } from '@chunkd/core';
+import { CogTiff } from '@cogeotiff/core';
+
+/** Limit the caching of tiffs */
+export class TiffCache {
+  static cacheA: Map<string, CogTiff> = new Map();
+  static cacheB: Map<string, CogTiff> = new Map();
+
+  /** 256 MB Cache */
+  static MaxCacheSizeBytes = 256 * 1024 * 1024;
+
+  static get(id: string): CogTiff | null {
+    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(): void {
+    this.cacheA.clear();
+    this.cacheB.clear();
+  }
+
+  static set(id: string, tiff: CogTiff): void {
+    TiffCache.cacheA.set(id, tiff);
+    TiffCache.check();
+  }
+
+  /** Validate the size of the cache has not exploded */
+  static check(): void {
+    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(): number {
+    let size = 0;
+    for (const value of TiffCache.cacheA.values()) {
+      size += value.source.chunkSize * (value.source as ChunkSourceBase).chunks.size;
+    }
+    return size;
+  }
+}