styled-map-package 4.1.0 → 5.0.0-pre.0

package/dist/writer.d.ts

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

package/dist/writer.js

@@ -1,424 +0,0 @@
-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 {
-  FONTS_FOLDER,
-  getGlyphFilename,
-  getSpriteFilename,
-  getSpriteUri,
-  getTileFilename,
-  getTileUri,
-  GLYPH_URI,
-  SOURCES_FOLDER,
-  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.
-   */
-  async finish() {
-    this.#prepareStyle();
-    const style = JSON.stringify(this.#style);
-    await this.#append(style, { name: STYLE_FILE });
-    sortEntries(this.#archive);
-    await 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]];
-}
-function sortEntries(archive) {
-  const entries = (
-    /** @type {unknown} */
-    archive._module?.engine?._entries
-  );
-  if (!Array.isArray(entries)) {
-    throw new Error(
-      "Cannot find zip entries: check implementation changes in Archiver"
-    );
-  }
-  const sortedEntries = entries.sort(
-    /**
-     * @param {unknown} a
-     * @param {unknown} b
-     */
-    function(a, b) {
-      assertValidEntry(a);
-      assertValidEntry(b);
-      if (a.name === "style.json") return -1;
-      if (b.name === "style.json") return 1;
-      const foldersA = a.name.split("/");
-      const foldersB = b.name.split("/");
-      if (foldersA[0] === FONTS_FOLDER && foldersA[2] === "0-255.pbf.gz")
-        return -1;
-      if (foldersB[0] === FONTS_FOLDER && foldersB[2] === "0-255.pbf.gz")
-        return 1;
-      if (foldersA[0] === SOURCES_FOLDER && foldersB[0] !== SOURCES_FOLDER)
-        return -1;
-      if (foldersB[0] === SOURCES_FOLDER && foldersA[0] !== SOURCES_FOLDER)
-        return 1;
-      if (foldersA[0] === SOURCES_FOLDER && foldersB[0] === SOURCES_FOLDER) {
-        const zoomA = +foldersA[2];
-        const zoomB = +foldersB[2];
-        return zoomA - zoomB;
-      }
-      return 0;
-    }
-  );
-  archive._module.engine._entries = sortedEntries;
-}
-function assertValidEntry(maybeEntry) {
-  if (!maybeEntry || typeof maybeEntry !== "object" || !("name" in maybeEntry) || typeof maybeEntry.name !== "string") {
-    throw new Error(
-      "Unexpected zip entry type: check implementation changes in Archiver"
-    );
-  }
-}
-export {
-  SUPPORTED_SOURCE_TYPES,
-  Writer
-};

package/node_modules/@node-rs/crc32/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020-present LongYinan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/node_modules/@node-rs/crc32/README.md

@@ -1,61 +0,0 @@
-# `@node-rs/crc32`
-
-![](https://github.com/napi-rs/node-rs/workflows/CI/badge.svg)
-![](https://img.shields.io/npm/dm/@node-rs/crc32.svg?sanitize=true)
-
-Fastest `crc32` implement in `Node.js`
-
-The 4 tested implementations are:
-
-- **@node-rs/crc32** Hardware accelerated CRC-32C from [crc32fast](https://crates.io/crates/crc32fast)
-- **sse4_crc32c** Hardware accelerated CRC-32C from [sse4_crc32](https://github.com/Voxer/sse4_crc32)
-- **js_crc32c** Javascript implemented CRC-32C
-- **js_crc32** Javascript implemented CRC-32 from [buffer-crc32](https://github.com/brianloveswords/buffer-crc32)
-
-## Performance
-
-```bash
-@node-rs/crc32 for inputs 1024B x 5,108,123 ops/sec ±1.86% (89 runs sampled)
-@node-rs/crc32 for inputs 16931844B, avg 2066B x 271 ops/sec ±1.15% (85 runs sampled)
-sse4_crc32c_hw for inputs 1024B x 3,543,443 ops/sec ±1.39% (93 runs sampled)
-sse4_crc32c_hw for inputs 16931844B, avg 2066B x 209 ops/sec ±0.78% (76 runs sampled)
-sse4_crc32c_sw for inputs 1024B x 1,460,284 ops/sec ±2.35% (90 runs sampled)
-sse4_crc32c_sw for inputs 16931844B, avg 2066B x 93.50 ops/sec ±2.43% (69 runs sampled)
-js_crc32c for inputs 1024B x 464,681 ops/sec ±0.46% (91 runs sampled)
-js_crc32c for inputs 16931844B, avg 2066B x 28.25 ops/sec ±1.64% (51 runs sampled)
-js_crc32 for inputs 1024B x 442,272 ops/sec ±2.66% (93 runs sampled)
-js_crc32 for inputs 16931844B, avg 2066B x 22.12 ops/sec ±5.20% (40 runs sampled)
-+---------------------+-------------------+----------------------+
-|                     │ 1024B             │ 16931844B, avg 2066B |
-+---------------------+-------------------+----------------------+
-| @node-rs/crc32      │ 5,108,123 ops/sec │ 271 ops/sec          |
-+---------------------+-------------------+----------------------+
-| sse4_crc32c_hw      │ 3,543,443 ops/sec │ 209 ops/sec          |
-+---------------------+-------------------+----------------------+
-| sse4_crc32c_sw      │ 1,460,284 ops/sec │ 93.50 ops/sec        |
-+---------------------+-------------------+----------------------+
-| js_crc32c           │ 464,681 ops/sec   │ 28.25 ops/sec        |
-+---------------------+-------------------+----------------------+
-| js_crc32            │ 442,272 ops/sec   │ 22.12 ops/sec        |
-+---------------------+-------------------+----------------------+
-```
-
-## API
-
-> The type of **input initial crc** and **output crc number** is `u32`
-
-```ts
-export function crc32(input: Buffer, crc?: number): number
-export function crc32c(input: Buffer, crc?: number): number
-```
-
-## Usage
-
-```ts
-const { crc32 } = require('@node-rs/crc32')
-const { readFileSync } = require('fs')
-
-const content = readFileSync('./avatar.png')
-
-crc32(content)
-```

package/node_modules/@node-rs/crc32/browser.js

@@ -1 +0,0 @@
-export * from '@node-rs/crc32-wasm32-wasi'

package/node_modules/@node-rs/crc32/index.d.ts

@@ -1,5 +0,0 @@
-/* auto-generated by NAPI-RS */
-/* eslint-disable */
-export declare function crc32(input: string | Uint8Array, initialState?: number | undefined | null): number
-
-export declare function crc32c(input: string | Uint8Array, initialState?: number | undefined | null): number