styled-map-package 2.2.1 → 4.0.0

package/dist/utils/fetch.d.cts

@@ -0,0 +1,51 @@
+import * as stream from 'stream';
+import { ProgressCallback } from './streams.cjs';
+import 'readable-stream';
+
+/**
+ * @typedef {object} DownloadResponse
+ * @property {import('stream').Readable} body Node ReadableStream of the response body
+ * @property {string | null} mimeType Content mime-type (from http content-type header)
+ * @property {number | null} contentLength Content length in bytes (from http content-length header)
+ */
+/**
+ * A wrapper for fetch that limits the number of concurrent downloads.
+ */
+declare class FetchQueue {
+    /** @param {number} concurrency */
+    constructor(concurrency: number);
+    get activeCount(): number;
+    /**
+     * Fetch a URL, limiting the number of concurrent downloads. Resolves with a
+     * `DownloadResponse`, which is a parsed from the Fetch `Response` objects,
+     * with `body` as a Node readable stream, and the MIME type and content length
+     * of the response.
+     *
+     * NB: The response body stream must be consumed to the end, otherwise the
+     * queue will never be emptied.
+     *
+     * @param {string} url
+     * @param {{ onprogress?: import('./streams.js').ProgressCallback }} opts
+     * @returns {Promise<DownloadResponse>}
+     */
+    fetch(url: string, { onprogress }?: {
+        onprogress?: ProgressCallback;
+    }): Promise<DownloadResponse>;
+    #private;
+}
+type DownloadResponse = {
+    /**
+     * Node ReadableStream of the response body
+     */
+    body: stream.Readable;
+    /**
+     * Content mime-type (from http content-type header)
+     */
+    mimeType: string | null;
+    /**
+     * Content length in bytes (from http content-length header)
+     */
+    contentLength: number | null;
+};
+
+export { type DownloadResponse, FetchQueue };

package/dist/{lib/utils → utils}/fetch.d.ts

@@ -1,3 +1,7 @@
+import * as stream from 'stream';
+import { ProgressCallback } from './streams.js';
+import 'readable-stream';
+
 /**
  * @typedef {object} DownloadResponse
  * @property {import('stream').Readable} body Node ReadableStream of the response body
@@ -7,7 +11,7 @@
 /**
  * A wrapper for fetch that limits the number of concurrent downloads.
  */
-export class FetchQueue {
+declare class FetchQueue {
     /** @param {number} concurrency */
     constructor(concurrency: number);
     get activeCount(): number;
@@ -25,15 +29,15 @@ export class FetchQueue {
      * @returns {Promise<DownloadResponse>}
      */
     fetch(url: string, { onprogress }?: {
-        onprogress?: import("./streams.js").ProgressCallback;
+        onprogress?: ProgressCallback;
     }): Promise<DownloadResponse>;
     #private;
 }
-export type DownloadResponse = {
+type DownloadResponse = {
     /**
      * Node ReadableStream of the response body
      */
-    body: import("stream").Readable;
+    body: stream.Readable;
     /**
      * Content mime-type (from http content-type header)
      */
@@ -43,3 +47,5 @@ export type DownloadResponse = {
      */
     contentLength: number | null;
 };
+
+export { type DownloadResponse, FetchQueue };

package/dist/utils/fetch.js

@@ -0,0 +1,62 @@
+import ky from "ky";
+import { pEvent } from "p-event";
+import pLimit from "p-limit";
+import { fromWebReadableStream, ProgressStream } from "./streams.js";
+class FetchQueue {
+  /** @type {import('p-limit').LimitFunction} */
+  #limit;
+  /** @param {number} concurrency */
+  constructor(concurrency) {
+    this.#limit = pLimit(concurrency);
+  }
+  get activeCount() {
+    return this.#limit.activeCount;
+  }
+  /**
+   * Fetch a URL, limiting the number of concurrent downloads. Resolves with a
+   * `DownloadResponse`, which is a parsed from the Fetch `Response` objects,
+   * with `body` as a Node readable stream, and the MIME type and content length
+   * of the response.
+   *
+   * NB: The response body stream must be consumed to the end, otherwise the
+   * queue will never be emptied.
+   *
+   * @param {string} url
+   * @param {{ onprogress?: import('./streams.js').ProgressCallback }} opts
+   * @returns {Promise<DownloadResponse>}
+   */
+  fetch(url, { onprogress } = {}) {
+    return new Promise((resolveResponse, rejectResponse) => {
+      this.#limit(fetchStream, {
+        url,
+        onresponse: resolveResponse,
+        onerror: rejectResponse,
+        onprogress
+      });
+    });
+  }
+}
+async function fetchStream({ url, onresponse, onerror, onprogress }) {
+  try {
+    const response = await ky(url, { retry: 3 });
+    if (!response.body) {
+      throw new Error("No body in response");
+    }
+    const body = fromWebReadableStream(response.body);
+    const contentType = response.headers.get("content-type");
+    const mimeType = typeof contentType === "string" ? contentType.split(";")[0] : null;
+    const contentLengthHeader = response.headers.get("content-length");
+    const contentLength = contentLengthHeader === null ? null : parseInt(contentLengthHeader, 10);
+    onresponse({
+      body: onprogress ? body.pipe(new ProgressStream({ onprogress })) : body,
+      mimeType,
+      contentLength
+    });
+    await pEvent(body, "end");
+  } catch (err) {
+    onerror(err instanceof Error ? err : new Error("Unknown error"));
+  }
+}
+export {
+  FetchQueue
+};

package/dist/utils/file-formats.cjs

@@ -0,0 +1,98 @@
+"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 file_formats_exports = {};
+__export(file_formats_exports, {
+  getFormatFromMimeType: () => getFormatFromMimeType,
+  getTileFormatFromBuffer: () => getTileFormatFromBuffer,
+  getTileFormatFromStream: () => getTileFormatFromStream
+});
+module.exports = __toCommonJS(file_formats_exports);
+var import_buffer_peek_stream = __toESM(require("buffer-peek-stream"), 1);
+var import_misc = require('./misc.cjs');
+const peek = import_buffer_peek_stream.default.promise;
+const MAGIC_BYTES = (
+  /** @type {const} */
+  {
+    png: [137, 80, 78, 71, 13, 10, 26, 10],
+    jpg: [255, 216, 255],
+    // eslint-disable-next-line no-sparse-arrays
+    webp: [82, 73, 70, 70, , , , , 87, 69, 66, 80],
+    // Include the compression-type byte, which is always 0x08 (DEFLATE) for gzip
+    gz: [31, 139, 8]
+  }
+);
+const MIME_TYPES = (
+  /** @type {const} */
+  {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/webp": "webp"
+  }
+);
+const magicByteMap = /* @__PURE__ */ new Map();
+for (const [ext, bytes] of Object.entries(MAGIC_BYTES)) {
+  magicByteMap.set(
+    bytes[0],
+    // @ts-ignore
+    ext
+  );
+}
+function getTileFormatFromBuffer(buf) {
+  const ext = magicByteMap.get(buf[0]);
+  if (!ext) {
+    throw new Error("Unknown file type");
+  }
+  const sig = MAGIC_BYTES[ext];
+  for (let i = 1; i < sig.length; i++) {
+    if (typeof sig[i] !== "undefined" && sig[i] !== buf[i]) {
+      throw new Error("Unknown file type");
+    }
+  }
+  if (ext === "gz") {
+    return "mvt";
+  }
+  return ext;
+}
+async function getTileFormatFromStream(tileData) {
+  const [peekedData, outputStream] = await peek(tileData, 16 * 1024);
+  tileData = outputStream;
+  const format = getTileFormatFromBuffer(peekedData);
+  return [format, outputStream];
+}
+function getFormatFromMimeType(mimeType) {
+  if (mimeType.startsWith("application/")) return "mvt";
+  if ((0, import_misc.hasOwn)(MIME_TYPES, mimeType)) return MIME_TYPES[mimeType];
+  throw new Error("Unsupported MIME type " + mimeType);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFormatFromMimeType,
+  getTileFormatFromBuffer,
+  getTileFormatFromStream
+});

package/dist/utils/file-formats.d.cts

@@ -0,0 +1,35 @@
+import * as stream from 'stream';
+import { c as TileFormat } from '../types-B4Xn1F9K.cjs';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+
+/**
+ * For a given buffer, determine the tile format based on the magic bytes.
+ * Will throw for unknown file types.
+ * Smaller and faster version of magic-bytes.js due to the limited use case.
+ *
+ * @param {Buffer | Uint8Array} buf
+ * @returns {import("../writer.js").TileFormat}
+ */
+declare function getTileFormatFromBuffer(buf: Buffer | Uint8Array): TileFormat;
+/**
+ * Determine the tile format from either a readable stream, buffer or Uint8Array
+ * from the magic bytes at the start of the file. Used if data is served without
+ * a content-type header.
+ *
+ * @param {import('stream').Readable} tileData
+ * @returns {Promise<[import("../writer.js").TileFormat, import('stream').Readable]>}
+ */
+declare function getTileFormatFromStream(tileData: stream.Readable): Promise<[TileFormat, stream.Readable]>;
+/**
+ * Get the tile format from a MIME type. Throws for unsupported types.
+ *
+ * @param {string} mimeType
+ * @returns {import("../writer.js").TileFormat}
+ */
+declare function getFormatFromMimeType(mimeType: string): TileFormat;
+
+export { getFormatFromMimeType, getTileFormatFromBuffer, getTileFormatFromStream };

package/dist/{lib/utils → utils}/file-formats.d.ts

@@ -1,3 +1,11 @@
+import * as stream from 'stream';
+import { c as TileFormat } from '../types-B4Xn1F9K.js';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+
 /**
  * For a given buffer, determine the tile format based on the magic bytes.
  * Will throw for unknown file types.
@@ -6,7 +14,7 @@
  * @param {Buffer | Uint8Array} buf
  * @returns {import("../writer.js").TileFormat}
  */
-export function getTileFormatFromBuffer(buf: Buffer | Uint8Array): import("../writer.js").TileFormat;
+declare function getTileFormatFromBuffer(buf: Buffer | Uint8Array): TileFormat;
 /**
  * Determine the tile format from either a readable stream, buffer or Uint8Array
  * from the magic bytes at the start of the file. Used if data is served without
@@ -15,11 +23,13 @@ export function getTileFormatFromBuffer(buf: Buffer | Uint8Array): import("../wr
  * @param {import('stream').Readable} tileData
  * @returns {Promise<[import("../writer.js").TileFormat, import('stream').Readable]>}
  */
-export function getTileFormatFromStream(tileData: import("stream").Readable): Promise<[import("../writer.js").TileFormat, import("stream").Readable]>;
+declare function getTileFormatFromStream(tileData: stream.Readable): Promise<[TileFormat, stream.Readable]>;
 /**
  * Get the tile format from a MIME type. Throws for unsupported types.
  *
  * @param {string} mimeType
  * @returns {import("../writer.js").TileFormat}
  */
-export function getFormatFromMimeType(mimeType: string): import("../writer.js").TileFormat;
+declare function getFormatFromMimeType(mimeType: string): TileFormat;
+
+export { getFormatFromMimeType, getTileFormatFromBuffer, getTileFormatFromStream };

package/dist/utils/file-formats.js

@@ -0,0 +1,62 @@
+import BufferPeerStream from "buffer-peek-stream";
+import { hasOwn } from "./misc.js";
+const peek = BufferPeerStream.promise;
+const MAGIC_BYTES = (
+  /** @type {const} */
+  {
+    png: [137, 80, 78, 71, 13, 10, 26, 10],
+    jpg: [255, 216, 255],
+    // eslint-disable-next-line no-sparse-arrays
+    webp: [82, 73, 70, 70, , , , , 87, 69, 66, 80],
+    // Include the compression-type byte, which is always 0x08 (DEFLATE) for gzip
+    gz: [31, 139, 8]
+  }
+);
+const MIME_TYPES = (
+  /** @type {const} */
+  {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/webp": "webp"
+  }
+);
+const magicByteMap = /* @__PURE__ */ new Map();
+for (const [ext, bytes] of Object.entries(MAGIC_BYTES)) {
+  magicByteMap.set(
+    bytes[0],
+    // @ts-ignore
+    ext
+  );
+}
+function getTileFormatFromBuffer(buf) {
+  const ext = magicByteMap.get(buf[0]);
+  if (!ext) {
+    throw new Error("Unknown file type");
+  }
+  const sig = MAGIC_BYTES[ext];
+  for (let i = 1; i < sig.length; i++) {
+    if (typeof sig[i] !== "undefined" && sig[i] !== buf[i]) {
+      throw new Error("Unknown file type");
+    }
+  }
+  if (ext === "gz") {
+    return "mvt";
+  }
+  return ext;
+}
+async function getTileFormatFromStream(tileData) {
+  const [peekedData, outputStream] = await peek(tileData, 16 * 1024);
+  tileData = outputStream;
+  const format = getTileFormatFromBuffer(peekedData);
+  return [format, outputStream];
+}
+function getFormatFromMimeType(mimeType) {
+  if (mimeType.startsWith("application/")) return "mvt";
+  if (hasOwn(MIME_TYPES, mimeType)) return MIME_TYPES[mimeType];
+  throw new Error("Unsupported MIME type " + mimeType);
+}
+export {
+  getFormatFromMimeType,
+  getTileFormatFromBuffer,
+  getTileFormatFromStream
+};

package/dist/utils/geo.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var geo_exports = {};
+__export(geo_exports, {
+  MAX_BOUNDS: () => MAX_BOUNDS,
+  getQuadkey: () => getQuadkey,
+  getTileUrl: () => getTileUrl,
+  tileToBBox: () => tileToBBox,
+  unionBBox: () => unionBBox
+});
+module.exports = __toCommonJS(geo_exports);
+const r2d = 180 / Math.PI;
+const MAX_BOUNDS = (
+  /** @type {BBox} */
+  [
+    -180,
+    -85.051129,
+    180,
+    85.051129
+  ]
+);
+function tileToBBox({ x, y, z }) {
+  const e = tile2lon({ x: x + 1, z });
+  const w = tile2lon({ x, z });
+  const s = tile2lat({ y: y + 1, z });
+  const n = tile2lat({ y, z });
+  return [w, s, e, n];
+}
+function getQuadkey({ x, y, z }) {
+  let quadkey = "";
+  let mask;
+  for (let i = z; i > 0; i--) {
+    mask = 1 << i - 1;
+    quadkey += (x & mask ? 1 : 0) + (y & mask ? 2 : 0);
+  }
+  return quadkey;
+}
+function getTileUrl(urls, { x, y, z, scheme = "xyz" }) {
+  const bboxEspg3857 = tileToBBox({ x, y: Math.pow(2, z) - y - 1, z });
+  const quadkey = getQuadkey({ x, y, z });
+  return urls[(x + y) % urls.length].replace("{prefix}", (x % 16).toString(16) + (y % 16).toString(16)).replace(/{z}/g, String(z)).replace(/{x}/g, String(x)).replace(/{y}/g, String(scheme === "tms" ? Math.pow(2, z) - y - 1 : y)).replace("{quadkey}", quadkey).replace("{bbox-epsg-3857}", bboxEspg3857.join(","));
+}
+function unionBBox(bboxes) {
+  let [w, s, e, n] = bboxes[0];
+  for (let i = 1; i < bboxes.length; i++) {
+    const [w1, s1, e1, n1] = bboxes[i];
+    w = Math.min(w, w1);
+    s = Math.min(s, s1);
+    e = Math.max(e, e1);
+    n = Math.max(n, n1);
+  }
+  return [w, s, e, n];
+}
+function tile2lon({ x, z }) {
+  return x / Math.pow(2, z) * 360 - 180;
+}
+function tile2lat({ y, z }) {
+  const n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
+  return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_BOUNDS,
+  getQuadkey,
+  getTileUrl,
+  tileToBBox,
+  unionBBox
+});

package/dist/utils/geo.d.cts

@@ -0,0 +1,46 @@
+/**
+ * @typedef {[number, number, number, number]} BBox
+ */
+/**
+ * Return the bounding box for the given tile.
+ *
+ * @param {{ x: number, y: number, z: number }} tile
+ * @returns {BBox} Bounding Box [w, s, e, n]
+ */
+declare function tileToBBox({ x, y, z }: {
+    x: number;
+    y: number;
+    z: number;
+}): BBox;
+/**
+ * @param {{ x: number, y: number, z: number }} tile
+ */
+declare function getQuadkey({ x, y, z }: {
+    x: number;
+    y: number;
+    z: number;
+}): string;
+/**
+ * From an array of tile URL templates, get the URL for the given tile.
+ *
+ * @param {string[]} urls
+ * @param {{ x: number, y: number, z: number, scheme?: 'xyz' | 'tms' }} opts
+ */
+declare function getTileUrl(urls: string[], { x, y, z, scheme }: {
+    x: number;
+    y: number;
+    z: number;
+    scheme?: "xyz" | "tms";
+}): string;
+/**
+ * Returns a bbox that is the smallest bounding box that contains all the input bboxes.
+ *
+ * @param {[BBox, ...BBox[]]} bboxes
+ * @returns {BBox} Bounding Box [w, s, e, n]
+ */
+declare function unionBBox(bboxes: [BBox, ...BBox[]]): BBox;
+/** Spherical Mercator max bounds, rounded to 6 decimal places */
+declare const MAX_BOUNDS: BBox;
+type BBox = [number, number, number, number];
+
+export { type BBox, MAX_BOUNDS, getQuadkey, getTileUrl, tileToBBox, unionBBox };

package/dist/{lib/utils → utils}/geo.d.ts

@@ -7,7 +7,7 @@
  * @param {{ x: number, y: number, z: number }} tile
  * @returns {BBox} Bounding Box [w, s, e, n]
  */
-export function tileToBBox({ x, y, z }: {
+declare function tileToBBox({ x, y, z }: {
     x: number;
     y: number;
     z: number;
@@ -15,7 +15,7 @@ export function tileToBBox({ x, y, z }: {
 /**
  * @param {{ x: number, y: number, z: number }} tile
  */
-export function getQuadkey({ x, y, z }: {
+declare function getQuadkey({ x, y, z }: {
     x: number;
     y: number;
     z: number;
@@ -26,7 +26,7 @@ export function getQuadkey({ x, y, z }: {
  * @param {string[]} urls
  * @param {{ x: number, y: number, z: number, scheme?: 'xyz' | 'tms' }} opts
  */
-export function getTileUrl(urls: string[], { x, y, z, scheme }: {
+declare function getTileUrl(urls: string[], { x, y, z, scheme }: {
     x: number;
     y: number;
     z: number;
@@ -38,7 +38,9 @@ export function getTileUrl(urls: string[], { x, y, z, scheme }: {
  * @param {[BBox, ...BBox[]]} bboxes
  * @returns {BBox} Bounding Box [w, s, e, n]
  */
-export function unionBBox(bboxes: [BBox, ...BBox[]]): BBox;
+declare function unionBBox(bboxes: [BBox, ...BBox[]]): BBox;
 /** Spherical Mercator max bounds, rounded to 6 decimal places */
-export const MAX_BOUNDS: BBox;
-export type BBox = [number, number, number, number];
+declare const MAX_BOUNDS: BBox;
+type BBox = [number, number, number, number];
+
+export { type BBox, MAX_BOUNDS, getQuadkey, getTileUrl, tileToBBox, unionBBox };

package/dist/utils/geo.js

@@ -0,0 +1,56 @@
+const r2d = 180 / Math.PI;
+const MAX_BOUNDS = (
+  /** @type {BBox} */
+  [
+    -180,
+    -85.051129,
+    180,
+    85.051129
+  ]
+);
+function tileToBBox({ x, y, z }) {
+  const e = tile2lon({ x: x + 1, z });
+  const w = tile2lon({ x, z });
+  const s = tile2lat({ y: y + 1, z });
+  const n = tile2lat({ y, z });
+  return [w, s, e, n];
+}
+function getQuadkey({ x, y, z }) {
+  let quadkey = "";
+  let mask;
+  for (let i = z; i > 0; i--) {
+    mask = 1 << i - 1;
+    quadkey += (x & mask ? 1 : 0) + (y & mask ? 2 : 0);
+  }
+  return quadkey;
+}
+function getTileUrl(urls, { x, y, z, scheme = "xyz" }) {
+  const bboxEspg3857 = tileToBBox({ x, y: Math.pow(2, z) - y - 1, z });
+  const quadkey = getQuadkey({ x, y, z });
+  return urls[(x + y) % urls.length].replace("{prefix}", (x % 16).toString(16) + (y % 16).toString(16)).replace(/{z}/g, String(z)).replace(/{x}/g, String(x)).replace(/{y}/g, String(scheme === "tms" ? Math.pow(2, z) - y - 1 : y)).replace("{quadkey}", quadkey).replace("{bbox-epsg-3857}", bboxEspg3857.join(","));
+}
+function unionBBox(bboxes) {
+  let [w, s, e, n] = bboxes[0];
+  for (let i = 1; i < bboxes.length; i++) {
+    const [w1, s1, e1, n1] = bboxes[i];
+    w = Math.min(w, w1);
+    s = Math.min(s, s1);
+    e = Math.max(e, e1);
+    n = Math.max(n, n1);
+  }
+  return [w, s, e, n];
+}
+function tile2lon({ x, z }) {
+  return x / Math.pow(2, z) * 360 - 180;
+}
+function tile2lat({ y, z }) {
+  const n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
+  return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+}
+export {
+  MAX_BOUNDS,
+  getQuadkey,
+  getTileUrl,
+  tileToBBox,
+  unionBBox
+};