styled-map-package 2.2.1 → 4.0.0

package/dist/style-downloader.cjs

@@ -0,0 +1,312 @@
+"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 style_downloader_exports = {};
+__export(style_downloader_exports, {
+  StyleDownloader: () => StyleDownloader
+});
+module.exports = __toCommonJS(style_downloader_exports);
+var import_check_geojson = require("@placemarkio/check-geojson");
+var import_filter_obj = require("filter-obj");
+var import_ky = __toESM(require("ky"), 1);
+var import_yocto_queue = __toESM(require("yocto-queue"), 1);
+var import_zlib = __toESM(require("zlib"), 1);
+var import_tile_downloader = require('./tile-downloader.cjs');
+var import_fetch = require('./utils/fetch.cjs');
+var import_mapbox = require('./utils/mapbox.cjs');
+var import_misc = require('./utils/misc.cjs');
+var import_style = require('./utils/style.cjs');
+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 = (0, import_mapbox.normalizeStyleURL)(style, this.#mapboxAccessToken);
+    } else if ((0, import_style.validateStyle)(style)) {
+      this.#inputStyle = (0, import_misc.clone)(style);
+    } else {
+      throw new AggregateError(import_style.validateStyle.errors, "Invalid style");
+    }
+    this.#fetchQueue = new import_fetch.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 (0, import_ky.default)(this.#styleURL).json();
+      if (!(0, import_style.validateStyle)(downloadedStyle)) {
+        throw new AggregateError(
+          import_style.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 ((0, import_style.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 = (0, import_mapbox.normalizeSourceURL)(source.url, this.#mapboxAccessToken);
+      const tilejson = await (0, import_ky.default)(sourceUrl).json();
+      (0, import_style.assertTileJSON)(tilejson);
+      return {
+        ...source,
+        ...(0, import_filter_obj.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 = (0, import_mapbox.normalizeSourceURL)(
+        source.data,
+        this.#mapboxAccessToken
+      );
+      const data = (0, import_check_geojson.check)(await (0, import_ky.default)(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 = (0, import_mapbox.normalizeSpriteURL)(url, format, ".json", accessToken);
+        const pngUrl = (0, import_mapbox.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 = import_misc.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 import_yocto_queue.default();
+    const fontStacks = /* @__PURE__ */ new Map();
+    (0, import_style.mapFontStacks)(style.layers, (fontStack) => {
+      fontStacks.set(fontStack[0], fontStack.join(","));
+      return [];
+    });
+    const glyphUrl = (0, import_mapbox.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(import_misc.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(import_misc.noop);
+      if (!downloadResponse) continue;
+      const { body } = downloadResponse;
+      const gzipper = import_zlib.default.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 = import_misc.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 = (0, import_tile_downloader.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StyleDownloader
+});

package/dist/style-downloader.d.cts

@@ -0,0 +1,120 @@
+import * as ky from 'ky';
+import { BBox } from './utils/geo.cjs';
+import * as stream from 'stream';
+import { b as StyleInlinedSources, G as GlyphInfo, T as TileInfo } from './types-B4Xn1F9K.cjs';
+import { TileDownloadStats } from './tile-downloader.cjs';
+import { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+import './utils/fetch.cjs';
+import './utils/streams.cjs';
+
+/** @import { SourceSpecification, StyleSpecification } from '@maplibre/maplibre-gl-style-spec' */
+/** @import { TileInfo, GlyphInfo, GlyphRange } from './writer.js' */
+/** @import { TileDownloadStats } from './tile-downloader.js' */
+/** @import { StyleInlinedSources, InlinedSource } from './types.js'*/
+/** @typedef { import('ky').ResponsePromise & { body: ReadableStream<Uint8Array> } } ResponsePromise */
+/** @import { DownloadResponse } from './utils/fetch.js' */
+/**
+ * @typedef {object} GlyphDownloadStats
+ * @property {number} total
+ * @property {number} downloaded
+ * @property {number} totalBytes
+ */
+/**
+ * Download a style and its resources for offline use. Please check the terms of
+ * service of the map provider you are using before downloading any resources.
+ */
+declare class StyleDownloader {
+    /**
+     * @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: string | StyleSpecification, { concurrency, mapboxAccessToken }?: {
+        concurrency?: number | undefined;
+        mapboxAccessToken?: string | undefined;
+    });
+    /**
+     * Number of active downloads.
+     */
+    get active(): number;
+    /**
+     * Download the style JSON for this style and inline the sources
+     *
+     * @returns {Promise<StyleInlinedSources>}
+     */
+    getStyle(): Promise<StyleInlinedSources>;
+    /**
+     * 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 }>}
+     */
+    getSprites(): AsyncGenerator<{
+        json: stream.Readable;
+        png: stream.Readable;
+        id: string;
+        pixelRatio: number;
+    }>;
+    /**
+     * 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]>}
+     */
+    getGlyphs({ onprogress }?: {
+        onprogress?: ((progress: GlyphDownloadStats) => void) | undefined;
+    }): AsyncGenerator<[stream.Readable, 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, trackErrors }: {
+        bounds: BBox;
+        maxzoom: number;
+        onprogress?: ((progress: TileDownloadStats) => void) | undefined;
+        trackErrors?: boolean | undefined;
+    }): AsyncGenerator<[stream.Readable, TileInfo]> & {
+        readonly skipped: Array<TileInfo & {
+            error?: Error;
+        }>;
+        readonly stats: TileDownloadStats;
+    };
+    #private;
+}
+type ResponsePromise = ky.ResponsePromise & {
+    body: ReadableStream<Uint8Array>;
+};
+type GlyphDownloadStats = {
+    total: number;
+    downloaded: number;
+    totalBytes: number;
+};
+
+export { type GlyphDownloadStats, type ResponsePromise, StyleDownloader };

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

@@ -1,3 +1,16 @@
+import * as ky from 'ky';
+import { BBox } from './utils/geo.js';
+import * as stream from 'stream';
+import { b as StyleInlinedSources, G as GlyphInfo, T as TileInfo } from './types-B4Xn1F9K.js';
+import { TileDownloadStats } from './tile-downloader.js';
+import { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+import './utils/fetch.js';
+import './utils/streams.js';
+
 /** @import { SourceSpecification, StyleSpecification } from '@maplibre/maplibre-gl-style-spec' */
 /** @import { TileInfo, GlyphInfo, GlyphRange } from './writer.js' */
 /** @import { TileDownloadStats } from './tile-downloader.js' */
@@ -14,7 +27,7 @@
  * Download a style and its resources for offline use. Please check the terms of
  * service of the map provider you are using before downloading any resources.
  */
-export default class StyleDownloader {
+declare class StyleDownloader {
     /**
      * @param {string | StyleSpecification} style A url to a style JSON file or a style object
      * @param {object} [opts]
@@ -43,8 +56,8 @@ export default class StyleDownloader {
      * @returns {AsyncGenerator<{ json: import('stream').Readable, png: import('stream').Readable, id: string, pixelRatio: number }>}
      */
     getSprites(): AsyncGenerator<{
-        json: import("stream").Readable;
-        png: import("stream").Readable;
+        json: stream.Readable;
+        png: stream.Readable;
         id: string;
         pixelRatio: number;
     }>;
@@ -64,7 +77,7 @@ export default class StyleDownloader {
      */
     getGlyphs({ onprogress }?: {
         onprogress?: ((progress: GlyphDownloadStats) => void) | undefined;
-    }): AsyncGenerator<[import("stream").Readable, GlyphInfo]>;
+    }): AsyncGenerator<[stream.Readable, 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
@@ -83,11 +96,11 @@ export default class StyleDownloader {
      * @returns {AsyncGenerator<[import('stream').Readable, TileInfo]> & { readonly skipped: Array<TileInfo & { error?: Error }>, readonly stats: TileDownloadStats }}
      */
     getTiles({ bounds, maxzoom, onprogress, trackErrors }: {
-        bounds: import("./utils/geo.js").BBox;
+        bounds: BBox;
         maxzoom: number;
         onprogress?: ((progress: TileDownloadStats) => void) | undefined;
         trackErrors?: boolean | undefined;
-    }): AsyncGenerator<[import("stream").Readable, TileInfo]> & {
+    }): AsyncGenerator<[stream.Readable, TileInfo]> & {
         readonly skipped: Array<TileInfo & {
             error?: Error;
         }>;
@@ -95,16 +108,13 @@ export default class StyleDownloader {
     };
     #private;
 }
-export type ResponsePromise = import("ky").ResponsePromise & {
+type ResponsePromise = ky.ResponsePromise & {
     body: ReadableStream<Uint8Array>;
 };
-export type GlyphDownloadStats = {
+type GlyphDownloadStats = {
     total: number;
     downloaded: number;
     totalBytes: number;
 };
-import type { StyleInlinedSources } from './types.js';
-import type { GlyphInfo } from './writer.js';
-import type { TileDownloadStats } from './tile-downloader.js';
-import type { TileInfo } from './writer.js';
-import type { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+
+export { type GlyphDownloadStats, type ResponsePromise, StyleDownloader };