leaflet-city-mapper 0.0.9 → 0.1.1

package/src/cog/getColorTile.js

@@ -1,25 +1,38 @@
-import { readCogBlock } from './readCogBlock.js';
-
-export async function getColorTile(source, level, x, y, signal) {
-  const canvas = /* alloc */ new OffscreenCanvas(256, 256), context = canvas.getContext('2d');
-  if (!context) throw /* alloc */ new Error('Unable to create COG tile canvas');
-  const left = (x - level.x) * 256, top = (y - level.y) * 256;
-  let bx, by, pixels, rgba, i, j, bitmap;
-  for (by = Math.max(0, Math.floor(top / 256)); by < Math.min(level.rows, Math.ceil(top / 256 + 1)); by++) {
-    for (bx = Math.max(0, Math.floor(left / 256)); bx < Math.min(level.columns, Math.ceil(left / 256 + 1)); bx++) {
-      pixels = /* alloc */ new Uint8Array(await readCogBlock(source, level, bx, by, signal));
-      signal?.throwIfAborted();
-      rgba = /* alloc */ new Uint8ClampedArray(256 * 256 * 4);
-      for (i = 0, j = 0; i < pixels.length; i += level.samples, j += 4) {
-        rgba[j] = pixels[i]; rgba[j + 1] = pixels[i + 1]; rgba[j + 2] = pixels[i + 2];
-        rgba[j + 3] = level.samples === 4 ? pixels[i + 3] : 255;
-      }
-      bitmap = await createImageBitmap(/* alloc */ new ImageData(rgba, 256, 256));
-      context.drawImage(bitmap, bx * 256 - left, by * 256 - top);
-      bitmap.close();
-    }
-  }
-  const image = canvas.transferToImageBitmap();
-  if (signal?.aborted) { image.close(); signal.throwIfAborted(); }
-  return /* alloc */ { image };
-}
+import { readCogBlock } from './readCogBlock.js';
+
+/**
+ * Composite the COG color blocks overlapping an XYZ tile into an image bitmap.
+ *
+ * @param {Object} source Open COG source.
+ * @param {Object} level COG overview level.
+ * @param {number} x XYZ tile column.
+ * @param {number} y XYZ tile row.
+ * @param {AbortSignal} [signal] Request cancellation signal.
+ *
+ * @returns {Promise<Object>} Object containing the resulting image bitmap.
+ *
+ * @throws {Error} If a 2D canvas context cannot be created.
+ */
+export async function getColorTile(source, level, x, y, signal) {
+  const canvas = /* alloc */ new OffscreenCanvas(256, 256), context = canvas.getContext('2d');
+  if (!context) throw /* alloc */ new Error('Unable to create COG tile canvas');
+  const left = (x - level.x) * 256, top = (y - level.y) * 256;
+  let bx, by, pixels, rgba, i, j, bitmap;
+  for (by = Math.max(0, Math.floor(top / 256)); by < Math.min(level.rows, Math.ceil(top / 256 + 1)); by++) {
+    for (bx = Math.max(0, Math.floor(left / 256)); bx < Math.min(level.columns, Math.ceil(left / 256 + 1)); bx++) {
+      pixels = /* alloc */ new Uint8Array(await readCogBlock(source, level, bx, by, signal));
+      signal?.throwIfAborted();
+      rgba = /* alloc */ new Uint8ClampedArray(256 * 256 * 4);
+      for (i = 0, j = 0; i < pixels.length; i += level.samples, j += 4) {
+        rgba[j] = pixels[i]; rgba[j + 1] = pixels[i + 1]; rgba[j + 2] = pixels[i + 2];
+        rgba[j + 3] = level.samples === 4 ? pixels[i + 3] : 255;
+      }
+      bitmap = await createImageBitmap(/* alloc */ new ImageData(rgba, 256, 256));
+      context.drawImage(bitmap, bx * 256 - left, by * 256 - top);
+      bitmap.close();
+    }
+  }
+  const image = canvas.transferToImageBitmap();
+  if (signal?.aborted) { image.close(); signal.throwIfAborted(); }
+  return /* alloc */ { image };
+}

package/src/cog/getElevationTile.js

@@ -1,16 +1,29 @@
-import { readCogBlock } from './readCogBlock.js';
-
-export async function getElevationTile(source, level, x, y, signal) {
-  const data = await readCogBlock(source, level, x - level.x, y - level.y, signal);
-  signal?.throwIfAborted();
-  const view = /* alloc */ new DataView(data), heights = /* alloc */ new Float32Array(256 * 256);
-  let i, height;
-  for (i = 0; i < heights.length; i++) {
-    height = view.getFloat32(i * 4, source.little);
-    if (!Number.isFinite(height) || height < -12000 || height > 10000) {
-      throw /* alloc */ new Error('Invalid or missing COG elevation sample');
-    }
-    heights[i] = height;
-  }
-  return /* alloc */ { data: heights.buffer };
-}
+import { readCogBlock } from './readCogBlock.js';
+
+/**
+ * Read and validate the Float32 elevation samples for an XYZ tile.
+ *
+ * @param {Object} source Open COG source.
+ * @param {Object} level COG elevation level.
+ * @param {number} x XYZ tile column.
+ * @param {number} y XYZ tile row.
+ * @param {AbortSignal} [signal] Request cancellation signal.
+ *
+ * @returns {Promise<Object>} Object containing the elevation buffer.
+ *
+ * @throws {Error} If an elevation sample is non-finite or outside the supported range.
+ */
+export async function getElevationTile(source, level, x, y, signal) {
+  const data = await readCogBlock(source, level, x - level.x, y - level.y, signal);
+  signal?.throwIfAborted();
+  const view = /* alloc */ new DataView(data), heights = /* alloc */ new Float32Array(256 * 256);
+  let i, height;
+  for (i = 0; i < heights.length; i++) {
+    height = view.getFloat32(i * 4, source.little);
+    if (!Number.isFinite(height) || height < -12000 || height > 10000) {
+      throw /* alloc */ new Error('Invalid or missing COG elevation sample');
+    }
+    heights[i] = height;
+  }
+  return /* alloc */ { data: heights.buffer };
+}

package/src/cog/hasCogProjection.js

@@ -1,9 +1,16 @@
-export function hasCogProjection(keys) {
-  let projected = false, area = false, i;
-  if (keys) for (i = 4; i < keys.length; i += 4) {
-    if (keys[i + 1] !== 0 || keys[i + 2] !== 1) continue;
-    if (keys[i] === 3072 && keys[i + 3] === 3857) projected = true;
-    if (keys[i] === 1025 && keys[i + 3] === 1) area = true;
-  }
-  return projected && area;
-}
+/**
+ * Check GeoTIFF keys for EPSG:3857 and PixelIsArea.
+ *
+ * @param {ArrayLike<number>} keys GeoKey directory values, if present.
+ *
+ * @returns {boolean} Whether both required keys are present.
+ */
+export function hasCogProjection(keys) {
+  let projected = false, area = false, i;
+  if (keys) for (i = 4; i < keys.length; i += 4) {
+    if (keys[i + 1] !== 0 || keys[i + 2] !== 1) continue;
+    if (keys[i] === 3072 && keys[i + 3] === 3857) projected = true;
+    if (keys[i] === 1025 && keys[i + 3] === 1) area = true;
+  }
+  return projected && area;
+}

package/src/cog/initCog.js

@@ -1,7 +1,13 @@
-import { initRaster } from '../raster/initRaster.js';
-import { openCogInWorker } from '../workers/openCogInWorker.js';
-
-export function initCog(layer, options) {
-  initRaster(layer, /* alloc */ { ariaLabel: 'COG raster', ...options,
-    archive: options.archive || openCogInWorker(layer, options) });
-}
+import { initRaster } from '../raster/initRaster.js';
+import { openCogInWorker } from '../workers/openCogInWorker.js';
+
+/**
+ * Initialize a raster layer backed by a COG archive or a worker-opened COG source.
+ *
+ * @param {L.Layer} layer Raster layer to initialize.
+ * @param {Object} options Layer and COG source options.
+ */
+export function initCog(layer, options) {
+  initRaster(layer, /* alloc */ { ariaLabel: 'COG raster', ...options,
+    archive: options.archive || openCogInWorker(layer, options) });
+}

package/src/cog/invalidCogFullResponse.js

@@ -1,3 +1,10 @@
-export function invalidCogFullResponse(response) {
-  return response.status !== 200 || Number(response.headers.get('Content-Length')) > 32000000;
-}
+/**
+ * Check whether a non-range COG response has an unsupported status or declared size.
+ *
+ * @param {Response} response HTTP response.
+ *
+ * @returns {boolean} Whether the full response is unacceptable.
+ */
+export function invalidCogFullResponse(response) {
+  return response.status !== 200 || Number(response.headers.get('Content-Length')) > 32000000;
+}

package/src/cog/openCog.js

@@ -1,30 +1,40 @@
-import { readCog } from './readCog.js';
-import { readCogDirectories } from './readCogDirectories.js';
-import { getCogTile } from './getCogTile.js';
-import { getCogHeader } from './getCogHeader.js';
-import { openCogAsset } from './openCogAsset.js';
-
-/** EPSG:3857 COGs, standalone or named assets in a PMTiles container. */
-export async function openCog(url, asset) {
-  const source = asset === undefined ? /* alloc */ { url } : await openCogAsset(url, asset);
-  source.levels = /* alloc */ new Map();
-  const header = /* alloc */ new DataView(await readCog(source, 0, 8));
-  const order = header.getUint16(0);
-  if (order !== 0x4949 && order !== 0x4d4d) throw /* alloc */ new Error('Invalid TIFF byte order');
-  source.little = order === 0x4949;
-  if (header.getUint16(2, source.little) !== 42) throw /* alloc */ new Error('Expected classic TIFF (BigTIFF is not supported)');
-  const { base, minZoom, maxZoom } = await readCogDirectories(source, header.getUint32(4, source.little));
-  const half = 20037508.342789244;
-  const left = base.left + base.resolution / 2, right = base.left + (base.width - 0.5) * base.resolution;
-  const top = base.top - base.resolution / 2, bottom = base.top - (base.height - 0.5) * base.resolution;
-  source.header = /* alloc */ {
-    minZoom, maxZoom, tileType: base.elevation ? 0 : 2,
-    minLon: left / half * 180, maxLon: right / half * 180,
-    minLat: Math.atan(Math.sinh(bottom / half * Math.PI)) * 180 / Math.PI,
-    maxLat: Math.atan(Math.sinh(top / half * Math.PI)) * 180 / Math.PI,
-  };
-  return /* alloc */ {
-    getHeader: getCogHeader.bind(null, source),
-    getZxy: getCogTile.bind(null, source),
-  };
-}
+import { readCog } from './readCog.js';
+import { readCogDirectories } from './readCogDirectories.js';
+import { getCogTile } from './getCogTile.js';
+import { getCogHeader } from './getCogHeader.js';
+import { openCogAsset } from './openCogAsset.js';
+
+/**
+ * Open an EPSG:3857 COG, standalone or as a named asset in a PMTiles container.
+ *
+ * @param {string} url COG or container URL.
+ * @param {string} [asset] Named COG asset in the container.
+ *
+ * @returns {Promise<Object>} Archive-compatible header and XYZ tile methods.
+ *
+ * @throws {Error} If TIFF byte order is invalid.
+ * @throws {Error} If the file is not classic TIFF.
+ */
+export async function openCog(url, asset) {
+  const source = asset === undefined ? /* alloc */ { url } : await openCogAsset(url, asset);
+  source.levels = /* alloc */ new Map();
+  const header = /* alloc */ new DataView(await readCog(source, 0, 8));
+  const order = header.getUint16(0);
+  if (order !== 0x4949 && order !== 0x4d4d) throw /* alloc */ new Error('Invalid TIFF byte order');
+  source.little = order === 0x4949;
+  if (header.getUint16(2, source.little) !== 42) throw /* alloc */ new Error('Expected classic TIFF (BigTIFF is not supported)');
+  const { base, minZoom, maxZoom } = await readCogDirectories(source, header.getUint32(4, source.little));
+  const half = 20037508.342789244;
+  const left = base.left + base.resolution / 2, right = base.left + (base.width - 0.5) * base.resolution;
+  const top = base.top - base.resolution / 2, bottom = base.top - (base.height - 0.5) * base.resolution;
+  source.header = /* alloc */ {
+    minZoom, maxZoom, tileType: base.elevation ? 0 : 2,
+    minLon: left / half * 180, maxLon: right / half * 180,
+    minLat: Math.atan(Math.sinh(bottom / half * Math.PI)) * 180 / Math.PI,
+    maxLat: Math.atan(Math.sinh(top / half * Math.PI)) * 180 / Math.PI,
+  };
+  return /* alloc */ {
+    getHeader: getCogHeader.bind(null, source),
+    getZxy: getCogTile.bind(null, source),
+  };
+}

package/src/cog/openCogAsset.js

@@ -1,14 +1,22 @@
-import { decodeHeader } from '../archives/decodeHeader.js';
-import { readCog } from './readCog.js';
-import { validateCogContainer } from './validateCogContainer.js';
-import { getCogAssetEntry } from './getCogAssetEntry.js';
-
-export async function openCogAsset(url, asset) {
-  const container = /* alloc */ { url };
-  const header = decodeHeader(await readCog(container, 0, 127));
-  validateCogContainer(container, header);
-  const entry = await getCogAssetEntry(container, header, asset);
-  const baseOffset = header.tileDataOffset + entry.offset;
-  return /* alloc */ { url, baseOffset, size: entry.length, containerSize: container.size,
-    etag: container.etag, full: container.full?.slice(baseOffset, baseOffset + entry.length) };
-}
+import { decodeHeader } from '../archives/decodeHeader.js';
+import { readCog } from './readCog.js';
+import { validateCogContainer } from './validateCogContainer.js';
+import { getCogAssetEntry } from './getCogAssetEntry.js';
+
+/**
+ * Open a named COG asset within a PMTiles container as a bounded byte source.
+ *
+ * @param {string} url Container URL.
+ * @param {string} asset Asset name.
+ *
+ * @returns {Promise<Object>} COG source with container offset and size.
+ */
+export async function openCogAsset(url, asset) {
+  const container = /* alloc */ { url };
+  const header = decodeHeader(await readCog(container, 0, 127));
+  validateCogContainer(container, header);
+  const entry = await getCogAssetEntry(container, header, asset);
+  const baseOffset = header.tileDataOffset + entry.offset;
+  return /* alloc */ { url, baseOffset, size: entry.length, containerSize: container.size,
+    etag: container.etag, full: container.full?.slice(baseOffset, baseOffset + entry.length) };
+}

package/src/cog/readCog.js

@@ -1,25 +1,39 @@
-import { validateCogRange } from './validateCogRange.js';
-import { validateCogResponse } from './validateCogResponse.js';
-import { readCogBody } from './readCogBody.js';
-
-export async function readCog(source, offset, length, signal) {
-  signal?.throwIfAborted();
-  validateCogRange(source, offset, length);
-  if (source.full) return source.full.slice(offset, offset + length);
-  const rangeStart = (source.baseOffset || 0) + offset;
-  const response = await fetch(source.url, /* alloc */ {
-    headers: /* alloc */ { Range: `bytes=${rangeStart}-${rangeStart + length - 1}` }, signal,
-  });
-  if (!response.ok) throw /* alloc */ new Error(`Unable to read COG: HTTP ${response.status}`);
-  validateCogResponse(source, response, rangeStart, length);
-  const data = await readCogBody(response, length);
-  if (response.status === 200) {
-    if (source.baseOffset === undefined) source.size = data.byteLength;
-    else if (data.byteLength !== source.containerSize) throw /* alloc */ new Error('Truncated PMTiles COG container');
-    source.full = source.baseOffset === undefined ? data.buffer
-      : data.slice(source.baseOffset, source.baseOffset + source.size);
-  }
-  const result = response.status === 200 ? source.full.slice(offset, offset + length) : data.buffer;
-  if (result.byteLength !== length) throw /* alloc */ new Error('Truncated COG byte range');
-  return result;
-}
+import { validateCogRange } from './validateCogRange.js';
+import { validateCogResponse } from './validateCogResponse.js';
+import { readCogBody } from './readCogBody.js';
+
+/**
+ * Read a validated byte range from a COG source, caching an accepted full response.
+ *
+ * @param {Object} source COG byte source and response state.
+ * @param {number} offset Byte offset relative to the source.
+ * @param {number} length Number of bytes to read.
+ * @param {AbortSignal} [signal] Request cancellation signal.
+ *
+ * @returns {Promise<ArrayBuffer>} Requested bytes.
+ *
+ * @throws {Error} If the HTTP response is unsuccessful.
+ * @throws {Error} If a full PMTiles container response is truncated.
+ * @throws {Error} If the resulting byte range is truncated.
+ */
+export async function readCog(source, offset, length, signal) {
+  signal?.throwIfAborted();
+  validateCogRange(source, offset, length);
+  if (source.full) return source.full.slice(offset, offset + length);
+  const rangeStart = (source.baseOffset || 0) + offset;
+  const response = await fetch(source.url, /* alloc */ {
+    headers: /* alloc */ { Range: `bytes=${rangeStart}-${rangeStart + length - 1}` }, signal,
+  });
+  if (!response.ok) throw /* alloc */ new Error(`Unable to read COG: HTTP ${response.status}`);
+  validateCogResponse(source, response, rangeStart, length);
+  const data = await readCogBody(response, length);
+  if (response.status === 200) {
+    if (source.baseOffset === undefined) source.size = data.byteLength;
+    else if (data.byteLength !== source.containerSize) throw /* alloc */ new Error('Truncated PMTiles COG container');
+    source.full = source.baseOffset === undefined ? data.buffer
+      : data.slice(source.baseOffset, source.baseOffset + source.size);
+  }
+  const result = response.status === 200 ? source.full.slice(offset, offset + length) : data.buffer;
+  if (result.byteLength !== length) throw /* alloc */ new Error('Truncated COG byte range');
+  return result;
+}

package/src/cog/readCogBlock.js

@@ -1,8 +1,19 @@
-import { readCog } from './readCog.js';
-import { decodeCogTile } from './decodeCogTile.js';
-
-export async function readCogBlock(source, level, x, y, signal) {
-  const index = y * level.columns + x;
-  return decodeCogTile(await readCog(source, level.offsets[index], level.lengths[index], signal),
-    256 * 256 * (level.elevation ? 4 : level.samples), level.compression);
-}
+import { readCog } from './readCog.js';
+import { decodeCogTile } from './decodeCogTile.js';
+
+/**
+ * Read and decode one TIFF tile block from a COG level.
+ *
+ * @param {Object} source Open COG byte source.
+ * @param {Object} level COG level with block offsets and lengths.
+ * @param {number} x Block column within the level.
+ * @param {number} y Block row within the level.
+ * @param {AbortSignal} [signal] Request cancellation signal.
+ *
+ * @returns {Promise<ArrayBuffer>} Decoded block data.
+ */
+export async function readCogBlock(source, level, x, y, signal) {
+  const index = y * level.columns + x;
+  return decodeCogTile(await readCog(source, level.offsets[index], level.lengths[index], signal),
+    256 * 256 * (level.elevation ? 4 : level.samples), level.compression);
+}

package/src/cog/readCogBody.js

@@ -1,20 +1,30 @@
-export async function readCogBody(response, length) {
-  const reader = response.body.getReader(), chunks = /* alloc */ [];
-  let total = 0, part;
-  try {
-    while (!(part = await reader.read()).done) {
-      total += part.value.byteLength;
-      if (total > (response.status === 206 ? length : 32000000)) {
-        await reader.cancel();
-        throw /* alloc */ new Error('Oversized COG response');
-      }
-      chunks.push(part.value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const data = /* alloc */ new Uint8Array(total);
-  let start = 0, chunk;
-  for (chunk of chunks) { data.set(chunk, start); start += chunk.length; }
-  return data;
-}
+/**
+ * Read a COG HTTP body while enforcing the range or full-response size limit.
+ *
+ * @param {Response} response HTTP response with a readable body.
+ * @param {number} length Expected byte length for a range response.
+ *
+ * @returns {Promise<Uint8Array>} Response bytes.
+ *
+ * @throws {Error} If the response exceeds its permitted size.
+ */
+export async function readCogBody(response, length) {
+  const reader = response.body.getReader(), chunks = /* alloc */ [];
+  let total = 0, part;
+  try {
+    while (!(part = await reader.read()).done) {
+      total += part.value.byteLength;
+      if (total > (response.status === 206 ? length : 32000000)) {
+        await reader.cancel();
+        throw /* alloc */ new Error('Oversized COG response');
+      }
+      chunks.push(part.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const data = /* alloc */ new Uint8Array(total);
+  let start = 0, chunk;
+  for (chunk of chunks) { data.set(chunk, start); start += chunk.length; }
+  return data;
+}

package/src/cog/readCogDirectories.js

@@ -1,20 +1,32 @@
-import { readCogDirectory } from './readCogDirectory.js';
-import { readCogLevel } from './readCogLevel.js';
-
-export async function readCogDirectories(source, offset) {
-  const state = /* alloc */ { base: null, minZoom: Infinity, maxZoom: -Infinity };
-  const seen = /* alloc */ new Set();
-  let directory;
-  while (offset) {
-    if (seen.has(offset) || seen.size >= 24) throw /* alloc */ new Error('Cyclic or excessive COG directories');
-    seen.add(offset);
-    directory = await readCogDirectory(source, offset);
-    readCogLevel(source, directory, state);
-    offset = directory.next;
-  }
-  if (!state.base) throw /* alloc */ new Error('COG has no image directory');
-  if (source.levels.size !== state.maxZoom - state.minZoom + 1) {
-    throw /* alloc */ new Error('COG overview zooms must be contiguous');
-  }
-  return /* alloc */ { base: state.base, minZoom: state.minZoom, maxZoom: state.maxZoom };
-}
+import { readCogDirectory } from './readCogDirectory.js';
+import { readCogLevel } from './readCogLevel.js';
+
+/**
+ * Read TIFF image directories and register contiguous COG zoom levels.
+ *
+ * @param {Object} source Open COG byte source.
+ * @param {number} offset First TIFF directory offset.
+ *
+ * @returns {Promise<Object>} Base image and minimum and maximum zoom.
+ *
+ * @throws {Error} If directories are cyclic or exceed the supported count.
+ * @throws {Error} If there is no image directory.
+ * @throws {Error} If overview zoom levels are not contiguous.
+ */
+export async function readCogDirectories(source, offset) {
+  const state = /* alloc */ { base: null, minZoom: Infinity, maxZoom: -Infinity };
+  const seen = /* alloc */ new Set();
+  let directory;
+  while (offset) {
+    if (seen.has(offset) || seen.size >= 24) throw /* alloc */ new Error('Cyclic or excessive COG directories');
+    seen.add(offset);
+    directory = await readCogDirectory(source, offset);
+    readCogLevel(source, directory, state);
+    offset = directory.next;
+  }
+  if (!state.base) throw /* alloc */ new Error('COG has no image directory');
+  if (source.levels.size !== state.maxZoom - state.minZoom + 1) {
+    throw /* alloc */ new Error('COG overview zooms must be contiguous');
+  }
+  return /* alloc */ { base: state.base, minZoom: state.minZoom, maxZoom: state.maxZoom };
+}

package/src/cog/readCogDirectory.js

@@ -1,21 +1,34 @@
-import { readCog } from './readCog.js';
-import { cogTags } from '../globals/cogTags.js';
-import { readCogTag } from './readCogTag.js';
-
-export async function readCogDirectory(source, offset) {
-  const little = source.little;
-  const count = /* alloc */ new DataView(await readCog(source, offset, 2)).getUint16(0, little);
-  if (!count || count > 128) throw /* alloc */ new Error('Invalid COG directory size');
-  const entries = /* alloc */ new DataView(await readCog(source, offset + 2, count * 12 + 4));
-  const tags = /* alloc */ new Map();
-  let i, tag;
-  for (i = 0; i < count; i++) {
-    tag = entries.getUint16(i * 12, little);
-    if (tag === 42113) throw /* alloc */ new Error('COG nodata tags are not supported; export complete tiles');
-    if (tag === 34264) throw /* alloc */ new Error('COG affine transformation matrices are not supported');
-    if (!cogTags.includes(tag)) continue;
-    if (tags.has(tag)) throw /* alloc */ new Error('Duplicate COG tag');
-    tags.set(tag, await readCogTag(source, entries, i, tag, little));
-  }
-  return /* alloc */ { tags, next: entries.getUint32(count * 12, little) };
-}
+import { readCog } from './readCog.js';
+import { cogTags } from '../globals/cogTags.js';
+import { readCogTag } from './readCogTag.js';
+
+/**
+ * Read supported TIFF tags from one image directory.
+ *
+ * @param {Object} source Open COG byte source.
+ * @param {number} offset Directory byte offset.
+ *
+ * @returns {Promise<Object>} Tag map and next directory offset.
+ *
+ * @throws {Error} If the directory size is invalid.
+ * @throws {Error} If a nodata tag is present.
+ * @throws {Error} If an affine transformation tag is present.
+ * @throws {Error} If a supported tag is duplicated.
+ */
+export async function readCogDirectory(source, offset) {
+  const little = source.little;
+  const count = /* alloc */ new DataView(await readCog(source, offset, 2)).getUint16(0, little);
+  if (!count || count > 128) throw /* alloc */ new Error('Invalid COG directory size');
+  const entries = /* alloc */ new DataView(await readCog(source, offset + 2, count * 12 + 4));
+  const tags = /* alloc */ new Map();
+  let i, tag;
+  for (i = 0; i < count; i++) {
+    tag = entries.getUint16(i * 12, little);
+    if (tag === 42113) throw /* alloc */ new Error('COG nodata tags are not supported; export complete tiles');
+    if (tag === 34264) throw /* alloc */ new Error('COG affine transformation matrices are not supported');
+    if (!cogTags.includes(tag)) continue;
+    if (tags.has(tag)) throw /* alloc */ new Error('Duplicate COG tag');
+    tags.set(tag, await readCogTag(source, entries, i, tag, little));
+  }
+  return /* alloc */ { tags, next: entries.getUint32(count * 12, little) };
+}

package/src/cog/readCogLevel.js

@@ -1,27 +1,36 @@
-import { getCogProfile } from './getCogProfile.js';
-import { getCogBase } from './getCogBase.js';
-import { validCogGrid } from './validCogGrid.js';
-import { validateCogOffsets } from './validateCogOffsets.js';
-
-export function readCogLevel(source, directory, state) {
-  const tags = directory.tags, profile = getCogProfile(tags);
-  if (!state.base) state.base = getCogBase(tags, profile.width, profile.height, profile.elevation);
-  const base = state.base, resolution = base.resolution * base.width / profile.width;
-  const zoom = Math.round(Math.log2(20037508.342789244 * 2 / (256 * resolution)));
-  const span = 20037508.342789244 * 2 / 2 ** zoom;
-  let x = (base.left + 20037508.342789244) / span;
-  let y = (20037508.342789244 - base.top) / span;
-  if (Math.abs(x - Math.round(x)) < 1e-6) x = Math.round(x);
-  if (Math.abs(y - Math.round(y)) < 1e-6) y = Math.round(y);
-  if (!validCogGrid(source, base, profile, zoom, x, y, resolution)) {
-    throw /* alloc */ new Error('COG levels must align with the Web Mercator XYZ tile grid');
-  }
-  const level = /* alloc */ {
-    x, y, columns: profile.width / 256, rows: profile.height / 256, samples: profile.samples,
-    elevation: profile.elevation, compression: tags.get(259)[0], offsets: tags.get(324), lengths: tags.get(325),
-  };
-  validateCogOffsets(source, level);
-  source.levels.set(zoom, level);
-  state.minZoom = Math.min(state.minZoom, zoom);
-  state.maxZoom = Math.max(state.maxZoom, zoom);
-}
+import { getCogProfile } from './getCogProfile.js';
+import { getCogBase } from './getCogBase.js';
+import { validCogGrid } from './validCogGrid.js';
+import { validateCogOffsets } from './validateCogOffsets.js';
+
+/**
+ * Validate and register one TIFF directory as a COG XYZ level.
+ *
+ * @param {Object} source Open COG source and level map.
+ * @param {Object} directory TIFF directory with parsed tags.
+ * @param {Object} state Mutable base image and zoom range.
+ *
+ * @throws {Error} If the level does not align with the supported Web Mercator grid.
+ */
+export function readCogLevel(source, directory, state) {
+  const tags = directory.tags, profile = getCogProfile(tags);
+  if (!state.base) state.base = getCogBase(tags, profile.width, profile.height, profile.elevation);
+  const base = state.base, resolution = base.resolution * base.width / profile.width;
+  const zoom = Math.round(Math.log2(20037508.342789244 * 2 / (256 * resolution)));
+  const span = 20037508.342789244 * 2 / 2 ** zoom;
+  let x = (base.left + 20037508.342789244) / span;
+  let y = (20037508.342789244 - base.top) / span;
+  if (Math.abs(x - Math.round(x)) < 1e-6) x = Math.round(x);
+  if (Math.abs(y - Math.round(y)) < 1e-6) y = Math.round(y);
+  if (!validCogGrid(source, base, profile, zoom, x, y, resolution)) {
+    throw /* alloc */ new Error('COG levels must align with the Web Mercator XYZ tile grid');
+  }
+  const level = /* alloc */ {
+    x, y, columns: profile.width / 256, rows: profile.height / 256, samples: profile.samples,
+    elevation: profile.elevation, compression: tags.get(259)[0], offsets: tags.get(324), lengths: tags.get(325),
+  };
+  validateCogOffsets(source, level);
+  source.levels.set(zoom, level);
+  state.minZoom = Math.min(state.minZoom, zoom);
+  state.maxZoom = Math.max(state.maxZoom, zoom);
+}