styled-map-package 2.2.0 → 3.0.0

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

@@ -1,27 +1,35 @@
+import * as type_fest from 'type-fest';
+import { T as TileInfo, d as GlyphRange, c as TileFormat } from '../types-B4Xn1F9K.js';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'stream';
+import 'readable-stream';
+import 'events';
+
 /**
  * @param {string} path
  * @returns
  */
-export function getResourceType(path: string): "sprite" | "tile" | "glyph" | "style";
+declare function getResourceType(path: string): "sprite" | "style" | "tile" | "glyph";
 /**
  * Determine the content type of a file based on its extension.
  *
  * @param {string} path
  */
-export function getContentType(path: string): "application/json; charset=utf-8" | "application/x-protobuf" | "image/png" | "image/jpeg" | "image/webp" | "application/vnd.mapbox-vector-tile";
+declare function getContentType(path: string): "application/json; charset=utf-8" | "application/x-protobuf" | "image/png" | "image/jpeg" | "image/webp" | "application/vnd.mapbox-vector-tile";
 /**
  * Get the filename for a tile, given the TileInfo
  *
  * @param {import("type-fest").SetRequired<import("../writer.js").TileInfo, 'format'>} tileInfo
  * @returns
  */
-export function getTileFilename({ sourceId, z, x, y, format }: import("type-fest").SetRequired<import("../writer.js").TileInfo, "format">): string;
+declare function getTileFilename({ sourceId, z, x, y, format }: type_fest.SetRequired<TileInfo, "format">): string;
 /**
  * Get a filename for a sprite file, given the sprite id, pixel ratio and extension
  *
  * @param {{ id: string, pixelRatio: number, ext: '.json' | '.png'}} spriteInfo
  */
-export function getSpriteFilename({ id, pixelRatio, ext }: {
+declare function getSpriteFilename({ id, pixelRatio, ext }: {
     id: string;
     pixelRatio: number;
     ext: ".json" | ".png";
@@ -33,14 +41,14 @@ export function getSpriteFilename({ id, pixelRatio, ext }: {
  * @param {string} options.fontstack
  * @param {import("../writer.js").GlyphRange} options.range
  */
-export function getGlyphFilename({ fontstack, range }: {
+declare function getGlyphFilename({ fontstack, range }: {
     fontstack: string;
-    range: import("../writer.js").GlyphRange;
+    range: GlyphRange;
 }): string;
 /**
  * Get the URI template for the sprites in the style
  */
-export function getSpriteUri(id?: string): string;
+declare function getSpriteUri(id?: string): string;
 /**
  * Get the URI template for tiles in the style
  *
@@ -49,9 +57,9 @@ export function getSpriteUri(id?: string): string;
  * @param {import("../writer.js").TileFormat} opts.format
  * @returns
  */
-export function getTileUri({ sourceId, format }: {
+declare function getTileUri({ sourceId, format }: {
     sourceId: string;
-    format: import("../writer.js").TileFormat;
+    format: TileFormat;
 }): string;
 /**
  * Replaces variables in a string with values provided in an object. Variables
@@ -61,8 +69,10 @@ export function getTileUri({ sourceId, format }: {
  * @param {Record<string, string | number>} variables - An object where the keys correspond to variable names and values correspond to the replacement values.
  * @returns {string} The string with the variables replaced by their corresponding values.
  */
-export function replaceVariables(template: string, variables: Record<string, string | number>): string;
-export const URI_SCHEME: "smp";
-export const URI_BASE: string;
-export const STYLE_FILE: "style.json";
-export const GLYPH_URI: string;
+declare function replaceVariables(template: string, variables: Record<string, string | number>): string;
+declare const URI_SCHEME: "smp";
+declare const URI_BASE: string;
+declare const STYLE_FILE: "style.json";
+declare const GLYPH_URI: string;
+
+export { GLYPH_URI, STYLE_FILE, URI_BASE, URI_SCHEME, getContentType, getGlyphFilename, getResourceType, getSpriteFilename, getSpriteUri, getTileFilename, getTileUri, replaceVariables };

package/dist/utils/templates.js

@@ -0,0 +1,79 @@
+const URI_SCHEME = "smp";
+const URI_BASE = URI_SCHEME + "://maps.v1/";
+const STYLE_FILE = "style.json";
+const SOURCES_FOLDER = "s";
+const SPRITES_FOLDER = "sprites";
+const FONTS_FOLDER = "fonts";
+const TILE_FILE = SOURCES_FOLDER + "/{sourceId}/{z}/{x}/{y}{ext}";
+const SPRITE_FILE = SPRITES_FOLDER + "/{id}/sprite{pixelRatio}{ext}";
+const GLYPH_FILE = FONTS_FOLDER + "/{fontstack}/{range}.pbf.gz";
+const GLYPH_URI = URI_BASE + GLYPH_FILE;
+const pathToResouceType = (
+  /** @type {const} */
+  {
+    [TILE_FILE.split("/")[0] + "/"]: "tile",
+    [SPRITE_FILE.split("/")[0] + "/"]: "sprite",
+    [GLYPH_FILE.split("/")[0] + "/"]: "glyph"
+  }
+);
+function getResourceType(path) {
+  if (path === "style.json") return "style";
+  for (const [prefix, type] of Object.entries(pathToResouceType)) {
+    if (path.startsWith(prefix)) return type;
+  }
+  throw new Error(`Unknown resource type for path: ${path}`);
+}
+function getContentType(path) {
+  if (path.endsWith(".json")) return "application/json; charset=utf-8";
+  if (path.endsWith(".pbf.gz") || path.endsWith(".pbf"))
+    return "application/x-protobuf";
+  if (path.endsWith(".png")) return "image/png";
+  if (path.endsWith(".jpg")) return "image/jpeg";
+  if (path.endsWith(".webp")) return "image/webp";
+  if (path.endsWith(".mvt.gz") || path.endsWith(".mvt"))
+    return "application/vnd.mapbox-vector-tile";
+  throw new Error(`Unknown content type for path: ${path}`);
+}
+function getTileFilename({ sourceId, z, x, y, format }) {
+  const ext = "." + format + (format === "mvt" ? ".gz" : "");
+  return replaceVariables(TILE_FILE, { sourceId, z, x, y, ext });
+}
+function getSpriteFilename({ id, pixelRatio, ext }) {
+  return replaceVariables(SPRITE_FILE, {
+    id,
+    pixelRatio: getPixelRatioString(pixelRatio),
+    ext
+  });
+}
+function getGlyphFilename({ fontstack, range }) {
+  return replaceVariables(GLYPH_FILE, { fontstack, range });
+}
+function getSpriteUri(id = "default") {
+  return URI_BASE + replaceVariables(SPRITE_FILE, { id, pixelRatio: "", ext: "" });
+}
+function getTileUri({ sourceId, format }) {
+  const ext = "." + format + (format === "mvt" ? ".gz" : "");
+  return URI_BASE + TILE_FILE.replace("{sourceId}", sourceId).replace("{ext}", ext);
+}
+function getPixelRatioString(pixelRatio) {
+  return pixelRatio === 1 ? "" : `@${pixelRatio}x`;
+}
+function replaceVariables(template, variables) {
+  return template.replace(/{(.*?)}/g, (match, varName) => {
+    return varName in variables ? String(variables[varName]) : match;
+  });
+}
+export {
+  GLYPH_URI,
+  STYLE_FILE,
+  URI_BASE,
+  URI_SCHEME,
+  getContentType,
+  getGlyphFilename,
+  getResourceType,
+  getSpriteFilename,
+  getSpriteUri,
+  getTileFilename,
+  getTileUri,
+  replaceVariables
+};

package/dist/writer.cjs

@@ -0,0 +1,401 @@
+"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 writer_exports = {};
+__export(writer_exports, {
+  SUPPORTED_SOURCE_TYPES: () => SUPPORTED_SOURCE_TYPES,
+  Writer: () => Writer
+});
+module.exports = __toCommonJS(writer_exports);
+var import_maplibre_gl_style_spec = require("@maplibre/maplibre-gl-style-spec");
+var import_bbox = require("@turf/bbox");
+var import_archiver = __toESM(require("archiver"), 1);
+var import_events = require("events");
+var import_filter_obj = require("filter-obj");
+var import_fs = __toESM(require("fs"), 1);
+var import_p_event = require("p-event");
+var import_readable_stream = require("readable-stream");
+var import_stream = require("stream");
+var import_file_formats = require('./utils/file-formats.cjs');
+var import_geo = require('./utils/geo.cjs');
+var import_misc = require('./utils/misc.cjs');
+var import_streams = require('./utils/streams.cjs');
+var import_style = require('./utils/style.cjs');
+var import_templates = require('./utils/templates.cjs');
+const SUPPORTED_SOURCE_TYPES = (
+  /** @type {const} */
+  [
+    "raster",
+    "vector",
+    "geojson"
+  ]
+);
+class Writer extends import_events.EventEmitter {
+  #archive = (0, import_archiver.default)("zip", { zlib: { level: 9 } }).setMaxListeners(Infinity).on("error", console.error);
+  /** @type {Set<string>} */
+  #addedFiles = /* @__PURE__ */ new Set();
+  /** @type {Set<string>} */
+  #fonts = /* @__PURE__ */ new Set();
+  /** @type {Set<string>} */
+  #addedSpriteIds = /* @__PURE__ */ new Set();
+  /** @type {Map<string, SourceInfo>} */
+  #sources = /* @__PURE__ */ new Map();
+  /** @type {StyleSpecification} */
+  #style;
+  #outputStream;
+  static SUPPORTED_SOURCE_TYPES = SUPPORTED_SOURCE_TYPES;
+  /**
+   * @param {any} style A v7 or v8 MapLibre style. v7 styles will be migrated to
+   * v8. (There are currently no typescript declarations for v7 styles, hence
+   * this is typed as `any` and validated internally)
+   * @param {object} opts
+   * @param {number} [opts.highWaterMark=1048576] The maximum number of bytes to buffer during write
+   */
+  constructor(style, { highWaterMark = 1024 * 1024 } = {}) {
+    super();
+    if (!style || !("version" in style)) {
+      throw new Error("Invalid style");
+    }
+    if (style.version !== 7 && style.version !== 8) {
+      throw new Error(`Invalid style: Unsupported version v${style.version}`);
+    }
+    if (!Array.isArray(style.layers)) {
+      throw new Error("Invalid style: missing layers property");
+    }
+    const styleCopy = (0, import_misc.clone)(style);
+    (0, import_maplibre_gl_style_spec.migrate)(styleCopy);
+    const errors = (0, import_maplibre_gl_style_spec.validateStyleMin)(styleCopy);
+    if (errors.length) {
+      throw new AggregateError(errors, "Invalid style");
+    }
+    this.#style = styleCopy;
+    for (const [sourceId, source] of Object.entries(this.#style.sources)) {
+      if (source.type !== "geojson") continue;
+      this.#addSource(sourceId, source);
+    }
+    this.#outputStream = new import_readable_stream.PassThrough({ highWaterMark });
+    (0, import_readable_stream.pipeline)(this.#archive, this.#outputStream, (err) => {
+      if (err) this.emit("error", err);
+    });
+  }
+  /**
+   * @returns {import('stream').Readable} Readable stream of the styled map package
+   */
+  get outputStream() {
+    return this.#outputStream;
+  }
+  #getBounds() {
+    let bounds;
+    let maxzoom = 0;
+    for (const { source } of this.#sources.values()) {
+      if (source.type === "geojson") {
+        if (isEmptyFeatureCollection(source.data)) continue;
+        const bbox2 = get2DBBox(source.data.bbox);
+        bounds = bounds ? (0, import_geo.unionBBox)([bounds, bbox2]) : [...bbox2];
+      } else {
+        if (source.maxzoom < maxzoom) continue;
+        if (source.maxzoom === maxzoom) {
+          bounds = bounds ? (0, import_geo.unionBBox)([bounds, source.bounds]) : source.bounds;
+        } else {
+          bounds = source.bounds;
+          maxzoom = source.maxzoom;
+        }
+      }
+    }
+    return bounds;
+  }
+  #getMaxZoom() {
+    let maxzoom = 0;
+    for (const { source } of this.#sources.values()) {
+      const sourceMaxzoom = (
+        // For GeoJSON sources, the maxzoom is 16 unless otherwise set
+        source.type === "geojson" ? source.maxzoom || 16 : source.maxzoom
+      );
+      maxzoom = Math.max(maxzoom, sourceMaxzoom);
+    }
+    return maxzoom;
+  }
+  /**
+   * Add a source definition to the styled map package
+   *
+   * @param {string} sourceId
+   * @param {InputSource} source
+   * @returns {SourceInfo}
+   */
+  #addSource(sourceId, source) {
+    const encodedSourceId = encodeSourceId(this.#sources.size);
+    const tileSourceOverrides = {
+      minzoom: 0,
+      maxzoom: 0,
+      bounds: (
+        /** @type {import('./utils/geo.js').BBox} */
+        [...import_geo.MAX_BOUNDS]
+      ),
+      tiles: (
+        /** @type {string[]} */
+        []
+      )
+    };
+    let smpSource;
+    switch (source.type) {
+      case "raster":
+      case "vector":
+        smpSource = {
+          ...(0, import_filter_obj.excludeKeys)(source, ["tiles", "url"]),
+          ...tileSourceOverrides
+        };
+        break;
+      case "geojson":
+        smpSource = {
+          ...source,
+          maxzoom: 0,
+          data: typeof source.data !== "string" ? (
+            // Add a bbox property to the GeoJSON data if it doesn't already have one
+            { ...source.data, bbox: source.data.bbox || (0, import_bbox.bbox)(source.data) }
+          ) : (
+            // If GeoJSON data is referenced by a URL, start with an empty FeatureCollection
+            {
+              type: "FeatureCollection",
+              features: [],
+              bbox: [0, 0, 0, 0]
+            }
+          )
+        };
+        break;
+    }
+    const sourceInfo = {
+      source: smpSource,
+      encodedSourceId
+    };
+    this.#sources.set(sourceId, sourceInfo);
+    return sourceInfo;
+  }
+  /**
+   * Add a tile to the styled map package
+   *
+   * @param {Source} tileData
+   * @param {TileInfo} opts
+   */
+  async addTile(tileData, { z, x, y, sourceId, format }) {
+    let sourceInfo = this.#sources.get(sourceId);
+    if (!sourceInfo) {
+      const source2 = this.#style.sources[sourceId];
+      if (!source2) {
+        throw new Error(`Source not referenced in style.json: ${sourceId}`);
+      }
+      if (source2.type !== "raster" && source2.type !== "vector") {
+        throw new Error(`Unsupported source type: ${source2.type}`);
+      }
+      sourceInfo = this.#addSource(sourceId, source2);
+    }
+    const { source, encodedSourceId } = sourceInfo;
+    if (source.type !== "raster" && source.type !== "vector") {
+      throw new Error(`Unsupported source type: ${source.type}`);
+    }
+    if (!format) {
+      const tileDataStream = typeof tileData === "string" ? import_fs.default.createReadStream(tileData) : tileData instanceof Uint8Array ? import_stream.Readable.from(tileData) : tileData;
+      [format, tileData] = await (0, import_file_formats.getTileFormatFromStream)(tileDataStream);
+    }
+    if (!sourceInfo.format) {
+      sourceInfo.format = format;
+    } else if (sourceInfo.format !== format) {
+      throw new Error(
+        `Tile format mismatch for source ${sourceId}: expected ${sourceInfo.format}, got ${format}`
+      );
+    }
+    const bbox2 = (0, import_geo.tileToBBox)({ z, x, y });
+    if (z > source.maxzoom) {
+      source.maxzoom = z;
+      source.bounds = bbox2;
+    } else if (z === source.maxzoom) {
+      source.bounds = (0, import_geo.unionBBox)([source.bounds, bbox2]);
+    }
+    const name = (0, import_templates.getTileFilename)({ sourceId: encodedSourceId, z, x, y, format });
+    return this.#append(tileData, { name, store: true });
+  }
+  /**
+   * Create a write stream for adding tiles to the styled map package
+   *
+   * @param {object} opts
+   * @param {number} [opts.concurrency=16] The number of concurrent writes
+   *
+   * @returns
+   */
+  createTileWriteStream({ concurrency = 16 } = {}) {
+    return (0, import_streams.writeStreamFromAsync)(this.addTile.bind(this), { concurrency });
+  }
+  /**
+   * Add a sprite to the styled map package
+   *
+   * @param {object} options
+   * @param {Source} options.json
+   * @param {Source} options.png
+   * @param {number} [options.pixelRatio]
+   * @param {string} [options.id='default']
+   * @returns {Promise<void>}
+   */
+  async addSprite({ json, png, pixelRatio = 1, id = "default" }) {
+    this.#addedSpriteIds.add(id);
+    const jsonName = (0, import_templates.getSpriteFilename)({ id, pixelRatio, ext: ".json" });
+    const pngName = (0, import_templates.getSpriteFilename)({ id, pixelRatio, ext: ".png" });
+    await Promise.all([
+      this.#append(json, { name: jsonName }),
+      this.#append(png, { name: pngName })
+    ]);
+  }
+  /**
+   * Add glyphs to the styled map package
+   *
+   * @param {Source} glyphData
+   * @param {GlyphInfo} glyphInfo
+   * @returns {Promise<void>}
+   */
+  addGlyphs(glyphData, { font: fontName, range }) {
+    this.#fonts.add(fontName);
+    const name = (0, import_templates.getGlyphFilename)({ fontstack: fontName, range });
+    return this.#append(glyphData, { name });
+  }
+  /**
+   * Create a write stream for adding glyphs to the styled map package
+   *
+   * @param {object} opts
+   * @param {number} [opts.concurrency=16] The number of concurrent writes
+   * @returns
+   */
+  createGlyphWriteStream({ concurrency = 16 } = {}) {
+    return (0, import_streams.writeStreamFromAsync)(this.addGlyphs.bind(this), { concurrency });
+  }
+  /**
+   * Finalize the styled map package and write the style to the archive.
+   * This method must be called to complete the archive.
+   * You must wait for your destination write stream to 'finish' before using the output.
+   */
+  finish() {
+    this.#prepareStyle();
+    const style = JSON.stringify(this.#style);
+    this.#append(style, { name: import_templates.STYLE_FILE });
+    this.#archive.finalize();
+  }
+  /**
+   * Mutates the style object to prepare it for writing to the archive.
+   * Deterministic: can be run more than once with the same result.
+   */
+  #prepareStyle() {
+    if (this.#sources.size === 0) {
+      throw new Error("Missing sources: add at least one source");
+    }
+    if (this.#style.glyphs && this.#fonts.size === 0) {
+      throw new Error(
+        "Missing fonts: style references glyphs but no fonts added"
+      );
+    }
+    (0, import_style.replaceFontStacks)(this.#style, [...this.#fonts]);
+    if (this.#style.glyphs) {
+      this.#style.glyphs = import_templates.GLYPH_URI;
+    }
+    if (typeof this.#style.sprite === "string") {
+      if (!this.#addedSpriteIds.has("default")) {
+        throw new Error(
+          "Missing sprite: style references sprite but none added"
+        );
+      }
+      this.#style.sprite = (0, import_templates.getSpriteUri)();
+    } else if (Array.isArray(this.#style.sprite)) {
+      this.#style.sprite = this.#style.sprite.map(({ id }) => {
+        if (!this.#addedSpriteIds.has(id)) {
+          throw new Error(
+            `Missing sprite: style references sprite ${id} but none added`
+          );
+        }
+        return { id, url: (0, import_templates.getSpriteUri)(id) };
+      });
+    }
+    this.#style.sources = {};
+    for (const [sourceId, { source, encodedSourceId, format = "mvt" }] of this.#sources) {
+      if (source.type === "geojson" && isEmptyFeatureCollection(source.data)) {
+        continue;
+      }
+      this.#style.sources[sourceId] = source;
+      if (!("tiles" in source)) continue;
+      source.tiles = [(0, import_templates.getTileUri)({ sourceId: encodedSourceId, format })];
+    }
+    this.#style.layers = this.#style.layers.filter(
+      (layer) => !("source" in layer) || !!this.#style.sources[layer.source]
+    );
+    const metadata = this.#style.metadata || (this.#style.metadata = {});
+    const bounds = this.#getBounds();
+    if (bounds) {
+      metadata["smp:bounds"] = bounds;
+      const [w, s, e, n] = bounds;
+      this.#style.center = [w + (e - w) / 2, s + (n - s) / 2];
+    }
+    metadata["smp:maxzoom"] = this.#getMaxZoom();
+    metadata["smp:sourceFolders"] = {};
+    for (const [sourceId, { encodedSourceId }] of this.#sources) {
+      metadata["smp:sourceFolders"][sourceId] = encodedSourceId;
+    }
+    this.#style.zoom = Math.max(0, this.#getMaxZoom() - 2);
+  }
+  /**
+   *
+   * @param {Source} source
+   * @param {{ name: string, store?: boolean }} options
+   * @returns {Promise<void>}
+   */
+  async #append(source, { name, store = false }) {
+    if (this.#addedFiles.has(name)) {
+      throw new Error(`${name} already added`);
+    }
+    this.#addedFiles.add(name);
+    const onAdded = (0, import_p_event.pEvent)(
+      this.#archive,
+      "entry",
+      (entry) => entry.name === name
+    );
+    this.#archive.append(convertSource(source), { name, store });
+    await onAdded;
+  }
+}
+function encodeSourceId(sourceIndex) {
+  return sourceIndex.toString(36);
+}
+function convertSource(source) {
+  return !Buffer.isBuffer(source) && source instanceof Uint8Array ? Buffer.from(source.buffer, source.byteOffset, source.length) : source;
+}
+function isEmptyFeatureCollection(data) {
+  return data.type === "FeatureCollection" && data.features.length === 0;
+}
+function get2DBBox(bbox2) {
+  if (bbox2.length === 4) return bbox2;
+  return [bbox2[0], bbox2[1], bbox2[3], bbox2[4]];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SUPPORTED_SOURCE_TYPES,
+  Writer
+});

package/dist/writer.d.cts

@@ -0,0 +1,7 @@
+export { G as GlyphInfo, d as GlyphRange, e as SUPPORTED_SOURCE_TYPES, f as Source, h as SourceInfo, g as SourceInternal, c as TileFormat, T as TileInfo, W as Writer } from './types-B4Xn1F9K.cjs';
+import 'readable-stream';
+import 'stream';
+import 'events';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';

package/dist/writer.d.ts

@@ -0,0 +1,7 @@
+export { G as GlyphInfo, d as GlyphRange, e as SUPPORTED_SOURCE_TYPES, f as Source, h as SourceInfo, g as SourceInternal, c as TileFormat, T as TileInfo, W as Writer } from './types-B4Xn1F9K.js';
+import 'readable-stream';
+import 'stream';
+import 'events';
+import '@maplibre/maplibre-gl-style-spec';
+import 'geojson';
+import 'type-fest';