styled-map-package 2.2.1 → 4.0.0

package/dist/reader.js

@@ -0,0 +1,138 @@
+import intoStream from "into-stream";
+import { open } from "yauzl-promise";
+import { json } from "node:stream/consumers";
+import { ENOENT } from "./utils/errors.js";
+import { noop } from "./utils/misc.js";
+import { validateStyle } from "./utils/style.js";
+import {
+  getContentType,
+  getResourceType,
+  STYLE_FILE,
+  URI_BASE
+} from "./utils/templates.js";
+class Reader {
+  /** @type {Promise<import('yauzl-promise').ZipFile>} */
+  #zipPromise;
+  #entriesPromise;
+  /** @type {undefined | Promise<void>} */
+  #closePromise;
+  /**
+   * @param {string | import('yauzl-promise').ZipFile} filepathOrZip Path to styled map package (`.styledmap`) file, or an instance of yauzl ZipFile
+   */
+  constructor(filepathOrZip) {
+    const zipPromise = this.#zipPromise = typeof filepathOrZip === "string" ? open(filepathOrZip) : Promise.resolve(filepathOrZip);
+    zipPromise.catch(noop);
+    this.#entriesPromise = (async () => {
+      const entries = /* @__PURE__ */ new Map();
+      if (this.#closePromise) return entries;
+      const zip = await zipPromise;
+      if (this.#closePromise) return entries;
+      for await (const entry of zip) {
+        if (this.#closePromise) return entries;
+        entries.set(entry.filename, entry);
+      }
+      return entries;
+    })();
+    this.#entriesPromise.catch(noop);
+  }
+  /**
+   * Resolves when the styled map package has been opened and the entries have
+   * been read. Throws any error that occurred during opening.
+   */
+  async opened() {
+    await this.#entriesPromise;
+  }
+  /**
+   * Get the style JSON from the styled map package. The URLs in the style JSON
+   * will be transformed to use the provided base URL.
+   *
+   * @param {string | null} [baseUrl] Base URL where you plan to serve the resources in this styled map package, e.g. `http://localhost:3000/maps/styleA`
+   * @returns {Promise<import('./types.js').SMPStyle>}
+   */
+  async getStyle(baseUrl = null) {
+    const styleEntry = (await this.#entriesPromise).get(STYLE_FILE);
+    if (!styleEntry) throw new ENOENT(STYLE_FILE);
+    const stream = await styleEntry.openReadStream();
+    const style = await json(stream);
+    if (!validateStyle(style)) {
+      throw new AggregateError(validateStyle.errors, "Invalid style");
+    }
+    if (typeof style.glyphs === "string") {
+      style.glyphs = getUrl(style.glyphs, baseUrl);
+    }
+    if (typeof style.sprite === "string") {
+      style.sprite = getUrl(style.sprite, baseUrl);
+    } else if (Array.isArray(style.sprite)) {
+      style.sprite = style.sprite.map(({ id, url }) => {
+        return { id, url: getUrl(url, baseUrl) };
+      });
+    }
+    for (const source of Object.values(style.sources)) {
+      if ("tiles" in source && source.tiles) {
+        source.tiles = source.tiles.map((tile) => getUrl(tile, baseUrl));
+      }
+    }
+    return (
+      /** @type {import('./types.js').SMPStyle} */
+      style
+    );
+  }
+  /**
+   * Get a resource from the styled map package. The path should be relative to
+   * the root of the package.
+   *
+   * @param {string} path
+   * @returns {Promise<Resource>}
+   */
+  async getResource(path) {
+    if (path[0] === "/") path = path.slice(1);
+    if (path === STYLE_FILE) {
+      const styleJSON = JSON.stringify(await this.getStyle());
+      return {
+        contentType: "application/json; charset=utf-8",
+        contentLength: Buffer.byteLength(styleJSON, "utf8"),
+        resourceType: "style",
+        stream: intoStream(styleJSON)
+      };
+    }
+    const entry = (await this.#entriesPromise).get(path);
+    if (!entry) throw new ENOENT(path);
+    const resourceType = getResourceType(path);
+    const contentType = getContentType(path);
+    const stream = await entry.openReadStream();
+    const resource = {
+      resourceType,
+      contentType,
+      contentLength: entry.uncompressedSize,
+      stream
+    };
+    if (path.endsWith(".gz")) {
+      resource.contentEncoding = "gzip";
+    }
+    return resource;
+  }
+  /**
+   * Close the styled map package file (should be called after reading the file to avoid memory leaks)
+   */
+  async close() {
+    if (this.#closePromise) return this.#closePromise;
+    this.#closePromise = (async () => {
+      const zip = await this.#zipPromise;
+      await zip.close();
+    })();
+    return this.#closePromise;
+  }
+}
+function getUrl(smpUri, baseUrl) {
+  if (!smpUri.startsWith(URI_BASE)) {
+    throw new Error(`Invalid SMP URI: ${smpUri}`);
+  }
+  if (typeof baseUrl !== "string") return smpUri;
+  if (!baseUrl.endsWith("/")) {
+    baseUrl += "/";
+  }
+  return smpUri.replace(URI_BASE, baseUrl);
+}
+export {
+  Reader
+};

package/dist/reporters.cjs

@@ -0,0 +1,122 @@
+"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 reporters_exports = {};
+__export(reporters_exports, {
+  ttyReporter: () => ttyReporter
+});
+module.exports = __toCommonJS(reporters_exports);
+var import_chalk = __toESM(require("chalk"), 1);
+var import_log_symbols = __toESM(require("log-symbols"), 1);
+var import_ora = __toESM(require("ora"), 1);
+var import_pretty_bytes = __toESM(require("pretty-bytes"), 1);
+var import_pretty_ms = __toESM(require("pretty-ms"), 1);
+var import_readable_stream = require("readable-stream");
+import_chalk.default.level = import_chalk.chalkStderr.level;
+const TASKS = (
+  /** @type {const} */
+  [
+    "style",
+    "sprites",
+    "tiles",
+    "glyphs",
+    "output"
+  ]
+);
+const TASK_LABEL = (
+  /** @type {const} */
+  {
+    style: "Downloading Map Style",
+    sprites: "Downloading Sprites",
+    tiles: "Downloading Tiles",
+    glyphs: "Downloading Glyphs",
+    output: "Writing Styled Map Package"
+  }
+);
+const TASK_SUFFIX = (
+  /** @type {{ [K in (typeof TASKS)[number]]: (progress: import('./download.js').DownloadProgress[K]) => string }} */
+  {
+    style: () => "",
+    sprites: ({ downloaded }) => `${downloaded}`,
+    tiles: ({ total, skipped, totalBytes, downloaded }) => {
+      const formattedTotal = total.toLocaleString();
+      const formattedCompleted = (downloaded + skipped).toLocaleString().padStart(formattedTotal.length);
+      return `${formattedCompleted}/${formattedTotal} (${(0, import_pretty_bytes.default)(totalBytes)})`;
+    },
+    glyphs: ({ total, downloaded, totalBytes }) => `${downloaded}/${total} (${(0, import_pretty_bytes.default)(totalBytes)})`,
+    output: ({ totalBytes }) => `${(0, import_pretty_bytes.default)(totalBytes)}`
+  }
+);
+function ttyReporter() {
+  let stats;
+  let current = 0;
+  let spinner;
+  return new import_readable_stream.Writable({
+    objectMode: true,
+    // @ts-ignore - missing type def
+    construct(cb) {
+      process.stderr.write("\n");
+      spinner = (0, import_ora.default)(TASK_LABEL[TASKS[current]]).start();
+      cb();
+    },
+    /** @param {ArrayLike<{ chunk: import('./download.js').DownloadProgress, encoding: string }>} chunks */
+    writev(chunks, cb) {
+      stats = chunks[chunks.length - 1].chunk;
+      while (current < TASKS.length && stats[TASKS[current]].done) {
+        spinner.suffixText = import_chalk.default.dim(
+          TASK_SUFFIX[TASKS[current]](
+            // @ts-ignore - too complicated for TS
+            stats[TASKS[current]]
+          )
+        );
+        spinner.succeed();
+        if (++current < TASKS.length) {
+          spinner = (0, import_ora.default)(TASK_LABEL[TASKS[current]]).start();
+        }
+      }
+      if (current < TASKS.length) {
+        spinner.suffixText = import_chalk.default.dim(
+          TASK_SUFFIX[TASKS[current]](
+            // @ts-ignore - too complicated for TS
+            stats[TASKS[current]]
+          )
+        );
+      } else {
+        process.stderr.write(
+          `${import_chalk.default.green(import_log_symbols.default.success)} Completed in ${(0, import_pretty_ms.default)(stats.elapsedMs)}
+`
+        );
+      }
+      cb();
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ttyReporter
+});

package/dist/reporters.d.cts

@@ -0,0 +1,10 @@
+import { Writable } from 'readable-stream';
+
+/**
+ * A writable stream to reporting download progress to a TTY terminal. Write
+ * progress messages to this stream for a pretty-printed progress task-list in
+ * the terminal.
+ */
+declare function ttyReporter(): Writable;
+
+export { ttyReporter };

package/dist/{lib/reporters.d.ts → reporters.d.ts}

@@ -1,7 +1,10 @@
+import { Writable } from 'readable-stream';
+
 /**
  * A writable stream to reporting download progress to a TTY terminal. Write
  * progress messages to this stream for a pretty-printed progress task-list in
  * the terminal.
  */
-export function ttyReporter(): Writable;
-import { Writable } from 'readable-stream';
+declare function ttyReporter(): Writable;
+
+export { ttyReporter };

package/dist/reporters.js

@@ -0,0 +1,88 @@
+import chalk, { chalkStderr } from "chalk";
+import logSymbols from "log-symbols";
+import ora from "ora";
+import prettyBytes from "pretty-bytes";
+import prettyMilliseconds from "pretty-ms";
+import { Writable } from "readable-stream";
+chalk.level = chalkStderr.level;
+const TASKS = (
+  /** @type {const} */
+  [
+    "style",
+    "sprites",
+    "tiles",
+    "glyphs",
+    "output"
+  ]
+);
+const TASK_LABEL = (
+  /** @type {const} */
+  {
+    style: "Downloading Map Style",
+    sprites: "Downloading Sprites",
+    tiles: "Downloading Tiles",
+    glyphs: "Downloading Glyphs",
+    output: "Writing Styled Map Package"
+  }
+);
+const TASK_SUFFIX = (
+  /** @type {{ [K in (typeof TASKS)[number]]: (progress: import('./download.js').DownloadProgress[K]) => string }} */
+  {
+    style: () => "",
+    sprites: ({ downloaded }) => `${downloaded}`,
+    tiles: ({ total, skipped, totalBytes, downloaded }) => {
+      const formattedTotal = total.toLocaleString();
+      const formattedCompleted = (downloaded + skipped).toLocaleString().padStart(formattedTotal.length);
+      return `${formattedCompleted}/${formattedTotal} (${prettyBytes(totalBytes)})`;
+    },
+    glyphs: ({ total, downloaded, totalBytes }) => `${downloaded}/${total} (${prettyBytes(totalBytes)})`,
+    output: ({ totalBytes }) => `${prettyBytes(totalBytes)}`
+  }
+);
+function ttyReporter() {
+  let stats;
+  let current = 0;
+  let spinner;
+  return new Writable({
+    objectMode: true,
+    // @ts-ignore - missing type def
+    construct(cb) {
+      process.stderr.write("\n");
+      spinner = ora(TASK_LABEL[TASKS[current]]).start();
+      cb();
+    },
+    /** @param {ArrayLike<{ chunk: import('./download.js').DownloadProgress, encoding: string }>} chunks */
+    writev(chunks, cb) {
+      stats = chunks[chunks.length - 1].chunk;
+      while (current < TASKS.length && stats[TASKS[current]].done) {
+        spinner.suffixText = chalk.dim(
+          TASK_SUFFIX[TASKS[current]](
+            // @ts-ignore - too complicated for TS
+            stats[TASKS[current]]
+          )
+        );
+        spinner.succeed();
+        if (++current < TASKS.length) {
+          spinner = ora(TASK_LABEL[TASKS[current]]).start();
+        }
+      }
+      if (current < TASKS.length) {
+        spinner.suffixText = chalk.dim(
+          TASK_SUFFIX[TASKS[current]](
+            // @ts-ignore - too complicated for TS
+            stats[TASKS[current]]
+          )
+        );
+      } else {
+        process.stderr.write(
+          `${chalk.green(logSymbols.success)} Completed in ${prettyMilliseconds(stats.elapsedMs)}
+`
+        );
+      }
+      cb();
+    }
+  });
+}
+export {
+  ttyReporter
+};

package/dist/server.cjs

@@ -0,0 +1,79 @@
+"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 server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_IttyRouter = require("itty-router/IttyRouter");
+var import_StatusError = require("itty-router/StatusError");
+var import_createResponse = require("itty-router/createResponse");
+var import_node_stream = require("node:stream");
+var import_errors = require('./utils/errors.cjs');
+function resourceResponse(resource, options = {}) {
+  const response = new Response(
+    // @ts-expect-error Some discrepancy between Typescript lib dom typings and @types/node typings
+    import_node_stream.Readable.toWeb(resource.stream),
+    options
+  );
+  response.headers.set("Content-Type", resource.contentType);
+  response.headers.set("Content-Length", resource.contentLength.toString());
+  if (resource.contentEncoding) {
+    response.headers.set("Content-Encoding", resource.contentEncoding);
+  }
+  return response;
+}
+const jsonRaw = (0, import_createResponse.createResponse)("application/json; charset=utf-8");
+const encoder = new TextEncoder();
+function json(obj) {
+  const data = encoder.encode(JSON.stringify(obj));
+  return jsonRaw(data, {
+    headers: { "Content-Length": data.length.toString() }
+  });
+}
+function createServer({ base = "/" } = {}) {
+  base = base.endsWith("/") ? base : base + "/";
+  const router = (0, import_IttyRouter.IttyRouter)({
+    base
+  }).get("/style.json", async (request, reader) => {
+    const baseUrl = new URL(base, request.url);
+    const style = await reader.getStyle(baseUrl.href);
+    return json(style);
+  }).get("*", async (request, reader) => {
+    const url = new URL(request.url);
+    const path = decodeURIComponent(url.pathname.slice(base.length - 1));
+    const resource = await reader.getResource(path);
+    return resourceResponse(resource);
+  });
+  return {
+    fetch: (request, reader) => {
+      return router.fetch(request, reader).catch((err) => {
+        if ((0, import_errors.isFileNotThereError)(err)) {
+          throw new import_StatusError.StatusError(404, "Not Found");
+        } else {
+          throw err;
+        }
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer
+});

package/dist/server.d.cts

@@ -0,0 +1,48 @@
+import { RequestLike } from 'itty-router';
+import { Reader } from './reader.cjs';
+import { IttyRouter } from 'itty-router/IttyRouter';
+import 'stream';
+import './types-B4Xn1F9K.cjs';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+import 'yauzl-promise';
+
+/**
+ * Create a server for serving styled map packages (SMP) over http. The server
+ * is a `fetch` handler that must be provided a WHATWG `Request` and a SMP
+ * `Reader` instance. Use `@whatwg-node/server` to use with Node.js HTTP server.
+ *
+ * To handle errors, catch errors from `fetch` and return appropriate HTTP responses.
+ * You can use `itty-router/error` for this.
+ *
+ * @example
+ * ```js
+ * import { createServer } from 'node:http'
+ * import { error } from 'itty-router/error'
+ * import { createServerAdapter } from '@whatwg-node/server'
+ * import { createServer as createSMPServer } from 'styled-map-package/server'
+ * import { Reader } from 'styled-map-package/reader'
+ *
+ * const reader = new Reader('path/to/your-style.smp')
+ * const smpServer = createSMPServer()
+ * const httpServer = createServer(createServerAdapter((request) => {
+ *   return smpServer.fetch(request, reader).catch(error)
+ * }))
+ * ```
+ *
+ * @param {object} [options]
+ * @param {string} [options.base='/'] Base path for the server routes
+ * @returns {{ fetch: (request: RequestLike, reader: ReaderLike) => Promise<Response> }} server instance
+ */
+declare function createServer({ base }?: {
+    base?: string | undefined;
+}): {
+    fetch: (request: RequestLike, reader: ReaderLike) => Promise<Response>;
+};
+type ReaderLike = Pick<Reader, keyof Reader>;
+type RouterType = typeof IttyRouter<IRequestStrict, [ReaderLike], Response>;
+
+export { type ReaderLike, type RouterType, createServer };

package/dist/server.d.ts

@@ -0,0 +1,48 @@
+import { RequestLike } from 'itty-router';
+import { Reader } from './reader.js';
+import { IttyRouter } from 'itty-router/IttyRouter';
+import 'stream';
+import './types-B4Xn1F9K.js';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+import 'yauzl-promise';
+
+/**
+ * Create a server for serving styled map packages (SMP) over http. The server
+ * is a `fetch` handler that must be provided a WHATWG `Request` and a SMP
+ * `Reader` instance. Use `@whatwg-node/server` to use with Node.js HTTP server.
+ *
+ * To handle errors, catch errors from `fetch` and return appropriate HTTP responses.
+ * You can use `itty-router/error` for this.
+ *
+ * @example
+ * ```js
+ * import { createServer } from 'node:http'
+ * import { error } from 'itty-router/error'
+ * import { createServerAdapter } from '@whatwg-node/server'
+ * import { createServer as createSMPServer } from 'styled-map-package/server'
+ * import { Reader } from 'styled-map-package/reader'
+ *
+ * const reader = new Reader('path/to/your-style.smp')
+ * const smpServer = createSMPServer()
+ * const httpServer = createServer(createServerAdapter((request) => {
+ *   return smpServer.fetch(request, reader).catch(error)
+ * }))
+ * ```
+ *
+ * @param {object} [options]
+ * @param {string} [options.base='/'] Base path for the server routes
+ * @returns {{ fetch: (request: RequestLike, reader: ReaderLike) => Promise<Response> }} server instance
+ */
+declare function createServer({ base }?: {
+    base?: string | undefined;
+}): {
+    fetch: (request: RequestLike, reader: ReaderLike) => Promise<Response>;
+};
+type ReaderLike = Pick<Reader, keyof Reader>;
+type RouterType = typeof IttyRouter<IRequestStrict, [ReaderLike], Response>;
+
+export { type ReaderLike, type RouterType, createServer };

package/dist/server.js

@@ -0,0 +1,55 @@
+import { IttyRouter } from "itty-router/IttyRouter";
+import { StatusError } from "itty-router/StatusError";
+import { createResponse } from "itty-router/createResponse";
+import { Readable } from "node:stream";
+import { isFileNotThereError } from "./utils/errors.js";
+function resourceResponse(resource, options = {}) {
+  const response = new Response(
+    // @ts-expect-error Some discrepancy between Typescript lib dom typings and @types/node typings
+    Readable.toWeb(resource.stream),
+    options
+  );
+  response.headers.set("Content-Type", resource.contentType);
+  response.headers.set("Content-Length", resource.contentLength.toString());
+  if (resource.contentEncoding) {
+    response.headers.set("Content-Encoding", resource.contentEncoding);
+  }
+  return response;
+}
+const jsonRaw = createResponse("application/json; charset=utf-8");
+const encoder = new TextEncoder();
+function json(obj) {
+  const data = encoder.encode(JSON.stringify(obj));
+  return jsonRaw(data, {
+    headers: { "Content-Length": data.length.toString() }
+  });
+}
+function createServer({ base = "/" } = {}) {
+  base = base.endsWith("/") ? base : base + "/";
+  const router = IttyRouter({
+    base
+  }).get("/style.json", async (request, reader) => {
+    const baseUrl = new URL(base, request.url);
+    const style = await reader.getStyle(baseUrl.href);
+    return json(style);
+  }).get("*", async (request, reader) => {
+    const url = new URL(request.url);
+    const path = decodeURIComponent(url.pathname.slice(base.length - 1));
+    const resource = await reader.getResource(path);
+    return resourceResponse(resource);
+  });
+  return {
+    fetch: (request, reader) => {
+      return router.fetch(request, reader).catch((err) => {
+        if (isFileNotThereError(err)) {
+          throw new StatusError(404, "Not Found");
+        } else {
+          throw err;
+        }
+      });
+    }
+  };
+}
+export {
+  createServer
+};