styled-map-package 2.2.1 → 3.0.0

package/dist/writer.js

@@ -0,0 +1,374 @@
+import { validateStyleMin, migrate } from "@maplibre/maplibre-gl-style-spec";
+import { bbox } from "@turf/bbox";
+import archiver from "archiver";
+import { EventEmitter } from "events";
+import { excludeKeys } from "filter-obj";
+import fs from "fs";
+import { pEvent } from "p-event";
+import { PassThrough, pipeline } from "readable-stream";
+import { Readable } from "stream";
+import { getTileFormatFromStream } from "./utils/file-formats.js";
+import { MAX_BOUNDS, tileToBBox, unionBBox } from "./utils/geo.js";
+import { clone } from "./utils/misc.js";
+import { writeStreamFromAsync } from "./utils/streams.js";
+import { replaceFontStacks } from "./utils/style.js";
+import {
+  getGlyphFilename,
+  getSpriteFilename,
+  getSpriteUri,
+  getTileFilename,
+  getTileUri,
+  GLYPH_URI,
+  STYLE_FILE
+} from "./utils/templates.js";
+const SUPPORTED_SOURCE_TYPES = (
+  /** @type {const} */
+  [
+    "raster",
+    "vector",
+    "geojson"
+  ]
+);
+class Writer extends EventEmitter {
+  #archive = archiver("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 = clone(style);
+    migrate(styleCopy);
+    const errors = 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 PassThrough({ highWaterMark });
+    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 ? unionBBox([bounds, bbox2]) : [...bbox2];
+      } else {
+        if (source.maxzoom < maxzoom) continue;
+        if (source.maxzoom === maxzoom) {
+          bounds = bounds ? 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} */
+        [...MAX_BOUNDS]
+      ),
+      tiles: (
+        /** @type {string[]} */
+        []
+      )
+    };
+    let smpSource;
+    switch (source.type) {
+      case "raster":
+      case "vector":
+        smpSource = {
+          ...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 || 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" ? fs.createReadStream(tileData) : tileData instanceof Uint8Array ? Readable.from(tileData) : tileData;
+      [format, tileData] = await 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 = tileToBBox({ z, x, y });
+    if (z > source.maxzoom) {
+      source.maxzoom = z;
+      source.bounds = bbox2;
+    } else if (z === source.maxzoom) {
+      source.bounds = unionBBox([source.bounds, bbox2]);
+    }
+    const name = 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 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 = getSpriteFilename({ id, pixelRatio, ext: ".json" });
+    const pngName = 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 = 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 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: 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"
+      );
+    }
+    replaceFontStacks(this.#style, [...this.#fonts]);
+    if (this.#style.glyphs) {
+      this.#style.glyphs = 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 = 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: 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 = [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 = 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]];
+}
+export {
+  SUPPORTED_SOURCE_TYPES,
+  Writer
+};

package/package.json

@@ -1,65 +1,120 @@
 {
   "name": "styled-map-package",
-  "version": "2.2.1",
+  "version": "3.0.0",
   "description": "",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/lib/index.d.ts",
-      "import": "./lib/index.js"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./reader": {
-      "types": "./dist/lib/reader.d.ts",
-      "import": "./lib/reader.js"
+      "import": {
+        "types": "./dist/reader.d.ts",
+        "default": "./dist/reader.js"
+      },
+      "require": {
+        "types": "./dist/reader.d.cts",
+        "default": "./dist/reader.cjs"
+      }
     },
     "./reader-watch": {
-      "types": "./dist/lib/reader-watch.d.ts",
-      "import": "./lib/reader-watch.js"
+      "import": {
+        "types": "./dist/reader-watch.d.ts",
+        "default": "./dist/reader-watch.js"
+      },
+      "require": {
+        "types": "./dist/reader-watch.d.cts",
+        "default": "./dist/reader-watch.cjs"
+      }
     },
     "./writer": {
-      "types": "./dist/lib/writer.d.ts",
-      "import": "./lib/writer.js"
+      "import": {
+        "types": "./dist/writer.d.ts",
+        "default": "./dist/writer.js"
+      },
+      "require": {
+        "types": "./dist/writer.d.cts",
+        "default": "./dist/writer.cjs"
+      }
     },
     "./server": {
-      "types": "./dist/lib/server.d.ts",
-      "import": "./lib/server.js"
+      "import": {
+        "types": "./dist/server.d.ts",
+        "default": "./dist/server.js"
+      },
+      "require": {
+        "types": "./dist/server.d.cts",
+        "default": "./dist/server.cjs"
+      }
     },
     "./style-downloader": {
-      "types": "./dist/lib/style-downloader.d.ts",
-      "import": "./lib/style-downloader.js"
+      "import": {
+        "types": "./dist/style-downloader.d.ts",
+        "default": "./dist/style-downloader.js"
+      },
+      "require": {
+        "types": "./dist/style-downloader.d.cts",
+        "default": "./dist/style-downloader.cjs"
+      }
     },
     "./tile-downloader": {
-      "types": "./dist/lib/tile-downloader.d.ts",
-      "import": "./lib/tile-downloader.js"
+      "import": {
+        "types": "./dist/tile-downloader.d.ts",
+        "default": "./dist/tile-downloader.js"
+      },
+      "require": {
+        "types": "./dist/tile-downloader.d.cts",
+        "default": "./dist/tile-downloader.cjs"
+      }
     },
     "./download": {
-      "types": "./dist/lib/download.d.ts",
-      "import": "./lib/download.js"
+      "import": {
+        "types": "./dist/download.d.ts",
+        "default": "./dist/download.js"
+      },
+      "require": {
+        "types": "./dist/download.d.cts",
+        "default": "./dist/download.cjs"
+      }
     },
     "./from-mbtiles": {
-      "types": "./dist/lib/from-mbtiles.d.ts",
-      "import": "./lib/from-mbtiles.js"
-    }
+      "import": {
+        "types": "./dist/from-mbtiles.d.ts",
+        "default": "./dist/from-mbtiles.js"
+      },
+      "require": {
+        "types": "./dist/from-mbtiles.d.cts",
+        "default": "./dist/from-mbtiles.cjs"
+      }
+    },
+    "./package.json": "./package.json"
   },
-  "main": "./lib/index.js",
-  "types": "./dist/lib/index.d.ts",
   "bin": {
     "styled-map-package": "./bin/smp.js",
     "smp": "./bin/smp.js"
   },
-  "type": "module",
   "files": [
     "bin",
     "dist",
-    "lib",
     "map-viewer"
   ],
   "scripts": {
-    "test": "npm run lint && npm run types && node --test",
+    "test": "npm run lint && npm run build && npm run types && node --test",
     "prepare": "husky",
     "lint": "eslint .",
     "types": "tsc",
-    "build:types": "rimraf \"dist/\" && tsc -p tsconfig.publish.json",
-    "prepack": "npm run build:types"
+    "build": "tsup",
+    "prepack": "npm run build"
   },
   "keywords": [],
   "author": "",
@@ -99,14 +154,12 @@
     "yocto-queue": "^1.1.1"
   },
   "devDependencies": {
-    "@eslint/js": "^9.21.0",
+    "@eslint/js": "^9.25.1",
     "@jsquash/jpeg": "^1.4.0",
     "@jsquash/png": "^3.0.1",
     "@stealthybox/jpg-stream": "^1.1.2",
     "@trivago/prettier-plugin-sort-imports": "^4.3.0",
     "@types/archiver": "^6.0.3",
-    "@types/eslint": "^9.6.1",
-    "@types/eslint__js": "^8.42.3",
     "@types/geojson": "^7946.0.16",
     "@types/http-errors": "^2.0.4",
     "@types/mapbox__sphericalmercator": "^1.2.3",
@@ -115,9 +168,10 @@
     "@types/yauzl-promise": "^4.0.1",
     "ava": "^6.2.0",
     "block-stream2": "^2.1.0",
-    "eslint": "^9.21.0",
+    "esbuild-fix-imports-plugin": "^1.0.20",
+    "eslint": "^9.25.1",
     "execa": "^9.4.0",
-    "globals": "^15.9.0",
+    "globals": "^16.0.0",
     "husky": "^9.1.7",
     "jpg-stream": "^1.1.2",
     "lint-staged": "^15.4.3",
@@ -126,8 +180,8 @@
     "png-stream": "^1.0.5",
     "prettier": "^3.5.2",
     "random-bytes-readable-stream": "^3.0.0",
-    "rimraf": "^4.4.1",
     "tempy": "^3.1.0",
+    "tsup": "^8.4.0",
     "type-fest": "^4.35.0",
     "typescript": "^5.7.3"
   },

package/dist/lib/from-mbtiles.d.ts

@@ -1,13 +0,0 @@
-/**
- * @overload
- * @param {string} mbtilesPath
- * @returns {import('stream').Readable}
- */
-export default function fromMBTiles(mbtilesPath: string): import("stream").Readable;
-/**
- * @overload
- * @param {string} mbtilesPath
- * @param {string} outputPath
- * @returns {Promise<void>}
- */
-export default function fromMBTiles(mbtilesPath: string, outputPath: string): Promise<void>;

package/dist/lib/index.d.ts

@@ -1,10 +0,0 @@
-export { default as Reader } from "./reader.js";
-export { default as ReaderWatch } from "./reader-watch.js";
-export { default as Writer } from "./writer.js";
-export { default as Server } from "./server.js";
-export { default as StyleDownloader } from "./style-downloader.js";
-export { downloadTiles } from "./tile-downloader.js";
-export { default as download } from "./download.js";
-export { default as fromMBTiles } from "./from-mbtiles.js";
-export type SMPSource = import("./types.js").SMPSource;
-export type SMPStyle = import("./types.js").SMPStyle;

package/dist/lib/reader-watch.d.ts

@@ -1,13 +0,0 @@
-/** @implements {Pick<Reader, keyof Reader>} */
-export default class ReaderWatch implements Pick<Reader, keyof Reader> {
-    /**
-     * @param {string} filepath
-     */
-    constructor(filepath: string);
-    opened(): Promise<void>;
-    getStyle(baseUrl?: string | null): Promise<import("./types.js").SMPStyle>;
-    getResource(path: string): Promise<Resource>;
-    close(): Promise<void>;
-    #private;
-}
-import Reader from './reader.js';

package/dist/lib/server.d.ts

@@ -1,15 +0,0 @@
-export default function _default(instance: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>, opts: PluginOptions, done: (err?: Error) => void): void;
-export type PluginOptionsFilepath = {
-    /**
-     * Path to styled map package (`.smp`) file
-     */
-    filepath: string;
-};
-export type PluginOptionsReader = {
-    /**
-     * SMP Reader interface (also supports ReaderWatch)
-     */
-    reader: Pick<Reader, keyof Reader>;
-};
-export type PluginOptions = PluginOptionsFilepath | PluginOptionsReader;
-import Reader from './reader.js';

package/dist/lib/types.d.ts

@@ -1,64 +0,0 @@
-import type { SourceSpecification, StyleSpecification, ValidationError, GeoJSONSourceSpecification, VectorSourceSpecification, RasterSourceSpecification, RasterDEMSourceSpecification } from '@maplibre/maplibre-gl-style-spec';
-import type { GeoJSON, BBox } from 'geojson';
-import type { Readable } from 'stream';
-import type { SetRequired } from 'type-fest';
-import { SUPPORTED_SOURCE_TYPES } from './writer.js';
-export type InputSource = Extract<SourceSpecification, {
-    type: (typeof SUPPORTED_SOURCE_TYPES)[number];
-}>;
-type TransformInlinedSource<T extends SourceSpecification> = T extends GeoJSONSourceSpecification ? OmitUnion<T, 'data'> & {
-    data: GeoJSON;
-} : T extends VectorSourceSpecification | RasterSourceSpecification | RasterDEMSourceSpecification ? SetRequired<OmitUnion<T, 'url'>, 'tiles'> : T;
-/**
- * This is a slightly stricter version of SourceSpecification that requires
- * sources to be inlined (e.g. no urls to TileJSON or GeoJSON files).
- */
-export type InlinedSource = TransformInlinedSource<SourceSpecification>;
-type SupportedInlinedSource = Extract<InlinedSource, {
-    type: (typeof SUPPORTED_SOURCE_TYPES)[number];
-}>;
-/**
- * This is a slightly stricter version of StyleSpecification that requires
- * sources to be inlined (e.g. no urls to TileJSON or GeoJSON files).
- */
-export type StyleInlinedSources = Omit<StyleSpecification, 'sources'> & {
-    sources: {
-        [_: string]: InlinedSource;
-    };
-};
-export type SMPSource = TransformSMPInputSource<SupportedInlinedSource>;
-/**
- * This is a slightly stricter version of StyleSpecification that is provided in
- * a Styled Map Package. Tile sources must have tile URLs inlined (they cannot
- * refer to a TileJSON url), and they must have bounds, minzoom, and maxzoom.
- * GeoJSON sources must have inlined GeoJSON (not a URL to a GeoJSON file).
- */
-export type SMPStyle = TransformSMPStyle<StyleSpecification>;
-export type TransformSMPInputSource<T extends SupportedInlinedSource> = T extends GeoJSONSourceSpecification ? T & {
-    data: {
-        bbox: BBox;
-    };
-} : T extends RasterSourceSpecification | VectorSourceSpecification ? SetRequired<T, 'bounds' | 'minzoom' | 'maxzoom'> : T;
-type TransformSMPStyle<T extends StyleSpecification> = Omit<T, 'sources'> & {
-    metadata: {
-        'smp:bounds': [number, number, number, number];
-        'smp:maxzoom': 0;
-        'smp:sourceFolders': {
-            [_: string]: string;
-        };
-    };
-    sources: {
-        [_: string]: SMPSource;
-    };
-};
-export interface ValidateStyle {
-    (style: unknown): style is StyleSpecification;
-    errors: Array<ValidationError>;
-}
-export interface DownloadStream extends Readable {
-    iterator(...args: Parameters<Readable['iterator']>): AsyncIterableIterator<Buffer>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<Buffer>;
-}
-export type RequiredUnion<T> = T extends any ? Required<T> : never;
-export type OmitUnion<T, K extends keyof any> = T extends unknown ? Omit<T, K> : never;
-export {};