styled-map-package 2.2.1 → 3.0.0

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)
-}

package/lib/reporters.js

@@ -1,92 +0,0 @@
-import chalk, { chalkStderr } from 'chalk'
-import logSymbols from 'log-symbols'
-import ora from 'ora'
-import prettyBytes from 'pretty-bytes'
-import prettyMilliseconds from 'pretty-ms'
-import { Writable } from 'readable-stream'
-
-chalk.level = chalkStderr.level
-
-const TASKS = /** @type {const} */ ([
-  'style',
-  'sprites',
-  'tiles',
-  'glyphs',
-  'output',
-])
-
-const TASK_LABEL = /** @type {const} */ ({
-  style: 'Downloading Map Style',
-  sprites: 'Downloading Sprites',
-  tiles: 'Downloading Tiles',
-  glyphs: 'Downloading Glyphs',
-  output: 'Writing Styled Map Package',
-})
-
-const TASK_SUFFIX =
-  /** @type {{ [K in (typeof TASKS)[number]]: (progress: import('./download.js').DownloadProgress[K]) => string }} */ ({
-    style: () => '',
-    sprites: ({ downloaded }) => `${downloaded}`,
-    tiles: ({ total, skipped, totalBytes, downloaded }) => {
-      const formattedTotal = total.toLocaleString()
-      const formattedCompleted = (downloaded + skipped)
-        .toLocaleString()
-        .padStart(formattedTotal.length)
-      return `${formattedCompleted}/${formattedTotal} (${prettyBytes(totalBytes)})`
-    },
-    glyphs: ({ total, downloaded, totalBytes }) =>
-      `${downloaded}/${total} (${prettyBytes(totalBytes)})`,
-    output: ({ totalBytes }) => `${prettyBytes(totalBytes)}`,
-  })
-
-/**
- * A writable stream to reporting download progress to a TTY terminal. Write
- * progress messages to this stream for a pretty-printed progress task-list in
- * the terminal.
- */
-export function ttyReporter() {
-  /** @type {import('./download.js').DownloadProgress | undefined} */
-  let stats
-  let current = 0
-  /** @type {import('ora').Ora} */
-  let spinner
-  return new Writable({
-    objectMode: true,
-    // @ts-ignore - missing type def
-    construct(cb) {
-      process.stderr.write('\n')
-      spinner = ora(TASK_LABEL[TASKS[current]]).start()
-      cb()
-    },
-    /** @param {ArrayLike<{ chunk: import('./download.js').DownloadProgress, encoding: string }>} chunks */
-    writev(chunks, cb) {
-      stats = chunks[chunks.length - 1].chunk
-      while (current < TASKS.length && stats[TASKS[current]].done) {
-        spinner.suffixText = chalk.dim(
-          TASK_SUFFIX[TASKS[current]](
-            // @ts-ignore - too complicated for TS
-            stats[TASKS[current]],
-          ),
-        )
-        spinner.succeed()
-        if (++current < TASKS.length) {
-          spinner = ora(TASK_LABEL[TASKS[current]]).start()
-        }
-      }
-      if (current < TASKS.length) {
-        spinner.suffixText = chalk.dim(
-          TASK_SUFFIX[TASKS[current]](
-            // @ts-ignore - too complicated for TS
-            stats[TASKS[current]],
-          ),
-        )
-      } else {
-        process.stderr.write(
-          `${chalk.green(logSymbols.success)} Completed in ${prettyMilliseconds(stats.elapsedMs)}\n`,
-        )
-      }
-
-      cb()
-    },
-  })
-}