styled-map-package 2.2.1 → 3.0.0

package/dist/style-downloader.js

@@ -0,0 +1,288 @@
+import { check as checkGeoJson } from "@placemarkio/check-geojson";
+import { includeKeys } from "filter-obj";
+import ky from "ky";
+import Queue from "yocto-queue";
+import zlib from "zlib";
+import { downloadTiles } from "./tile-downloader.js";
+import { FetchQueue } from "./utils/fetch.js";
+import {
+  normalizeGlyphsURL,
+  normalizeSourceURL,
+  normalizeSpriteURL,
+  normalizeStyleURL
+} from "./utils/mapbox.js";
+import { clone, noop } from "./utils/misc.js";
+import {
+  assertTileJSON,
+  isInlinedSource,
+  mapFontStacks,
+  validateStyle
+} from "./utils/style.js";
+class StyleDownloader {
+  /** @type {null | string} */
+  #styleURL = null;
+  /** @type {null | StyleSpecification} */
+  #inputStyle = null;
+  /** @type {FetchQueue} */
+  #fetchQueue;
+  #mapboxAccessToken;
+  /**
+   * @param {string | StyleSpecification} style A url to a style JSON file or a style object
+   * @param {object} [opts]
+   * @param {number} [opts.concurrency=8]
+   * @param {string} [opts.mapboxAccessToken] Downloading a style from Mapbox requires an access token
+   */
+  constructor(style, { concurrency = 8, mapboxAccessToken } = {}) {
+    if (typeof style === "string") {
+      const { searchParams } = new URL(style);
+      this.#mapboxAccessToken = searchParams.get("access_token") || mapboxAccessToken;
+      this.#styleURL = normalizeStyleURL(style, this.#mapboxAccessToken);
+    } else if (validateStyle(style)) {
+      this.#inputStyle = clone(style);
+    } else {
+      throw new AggregateError(validateStyle.errors, "Invalid style");
+    }
+    this.#fetchQueue = new FetchQueue(concurrency);
+  }
+  /**
+   * Number of active downloads.
+   */
+  get active() {
+    return this.#fetchQueue.activeCount;
+  }
+  /**
+   * Download the style JSON for this style and inline the sources
+   *
+   * @returns {Promise<StyleInlinedSources>}
+   */
+  async getStyle() {
+    if (!this.#inputStyle && this.#styleURL) {
+      const downloadedStyle = await ky(this.#styleURL).json();
+      if (!validateStyle(downloadedStyle)) {
+        throw new AggregateError(
+          validateStyle.errors,
+          "Invalid style: " + this.#styleURL
+        );
+      }
+      this.#inputStyle = downloadedStyle;
+    } else if (!this.#inputStyle) {
+      throw new Error("Unexpected state: no style or style URL provided");
+    }
+    const inlinedSources = {};
+    for (const [sourceId, source] of Object.entries(this.#inputStyle.sources)) {
+      inlinedSources[sourceId] = await this.#getInlinedSource(source);
+    }
+    return {
+      ...this.#inputStyle,
+      sources: inlinedSources
+    };
+  }
+  /**
+   * @param {SourceSpecification} source
+   * @returns {Promise<InlinedSource>}
+   */
+  async #getInlinedSource(source) {
+    if (isInlinedSource(source)) {
+      return source;
+    }
+    if (source.type === "raster" || source.type === "vector" || source.type === "raster-dem") {
+      if (!source.url) {
+        throw new Error("Source is missing both url and tiles properties");
+      }
+      const sourceUrl = normalizeSourceURL(source.url, this.#mapboxAccessToken);
+      const tilejson = await ky(sourceUrl).json();
+      assertTileJSON(tilejson);
+      return {
+        ...source,
+        ...includeKeys(tilejson, [
+          "bounds",
+          "maxzoom",
+          "minzoom",
+          "tiles",
+          "description",
+          "attribution",
+          "vector_layers"
+        ])
+      };
+    } else if (source.type === "geojson") {
+      if (typeof source.data !== "string") {
+        throw new Error("Unexpected data property for GeoJson source");
+      }
+      const geojsonUrl = normalizeSourceURL(
+        source.data,
+        this.#mapboxAccessToken
+      );
+      const data = checkGeoJson(await ky(geojsonUrl).text());
+      return {
+        ...source,
+        data
+      };
+    }
+    return source;
+  }
+  /**
+   * Download the sprite PNGs and JSON files for this style. Returns an async
+   * generator of json and png readable streams, and the sprite id and pixel
+   * ratio. Downloads pixel ratios `1` and `2`.
+   *
+   * @returns {AsyncGenerator<{ json: import('stream').Readable, png: import('stream').Readable, id: string, pixelRatio: number }>}
+   */
+  async *getSprites() {
+    const style = await this.getStyle();
+    if (!style.sprite) return;
+    const accessToken = this.#mapboxAccessToken;
+    const spriteDefs = Array.isArray(style.sprite) ? style.sprite : [{ id: "default", url: style.sprite }];
+    for (const { id, url } of spriteDefs) {
+      for (const pixelRatio of [1, 2]) {
+        const format = pixelRatio === 1 ? "" : "@2x";
+        const jsonUrl = normalizeSpriteURL(url, format, ".json", accessToken);
+        const pngUrl = normalizeSpriteURL(url, format, ".png", accessToken);
+        const [{ body: json }, { body: png }] = await Promise.all([
+          this.#fetchQueue.fetch(jsonUrl),
+          this.#fetchQueue.fetch(pngUrl)
+        ]);
+        yield { json, png, id, pixelRatio };
+      }
+    }
+  }
+  /**
+   * Download all the glyphs for the fonts used in this style. When font stacks
+   * are used in the style.json (e.g. lists of prefered fonts like with CSS),
+   * then the first font in the stack is downloaded. Defaults to downloading all
+   * UTF character ranges, which may be overkill for some styles. TODO: add more
+   * options here.
+   *
+   * Returns an async generator of readable streams of glyph data and glyph info
+   * objects.
+   *
+   * @param {object} opts
+   * @param {(progress: GlyphDownloadStats) => void} [opts.onprogress]
+   * @returns {AsyncGenerator<[import('stream').Readable, GlyphInfo]>}
+   */
+  async *getGlyphs({ onprogress = noop } = {}) {
+    const style = await this.getStyle();
+    if (!style.glyphs) return;
+    let completed = 0;
+    let stats = {
+      total: 0,
+      downloaded: 0,
+      totalBytes: 0
+    };
+    function onDownloadProgress({ chunkBytes }) {
+      stats.totalBytes += chunkBytes;
+      onprogress(stats);
+    }
+    function onDownloadComplete() {
+      stats.downloaded = ++completed;
+      onprogress(stats);
+    }
+    const queue = new Queue();
+    const fontStacks = /* @__PURE__ */ new Map();
+    mapFontStacks(style.layers, (fontStack) => {
+      fontStacks.set(fontStack[0], fontStack.join(","));
+      return [];
+    });
+    const glyphUrl = normalizeGlyphsURL(style.glyphs, this.#mapboxAccessToken);
+    for (const [font, fontStack] of fontStacks.entries()) {
+      for (let i = 0; i < Math.pow(2, 16); i += 256) {
+        const range = `${i}-${i + 255}`;
+        const url = glyphUrl.replace("{fontstack}", fontStack).replace("{range}", range);
+        const result = this.#fetchQueue.fetch(url, { onprogress: onDownloadProgress }).catch(noop);
+        queue.enqueue([result, { font, range }]);
+      }
+    }
+    stats.total = queue.size;
+    if (onprogress) onprogress(stats);
+    for (const [result, glyphInfo] of queue) {
+      const downloadResponse = await result.catch(noop);
+      if (!downloadResponse) continue;
+      const { body } = downloadResponse;
+      const gzipper = zlib.createGzip();
+      body.on("error", (err) => gzipper.destroy(err));
+      body.on("end", onDownloadComplete);
+      yield [body.pipe(gzipper), glyphInfo];
+    }
+  }
+  /**
+   * Get all the tiles for this style within the given bounds and zoom range.
+   * Returns an async generator of readable streams of tile data and tile info
+   * objects.
+   *
+   * The returned iterator also has a `skipped` property which is an
+   * array of tiles which could not be downloaded, and a `stats` property which
+   * is an object with the total number of tiles, downloaded tiles, and total
+   * bytes downloaded.
+   *
+   * @param {object} opts
+   * @param {import('./utils/geo.js').BBox} opts.bounds
+   * @param {number} opts.maxzoom
+   * @param {(progress: TileDownloadStats) => void} [opts.onprogress]
+   * @param {boolean} [opts.trackErrors=false] Include errors in the returned array of skipped tiles - this has memory overhead so should only be used for debugging.
+   * @returns {AsyncGenerator<[import('stream').Readable, TileInfo]> & { readonly skipped: Array<TileInfo & { error?: Error }>, readonly stats: TileDownloadStats }}
+   */
+  getTiles({ bounds, maxzoom, onprogress = noop, trackErrors = false }) {
+    const _this = this;
+    const skipped = [];
+    let stats = {
+      total: 0,
+      downloaded: 0,
+      skipped: 0,
+      totalBytes: 0
+    };
+    const tiles = async function* () {
+      const inlinedStyle = await _this.getStyle();
+      for await (const [sourceId, source] of Object.entries(
+        inlinedStyle.sources
+      )) {
+        if (source.type !== "raster" && source.type !== "vector") {
+          continue;
+        }
+        const statsBaseline = { ...stats };
+        const sourceTiles = downloadTiles({
+          tileUrls: source.tiles,
+          bounds,
+          maxzoom: Math.min(maxzoom, source.maxzoom || maxzoom),
+          minzoom: source.minzoom,
+          sourceBounds: source.bounds,
+          boundsBuffer: true,
+          scheme: source.scheme,
+          fetchQueue: _this.#fetchQueue,
+          onprogress: (sourceStats) => {
+            stats = addStats(statsBaseline, sourceStats);
+            onprogress(stats);
+          },
+          trackErrors
+        });
+        for await (const [tileDataStream, tileInfo] of sourceTiles) {
+          yield [tileDataStream, { ...tileInfo, sourceId }];
+        }
+        Array.prototype.push.apply(
+          skipped,
+          sourceTiles.skipped.map((tile) => ({ ...tile, sourceId }))
+        );
+      }
+    }();
+    Object.defineProperty(tiles, "skipped", {
+      get() {
+        return skipped;
+      }
+    });
+    Object.defineProperty(tiles, "stats", {
+      get() {
+        return stats;
+      }
+    });
+    return tiles;
+  }
+}
+function addStats(statsA, statsB) {
+  return {
+    total: statsA.total + statsB.total,
+    downloaded: statsA.downloaded + statsB.downloaded,
+    skipped: statsA.skipped + statsB.skipped,
+    totalBytes: statsA.totalBytes + statsB.totalBytes
+  };
+}
+export {
+  StyleDownloader
+};

package/dist/tile-downloader.cjs

@@ -0,0 +1,158 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tile_downloader_exports = {};
+__export(tile_downloader_exports, {
+  downloadTiles: () => downloadTiles,
+  tileIterator: () => tileIterator
+});
+module.exports = __toCommonJS(tile_downloader_exports);
+var import_sphericalmercator = __toESM(require("@mapbox/sphericalmercator"), 1);
+var import_yocto_queue = __toESM(require("yocto-queue"), 1);
+var import_zlib = __toESM(require("zlib"), 1);
+var import_fetch = require('./utils/fetch.cjs');
+var import_file_formats = require('./utils/file-formats.cjs');
+var import_geo = require('./utils/geo.cjs');
+var import_misc = require('./utils/misc.cjs');
+function downloadTiles({
+  tileUrls,
+  bounds,
+  maxzoom,
+  onprogress = import_misc.noop,
+  trackErrors = false,
+  sourceBounds = import_geo.MAX_BOUNDS,
+  boundsBuffer = false,
+  minzoom = 0,
+  concurrency = 8,
+  fetchQueue = new import_fetch.FetchQueue(concurrency),
+  scheme = "xyz"
+}) {
+  const skipped = [];
+  let completed = 0;
+  let stats = {
+    total: 0,
+    downloaded: 0,
+    skipped: 0,
+    totalBytes: 0
+  };
+  function onDownloadProgress({ chunkBytes }) {
+    stats.totalBytes += chunkBytes;
+    onprogress(stats);
+  }
+  function onDownloadError(error, tileInfo) {
+    if (trackErrors) {
+      skipped.push({ ...tileInfo, error });
+    } else {
+      skipped.push(tileInfo);
+    }
+    onprogress(stats);
+  }
+  function onDownloadComplete() {
+    stats.downloaded = ++completed - skipped.length;
+    stats.skipped = skipped.length;
+    onprogress(stats);
+  }
+  const tiles = async function* () {
+    const queue = new import_yocto_queue.default();
+    const tiles2 = tileIterator({
+      bounds,
+      minzoom,
+      maxzoom,
+      sourceBounds,
+      boundsBuffer
+    });
+    for (const { x, y, z } of tiles2) {
+      const tileURL = (0, import_geo.getTileUrl)(tileUrls, { x, y, z, scheme });
+      const tileInfo = { z, x, y };
+      const result = fetchQueue.fetch(tileURL, { onprogress: onDownloadProgress }).catch((err) => onDownloadError(err, tileInfo));
+      queue.enqueue([result, tileInfo]);
+    }
+    stats.total = queue.size;
+    if (onprogress) onprogress(stats);
+    for (const [result, tileInfo] of queue) {
+      const downloadResponse = await result.catch(import_misc.noop);
+      if (!downloadResponse) continue;
+      let { body, mimeType } = downloadResponse;
+      body.on("end", onDownloadComplete);
+      body.on("error", (err) => onDownloadError(err, tileInfo));
+      let format;
+      if (mimeType) {
+        format = (0, import_file_formats.getFormatFromMimeType)(mimeType);
+      } else {
+        ;
+        [format, body] = await (0, import_file_formats.getTileFormatFromStream)(body);
+      }
+      let stream = body;
+      if (format === "mvt") {
+        const gzipStream = import_zlib.default.createGzip();
+        stream = body.pipe(gzipStream);
+        stream.on("error", (err) => gzipStream.destroy(err));
+      }
+      yield [stream, { ...tileInfo, format }];
+    }
+  }();
+  Object.defineProperty(tiles, "skipped", {
+    get() {
+      return skipped;
+    }
+  });
+  Object.defineProperty(tiles, "stats", {
+    get() {
+      return stats;
+    }
+  });
+  return tiles;
+}
+function* tileIterator({
+  bounds = [...import_geo.MAX_BOUNDS],
+  minzoom = 0,
+  maxzoom,
+  sourceBounds,
+  boundsBuffer = false
+}) {
+  const sm = new import_sphericalmercator.default({ size: 256 });
+  for (let z = minzoom; z <= maxzoom; z++) {
+    let { minX, minY, maxX, maxY } = sm.xyz([...bounds], z);
+    let sourceXYBounds = sourceBounds ? sm.xyz([...sourceBounds], z) : { minX, minY, maxX, maxY };
+    const buffer = boundsBuffer ? 1 : 0;
+    minX = Math.max(0, minX - buffer, sourceXYBounds.minX);
+    minY = Math.max(0, minY - buffer, sourceXYBounds.minY);
+    maxX = Math.min(Math.pow(2, z) - 1, maxX + buffer, sourceXYBounds.maxX);
+    maxY = Math.min(Math.pow(2, z) - 1, maxY + buffer, sourceXYBounds.maxY);
+    for (let x = minX; x <= maxX; x++) {
+      for (let y = minY; y <= maxY; y++) {
+        yield { x, y, z };
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  downloadTiles,
+  tileIterator
+});

package/dist/tile-downloader.d.cts

@@ -0,0 +1,84 @@
+import { T as TileInfo$1 } from './types-B4Xn1F9K.cjs';
+import * as stream from 'stream';
+import { BBox } from './utils/geo.cjs';
+import { FetchQueue } from './utils/fetch.cjs';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+import './utils/streams.cjs';
+
+/** @typedef {Omit<import('./writer.js').TileInfo, 'sourceId'>} TileInfo */
+/**
+ * @typedef {object} TileDownloadStats
+ * @property {number} total
+ * @property {number} downloaded
+ * @property {number} skipped
+ * @property {number} totalBytes
+ */
+/**
+ * Download tiles from a list of tile URLs within a bounding box and zoom range.
+ * Returns an async generator of tile data as readable streams and tile info objects.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.tileUrls Array of tile URL templates. Use `{x}`, `{y}`, `{z}` placeholders, and optional `{scheme}` placeholder which can be `xyz` or `tms`.
+ * @param {import('./utils/geo.js').BBox} opts.bounds Bounding box of the area to download
+ * @param {number} opts.maxzoom Maximum zoom level to download
+ * @param {(progress: TileDownloadStats) => void} [opts.onprogress] Callback to report download progress
+ * @param {boolean} [opts.trackErrors=false] Include errors in the returned array of skipped tiles - this has memory overhead so should only be used for debugging.
+ * @param {import('./utils/geo.js').BBox} [opts.sourceBounds=MAX_BOUNDS] Bounding box of source data.
+ * @param {boolean} [opts.boundsBuffer=false] Buffer the bounds by one tile at each zoom level to ensure no tiles are missed at the edges. With this set to false, in most instances the map will appear incomplete when viewed because the downloaded tiles at lower zoom levels will not cover the map view area.
+ * @param {number} [opts.minzoom=0] Minimum zoom level to download (for most cases this should be left as `0` - the size overhead is minimal, because each zoom level has 4x as many tiles)
+ * @param {number} [opts.concurrency=8] Number of concurrent downloads (ignored if `fetchQueue` is provided)
+ * @param {FetchQueue} [opts.fetchQueue=new FetchQueue(concurrency)] Optional fetch queue to use for downloading tiles
+ * @param {'xyz' | 'tms'} [opts.scheme='xyz'] Tile scheme to use for tile URLs
+ * @returns {AsyncGenerator<[import('stream').Readable, TileInfo]> & { readonly skipped: Array<TileInfo & { error?: Error }>, readonly stats: TileDownloadStats }}
+ */
+declare function downloadTiles({ tileUrls, bounds, maxzoom, onprogress, trackErrors, sourceBounds, boundsBuffer, minzoom, concurrency, fetchQueue, scheme, }: {
+    tileUrls: string[];
+    bounds: BBox;
+    maxzoom: number;
+    onprogress?: ((progress: TileDownloadStats) => void) | undefined;
+    trackErrors?: boolean | undefined;
+    sourceBounds?: BBox | undefined;
+    boundsBuffer?: boolean | undefined;
+    minzoom?: number | undefined;
+    concurrency?: number | undefined;
+    fetchQueue?: FetchQueue | undefined;
+    scheme?: "xyz" | "tms" | undefined;
+}): AsyncGenerator<[stream.Readable, TileInfo]> & {
+    readonly skipped: Array<TileInfo & {
+        error?: Error;
+    }>;
+    readonly stats: TileDownloadStats;
+};
+/**
+ *
+ * @param {object} opts
+ * @param {import('./utils/geo.js').BBox} [opts.bounds]
+ * @param {import('./utils/geo.js').BBox} [opts.sourceBounds]
+ * @param {boolean} [opts.boundsBuffer]
+ * @param {number} [opts.minzoom]
+ * @param {number} opts.maxzoom
+ */
+declare function tileIterator({ bounds, minzoom, maxzoom, sourceBounds, boundsBuffer, }: {
+    bounds?: BBox | undefined;
+    sourceBounds?: BBox | undefined;
+    boundsBuffer?: boolean | undefined;
+    minzoom?: number | undefined;
+    maxzoom: number;
+}): Generator<{
+    x: number;
+    y: number;
+    z: number;
+}, void, unknown>;
+type TileInfo = Omit<TileInfo$1, "sourceId">;
+type TileDownloadStats = {
+    total: number;
+    downloaded: number;
+    skipped: number;
+    totalBytes: number;
+};
+
+export { type TileDownloadStats, type TileInfo, downloadTiles, tileIterator };

package/dist/{lib/tile-downloader.d.ts → tile-downloader.d.ts}

@@ -1,3 +1,14 @@
+import { T as TileInfo$1 } from './types-B4Xn1F9K.js';
+import * as stream from 'stream';
+import { BBox } from './utils/geo.js';
+import { FetchQueue } from './utils/fetch.js';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+import './utils/streams.js';
+
 /** @typedef {Omit<import('./writer.js').TileInfo, 'sourceId'>} TileInfo */
 /**
  * @typedef {object} TileDownloadStats
@@ -24,19 +35,19 @@
  * @param {'xyz' | 'tms'} [opts.scheme='xyz'] Tile scheme to use for tile URLs
  * @returns {AsyncGenerator<[import('stream').Readable, TileInfo]> & { readonly skipped: Array<TileInfo & { error?: Error }>, readonly stats: TileDownloadStats }}
  */
-export function downloadTiles({ tileUrls, bounds, maxzoom, onprogress, trackErrors, sourceBounds, boundsBuffer, minzoom, concurrency, fetchQueue, scheme, }: {
+declare function downloadTiles({ tileUrls, bounds, maxzoom, onprogress, trackErrors, sourceBounds, boundsBuffer, minzoom, concurrency, fetchQueue, scheme, }: {
     tileUrls: string[];
-    bounds: import("./utils/geo.js").BBox;
+    bounds: BBox;
     maxzoom: number;
     onprogress?: ((progress: TileDownloadStats) => void) | undefined;
     trackErrors?: boolean | undefined;
-    sourceBounds?: import("./utils/geo.js").BBox | undefined;
+    sourceBounds?: BBox | undefined;
     boundsBuffer?: boolean | undefined;
     minzoom?: number | undefined;
     concurrency?: number | undefined;
     fetchQueue?: FetchQueue | undefined;
     scheme?: "xyz" | "tms" | undefined;
-}): AsyncGenerator<[import("stream").Readable, TileInfo]> & {
+}): AsyncGenerator<[stream.Readable, TileInfo]> & {
     readonly skipped: Array<TileInfo & {
         error?: Error;
     }>;
@@ -51,9 +62,9 @@ export function downloadTiles({ tileUrls, bounds, maxzoom, onprogress, trackErro
  * @param {number} [opts.minzoom]
  * @param {number} opts.maxzoom
  */
-export function tileIterator({ bounds, minzoom, maxzoom, sourceBounds, boundsBuffer, }: {
-    bounds?: import("./utils/geo.js").BBox | undefined;
-    sourceBounds?: import("./utils/geo.js").BBox | undefined;
+declare function tileIterator({ bounds, minzoom, maxzoom, sourceBounds, boundsBuffer, }: {
+    bounds?: BBox | undefined;
+    sourceBounds?: BBox | undefined;
     boundsBuffer?: boolean | undefined;
     minzoom?: number | undefined;
     maxzoom: number;
@@ -62,11 +73,12 @@ export function tileIterator({ bounds, minzoom, maxzoom, sourceBounds, boundsBuf
     y: number;
     z: number;
 }, void, unknown>;
-export type TileInfo = Omit<import("./writer.js").TileInfo, "sourceId">;
-export type TileDownloadStats = {
+type TileInfo = Omit<TileInfo$1, "sourceId">;
+type TileDownloadStats = {
     total: number;
     downloaded: number;
     skipped: number;
     totalBytes: number;
 };
-import { FetchQueue } from './utils/fetch.js';
+
+export { type TileDownloadStats, type TileInfo, downloadTiles, tileIterator };