styled-map-package 2.2.1 → 4.0.0

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 {};

package/dist/lib/utils/mapbox.d.ts

@@ -1,41 +0,0 @@
-/** @param {string} url */
-export function isMapboxURL(url: string): boolean;
-/**
- * @param {string} url
- * @param {string} [accessToken]
- */
-export function normalizeStyleURL(url: string, accessToken?: string): string;
-/**
- * @param {string} url
- * @param {string} [accessToken]
- */
-export function normalizeGlyphsURL(url: string, accessToken?: string): string;
-/**
- * @param {string} url
- * @param {string} [accessToken]
- */
-export function normalizeSourceURL(url: string, accessToken?: string): string;
-/**
- * @param {string} url
- * @param {'' | '@2x'} format
- * @param {'.png' | '.json'} extension
- * @param {string} [accessToken]
- */
-export function normalizeSpriteURL(url: string, format: "" | "@2x", extension: ".png" | ".json", accessToken?: string): string;
-/**
- * @param {any} tileURL
- * @param {string} sourceURL
- * @param {256 | 512} [tileSize]
- * @param {{ devicePixelRatio?: number; supportsWebp?: boolean; }} [opts]
- */
-export function normalizeTileURL(tileURL: any, sourceURL: string, tileSize?: 256 | 512, { devicePixelRatio, supportsWebp }?: {
-    devicePixelRatio?: number;
-    supportsWebp?: boolean;
-}): any;
-export const API_URL: "https://api.mapbox.com";
-export type URLObject = {
-    protocol: string;
-    authority: string;
-    path: string;
-    params: string[];
-};

package/lib/download.js

@@ -1,114 +0,0 @@
-import { Transform } from 'readable-stream'
-import { pipeline } from 'stream/promises'
-
-import Writer from '../lib/writer.js'
-import StyleDownloader from './style-downloader.js'
-
-/**
- * @typedef {object} DownloadProgress
- * @property {import('./tile-downloader.js').TileDownloadStats & { done: boolean }} tiles
- * @property {{ done: boolean }} style
- * @property {{ downloaded: number, done: boolean }} sprites
- * @property {import('./style-downloader.js').GlyphDownloadStats & { done: boolean }} glyphs
- * @property {{ totalBytes: number, done: boolean }} output
- * @property {number} elapsedMs
- */
-
-/**
- * Download a map style and its resources for a given bounding box and max zoom
- * level. Returns a readable stream of a "styled map package", a zip file
- * containing all the resources needed to serve the style offline.
- *
- * @param {object} opts
- * @param {import("./utils/geo.js").BBox} opts.bbox Bounding box to download tiles for
- * @param {number} opts.maxzoom Max zoom level to download tiles for
- * @param {string} opts.styleUrl URL of the style to download
- * @param { (progress: DownloadProgress) => void } [opts.onprogress] Optional callback for reporting progress
- * @param {string} [opts.accessToken]
- * @returns {import('./types.js').DownloadStream} Readable stream of the output styled map file
- */
-export default function download({
-  bbox,
-  maxzoom,
-  styleUrl,
-  onprogress,
-  accessToken,
-}) {
-  const downloader = new StyleDownloader(styleUrl, {
-    concurrency: 24,
-    mapboxAccessToken: accessToken,
-  })
-
-  let start = Date.now()
-  /** @type {DownloadProgress} */
-  let progress = {
-    tiles: { downloaded: 0, totalBytes: 0, total: 0, skipped: 0, done: false },
-    style: { done: false },
-    sprites: { downloaded: 0, done: false },
-    glyphs: { downloaded: 0, total: 0, totalBytes: 0, done: false },
-    output: { totalBytes: 0, done: false },
-    elapsedMs: 0,
-  }
-
-  const sizeCounter = new Transform({
-    transform(chunk, encoding, cb) {
-      handleProgress({
-        output: {
-          totalBytes: progress.output.totalBytes + chunk.length,
-          done: false,
-        },
-      })
-      cb(null, chunk)
-    },
-    final(cb) {
-      handleProgress({ output: { ...progress.output, done: true } })
-      cb()
-    },
-  })
-
-  /** @param {Partial<DownloadProgress>} update */
-  function handleProgress(update) {
-    progress = { ...progress, ...update, elapsedMs: Date.now() - start }
-    onprogress?.(progress)
-  }
-
-  ;(async () => {
-    const style = await downloader.getStyle()
-    const writer = new Writer(style)
-    handleProgress({ style: { done: true } })
-    writer.outputStream.pipe(sizeCounter)
-    writer.on('error', (err) => sizeCounter.destroy(err))
-
-    try {
-      for await (const spriteInfo of downloader.getSprites()) {
-        await writer.addSprite(spriteInfo)
-        handleProgress({
-          sprites: { downloaded: progress.sprites.downloaded + 1, done: false },
-        })
-      }
-      handleProgress({ sprites: { ...progress.sprites, done: true } })
-
-      const tiles = downloader.getTiles({
-        bounds: bbox,
-        maxzoom,
-        onprogress: (tileStats) =>
-          handleProgress({ tiles: { ...tileStats, done: false } }),
-      })
-      await pipeline(tiles, writer.createTileWriteStream({ concurrency: 24 }))
-      handleProgress({ tiles: { ...progress.tiles, done: true } })
-
-      const glyphs = downloader.getGlyphs({
-        onprogress: (glyphStats) =>
-          handleProgress({ glyphs: { ...glyphStats, done: false } }),
-      })
-      await pipeline(glyphs, writer.createGlyphWriteStream())
-      handleProgress({ glyphs: { ...progress.glyphs, done: true } })
-
-      writer.finish()
-    } catch (err) {
-      writer.outputStream.destroy(/** @type {Error} */ (err))
-    }
-  })()
-
-  return sizeCounter
-}

package/lib/from-mbtiles.js

@@ -1,83 +0,0 @@
-import { MBTiles } from 'mbtiles-reader'
-import SMPWriter from 'styled-map-package/writer'
-
-import fs from 'node:fs'
-import { Transform } from 'node:stream'
-import { pipeline } from 'node:stream'
-import { pipeline as pipelinePromise } from 'node:stream/promises'
-
-const SOURCE_ID = 'mbtiles-source'
-
-/**
- * @overload
- * @param {string} mbtilesPath
- * @returns {import('stream').Readable}
- */
-
-/**
- * @overload
- * @param {string} mbtilesPath
- * @param {string} outputPath
- * @returns {Promise<void>}
- */
-
-/**
- * @param {string} mbtilesPath
- * @param {string} [outputPath]
- * @returns {Promise<void> | import('stream').Readable}
- */
-export default function fromMBTiles(mbtilesPath, outputPath) {
-  const reader = new MBTiles(mbtilesPath)
-  if (reader.metadata.format === 'pbf') {
-    throw new Error('Vector MBTiles are not yet supported')
-  }
-  const style = {
-    version: 8,
-    name: reader.metadata.name,
-    sources: {
-      [SOURCE_ID]: {
-        ...reader.metadata,
-        type: 'raster',
-      },
-    },
-    layers: [
-      {
-        id: 'background',
-        type: 'background',
-        paint: {
-          'background-color': 'white',
-        },
-      },
-      {
-        id: 'raster',
-        type: 'raster',
-        source: SOURCE_ID,
-        paint: {
-          'raster-opacity': 1,
-        },
-      },
-    ],
-  }
-
-  const writer = new SMPWriter(style)
-
-  const returnValue = outputPath
-    ? pipelinePromise(writer.outputStream, fs.createWriteStream(outputPath))
-    : writer.outputStream
-
-  const tileWriteStream = writer.createTileWriteStream()
-
-  const transform = new Transform({
-    objectMode: true,
-    transform({ z, x, y, data, format }, encoding, callback) {
-      callback(null, [data, { z, x, y, format, sourceId: SOURCE_ID }])
-    },
-  })
-
-  pipeline(reader, transform, tileWriteStream, (err) => {
-    if (err) return writer.outputStream.destroy(err)
-    writer.finish()
-  })
-
-  return returnValue
-}

package/lib/index.js

@@ -1,11 +0,0 @@
-/** @typedef {import('./types.js').SMPSource} SMPSource */
-/** @typedef {import('./types.js').SMPStyle} SMPStyle */
-
-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'

package/lib/reader-watch.js

@@ -1,133 +0,0 @@
-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'
-
-/** @implements {Pick<Reader, keyof Reader>} */
-export default 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
-    // Call this now to catch any synchronous errors
-    this.#tryToWatchFile()
-    // eagerly open Reader
-    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 = undefined
-          this.#maybeReader = undefined
-          this.#readerOpeningPromise = undefined
-          // Close the watcher (which on some platforms will continue watching
-          // the previous file) so on the next request we will start watching
-          // the new file
-          this.#watch?.close()
-          this.#watch = undefined
-        })
-        .on('error', noop)
-    } catch (error) {
-      if (isFileNotThereError(error)) {
-        // Ignore: File does not exist yet, but we'll try to open it later
-      } else {
-        throw error
-      }
-    }
-  }
-
-  async #get() {
-    if (isWin() && (this.#reader || this.#readerOpeningPromise)) {
-      // On Windows, the file watcher does not recognize file deletions, so we
-      // need to check if the file still exists each time
-      try {
-        await fsPromises.stat(this.#filepath)
-      } catch {
-        this.#watch?.close()
-        this.#watch = undefined
-        this.#reader?.close().catch(noop)
-        this.#reader = undefined
-        this.#maybeReader = undefined
-        this.#readerOpeningPromise = undefined
-      }
-    }
-    // Need to retry this each time in case it failed initially because the file
-    // was not present, or if the file was moved or deleted.
-    this.#tryToWatchFile()
-    // A lovely promise tangle to confuse future readers... sorry.
-    //
-    // 1. If the reader is already open, return it.
-    // 2. If the reader is in the process of opening, return a promise that will
-    //    return the reader instance if it opened without error, or throw.
-    // 3. If the reader threw an error during opening, try to open it again next
-    //    time this is called.
-    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 = undefined
-        this.#readerOpeningPromise = undefined
-      })
-    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()
-  }
-}
-
-/** @returns {boolean} */
-function isWin() {
-  return process.platform === 'win32'
-}

package/lib/reader.js

@@ -1,165 +0,0 @@
-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'
-
-/**
- * @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.
- */
-export default 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 () => {
-      /** @type {Map<string, import('yauzl-promise').Entry>} */
-      const entries = 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))
-      }
-    }
-    // Hard to get this type-safe without a validation function. Instead we
-    // trust the Writer and the tests for now.
-    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()
-    /** @type {Resource} */
-    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
-  }
-}
-
-/**
- * @param {string} smpUri
- * @param {string | null} baseUrl
- */
-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)
-}