styled-map-package 2.2.1 → 4.0.0

package/dist/reader-watch.cjs

@@ -0,0 +1,135 @@
+"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 reader_watch_exports = {};
+__export(reader_watch_exports, {
+  ReaderWatch: () => ReaderWatch
+});
+module.exports = __toCommonJS(reader_watch_exports);
+var import_events = require("events");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_reader = require('./reader.cjs');
+var import_errors = require('./utils/errors.cjs');
+var import_misc = require('./utils/misc.cjs');
+class ReaderWatch {
+  /** @type {Reader | undefined} */
+  #reader;
+  /** @type {Reader | undefined} */
+  #maybeReader;
+  /** @type {Promise<Reader> | undefined} */
+  #readerOpeningPromise;
+  #filepath;
+  /** @type {fs.FSWatcher | undefined} */
+  #watch;
+  /**
+   * @param {string} filepath
+   */
+  constructor(filepath) {
+    this.#filepath = filepath;
+    this.#tryToWatchFile();
+    this.#get().catch(import_misc.noop);
+  }
+  #tryToWatchFile() {
+    if (this.#watch) return;
+    try {
+      this.#watch = import_node_fs.default.watch(this.#filepath, { persistent: false }, () => {
+        this.#reader?.close().catch(import_misc.noop);
+        this.#reader = void 0;
+        this.#maybeReader = void 0;
+        this.#readerOpeningPromise = void 0;
+        this.#watch?.close();
+        this.#watch = void 0;
+      }).on("error", import_misc.noop);
+    } catch (error) {
+      if ((0, import_errors.isFileNotThereError)(error)) {
+      } else {
+        throw error;
+      }
+    }
+  }
+  async #get() {
+    if (isWin() && (this.#reader || this.#readerOpeningPromise)) {
+      try {
+        await import_promises.default.stat(this.#filepath);
+      } catch {
+        this.#watch?.close();
+        this.#watch = void 0;
+        this.#reader?.close().catch(import_misc.noop);
+        this.#reader = void 0;
+        this.#maybeReader = void 0;
+        this.#readerOpeningPromise = void 0;
+      }
+    }
+    this.#tryToWatchFile();
+    if (this.#reader) return this.#reader;
+    if (this.#readerOpeningPromise) return this.#readerOpeningPromise;
+    this.#maybeReader = new import_reader.Reader(this.#filepath);
+    this.#readerOpeningPromise = this.#maybeReader.opened().then(() => {
+      if (!this.#maybeReader) {
+        throw new import_errors.ENOENT(this.#filepath);
+      }
+      this.#reader = this.#maybeReader;
+      return this.#reader;
+    }).finally(() => {
+      this.#maybeReader = void 0;
+      this.#readerOpeningPromise = void 0;
+    });
+    return this.#readerOpeningPromise;
+  }
+  /** @type {Reader['opened']} */
+  async opened() {
+    const reader = await this.#get();
+    return reader.opened();
+  }
+  /** @type {Reader['getStyle']} */
+  async getStyle(baseUrl = null) {
+    const reader = await this.#get();
+    return reader.getStyle(baseUrl);
+  }
+  /** @type {Reader['getResource']} */
+  async getResource(path) {
+    const reader = await this.#get();
+    return reader.getResource(path);
+  }
+  async close() {
+    const reader = await this.#get();
+    if (this.#watch) {
+      this.#watch.close();
+      await (0, import_events.once)(this.#watch, "close");
+    }
+    await reader.close();
+  }
+}
+function isWin() {
+  return process.platform === "win32";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReaderWatch
+});

package/dist/reader-watch.d.cts

@@ -0,0 +1,24 @@
+import { a as SMPStyle } from './types-B4Xn1F9K.cjs';
+import { Reader } from './reader.cjs';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'stream';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+import 'yauzl-promise';
+
+/** @implements {Pick<Reader, keyof Reader>} */
+declare class ReaderWatch implements Pick<Reader, keyof Reader> {
+    /**
+     * @param {string} filepath
+     */
+    constructor(filepath: string);
+    opened(): Promise<void>;
+    getStyle(baseUrl?: string | null): Promise<SMPStyle>;
+    getResource(path: string): Promise<Resource>;
+    close(): Promise<void>;
+    #private;
+}
+
+export { ReaderWatch };

package/dist/reader-watch.d.ts

@@ -0,0 +1,24 @@
+import { a as SMPStyle } from './types-B4Xn1F9K.js';
+import { Reader } from './reader.js';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'stream';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+import 'yauzl-promise';
+
+/** @implements {Pick<Reader, keyof Reader>} */
+declare class ReaderWatch implements Pick<Reader, keyof Reader> {
+    /**
+     * @param {string} filepath
+     */
+    constructor(filepath: string);
+    opened(): Promise<void>;
+    getStyle(baseUrl?: string | null): Promise<SMPStyle>;
+    getResource(path: string): Promise<Resource>;
+    close(): Promise<void>;
+    #private;
+}
+
+export { ReaderWatch };

package/dist/reader-watch.js

@@ -0,0 +1,101 @@
+import { once } from "events";
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import { Reader } from "./reader.js";
+import { ENOENT, isFileNotThereError } from "./utils/errors.js";
+import { noop } from "./utils/misc.js";
+class ReaderWatch {
+  /** @type {Reader | undefined} */
+  #reader;
+  /** @type {Reader | undefined} */
+  #maybeReader;
+  /** @type {Promise<Reader> | undefined} */
+  #readerOpeningPromise;
+  #filepath;
+  /** @type {fs.FSWatcher | undefined} */
+  #watch;
+  /**
+   * @param {string} filepath
+   */
+  constructor(filepath) {
+    this.#filepath = filepath;
+    this.#tryToWatchFile();
+    this.#get().catch(noop);
+  }
+  #tryToWatchFile() {
+    if (this.#watch) return;
+    try {
+      this.#watch = fs.watch(this.#filepath, { persistent: false }, () => {
+        this.#reader?.close().catch(noop);
+        this.#reader = void 0;
+        this.#maybeReader = void 0;
+        this.#readerOpeningPromise = void 0;
+        this.#watch?.close();
+        this.#watch = void 0;
+      }).on("error", noop);
+    } catch (error) {
+      if (isFileNotThereError(error)) {
+      } else {
+        throw error;
+      }
+    }
+  }
+  async #get() {
+    if (isWin() && (this.#reader || this.#readerOpeningPromise)) {
+      try {
+        await fsPromises.stat(this.#filepath);
+      } catch {
+        this.#watch?.close();
+        this.#watch = void 0;
+        this.#reader?.close().catch(noop);
+        this.#reader = void 0;
+        this.#maybeReader = void 0;
+        this.#readerOpeningPromise = void 0;
+      }
+    }
+    this.#tryToWatchFile();
+    if (this.#reader) return this.#reader;
+    if (this.#readerOpeningPromise) return this.#readerOpeningPromise;
+    this.#maybeReader = new Reader(this.#filepath);
+    this.#readerOpeningPromise = this.#maybeReader.opened().then(() => {
+      if (!this.#maybeReader) {
+        throw new ENOENT(this.#filepath);
+      }
+      this.#reader = this.#maybeReader;
+      return this.#reader;
+    }).finally(() => {
+      this.#maybeReader = void 0;
+      this.#readerOpeningPromise = void 0;
+    });
+    return this.#readerOpeningPromise;
+  }
+  /** @type {Reader['opened']} */
+  async opened() {
+    const reader = await this.#get();
+    return reader.opened();
+  }
+  /** @type {Reader['getStyle']} */
+  async getStyle(baseUrl = null) {
+    const reader = await this.#get();
+    return reader.getStyle(baseUrl);
+  }
+  /** @type {Reader['getResource']} */
+  async getResource(path) {
+    const reader = await this.#get();
+    return reader.getResource(path);
+  }
+  async close() {
+    const reader = await this.#get();
+    if (this.#watch) {
+      this.#watch.close();
+      await once(this.#watch, "close");
+    }
+    await reader.close();
+  }
+}
+function isWin() {
+  return process.platform === "win32";
+}
+export {
+  ReaderWatch
+};

package/dist/reader.cjs

@@ -0,0 +1,167 @@
+"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 reader_exports = {};
+__export(reader_exports, {
+  Reader: () => Reader
+});
+module.exports = __toCommonJS(reader_exports);
+var import_into_stream = __toESM(require("into-stream"), 1);
+var import_yauzl_promise = require("yauzl-promise");
+var import_consumers = require("node:stream/consumers");
+var import_errors = require('./utils/errors.cjs');
+var import_misc = require('./utils/misc.cjs');
+var import_style = require('./utils/style.cjs');
+var import_templates = require('./utils/templates.cjs');
+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" ? (0, import_yauzl_promise.open)(filepathOrZip) : Promise.resolve(filepathOrZip);
+    zipPromise.catch(import_misc.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(import_misc.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(import_templates.STYLE_FILE);
+    if (!styleEntry) throw new import_errors.ENOENT(import_templates.STYLE_FILE);
+    const stream = await styleEntry.openReadStream();
+    const style = await (0, import_consumers.json)(stream);
+    if (!(0, import_style.validateStyle)(style)) {
+      throw new AggregateError(import_style.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 === import_templates.STYLE_FILE) {
+      const styleJSON = JSON.stringify(await this.getStyle());
+      return {
+        contentType: "application/json; charset=utf-8",
+        contentLength: Buffer.byteLength(styleJSON, "utf8"),
+        resourceType: "style",
+        stream: (0, import_into_stream.default)(styleJSON)
+      };
+    }
+    const entry = (await this.#entriesPromise).get(path);
+    if (!entry) throw new import_errors.ENOENT(path);
+    const resourceType = (0, import_templates.getResourceType)(path);
+    const contentType = (0, import_templates.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(import_templates.URI_BASE)) {
+    throw new Error(`Invalid SMP URI: ${smpUri}`);
+  }
+  if (typeof baseUrl !== "string") return smpUri;
+  if (!baseUrl.endsWith("/")) {
+    baseUrl += "/";
+  }
+  return smpUri.replace(import_templates.URI_BASE, baseUrl);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Reader
+});

package/dist/reader.d.cts

@@ -0,0 +1,62 @@
+import * as stream from 'stream';
+import { a as SMPStyle } from './types-B4Xn1F9K.cjs';
+import * as yauzl_promise from 'yauzl-promise';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+
+/**
+ * @typedef {object} Resource
+ * @property {string} resourceType
+ * @property {string} contentType
+ * @property {number} contentLength
+ * @property {import('stream').Readable} stream
+ * @property {'gzip'} [contentEncoding]
+ */
+/**
+ * A low-level reader for styled map packages. Returns resources in the package
+ * as readable streams, for serving over HTTP for example.
+ */
+declare class Reader {
+    /**
+     * @param {string | import('yauzl-promise').ZipFile} filepathOrZip Path to styled map package (`.styledmap`) file, or an instance of yauzl ZipFile
+     */
+    constructor(filepathOrZip: string | yauzl_promise.ZipFile);
+    /**
+     * Resolves when the styled map package has been opened and the entries have
+     * been read. Throws any error that occurred during opening.
+     */
+    opened(): Promise<void>;
+    /**
+     * 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>}
+     */
+    getStyle(baseUrl?: string | null): Promise<SMPStyle>;
+    /**
+     * 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>}
+     */
+    getResource(path: string): Promise<Resource>;
+    /**
+     * Close the styled map package file (should be called after reading the file to avoid memory leaks)
+     */
+    close(): Promise<void>;
+    #private;
+}
+type Resource = {
+    resourceType: string;
+    contentType: string;
+    contentLength: number;
+    stream: stream.Readable;
+    contentEncoding?: "gzip" | undefined;
+};
+
+export { Reader, type Resource };

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

@@ -1,3 +1,12 @@
+import * as stream from 'stream';
+import { a as SMPStyle } from './types-B4Xn1F9K.js';
+import * as yauzl_promise from 'yauzl-promise';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';
+import 'readable-stream';
+import 'events';
+
 /**
  * @typedef {object} Resource
  * @property {string} resourceType
@@ -10,11 +19,11 @@
  * A low-level reader for styled map packages. Returns resources in the package
  * as readable streams, for serving over HTTP for example.
  */
-export default class Reader {
+declare class Reader {
     /**
      * @param {string | import('yauzl-promise').ZipFile} filepathOrZip Path to styled map package (`.styledmap`) file, or an instance of yauzl ZipFile
      */
-    constructor(filepathOrZip: string | import("yauzl-promise").ZipFile);
+    constructor(filepathOrZip: string | yauzl_promise.ZipFile);
     /**
      * Resolves when the styled map package has been opened and the entries have
      * been read. Throws any error that occurred during opening.
@@ -27,7 +36,7 @@ export default class Reader {
      * @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>}
      */
-    getStyle(baseUrl?: string | null): Promise<import("./types.js").SMPStyle>;
+    getStyle(baseUrl?: string | null): Promise<SMPStyle>;
     /**
      * Get a resource from the styled map package. The path should be relative to
      * the root of the package.
@@ -42,10 +51,12 @@ export default class Reader {
     close(): Promise<void>;
     #private;
 }
-export type Resource = {
+type Resource = {
     resourceType: string;
     contentType: string;
     contentLength: number;
-    stream: import("stream").Readable;
+    stream: stream.Readable;
     contentEncoding?: "gzip" | undefined;
 };
+
+export { Reader, type Resource };