styled-map-package 2.2.1 → 4.0.0

package/lib/tile-downloader.js

@@ -1,188 +0,0 @@
-import SphericalMercator from '@mapbox/sphericalmercator'
-import Queue from 'yocto-queue'
-import zlib from 'zlib'
-
-import { FetchQueue } from './utils/fetch.js'
-import {
-  getFormatFromMimeType,
-  getTileFormatFromStream,
-} from './utils/file-formats.js'
-import { getTileUrl, MAX_BOUNDS } from './utils/geo.js'
-import { noop } from './utils/misc.js'
-
-/** @typedef {Omit<import('./writer.js').TileInfo, 'sourceId'>} TileInfo */
-/**
- * @typedef {object} TileDownloadStats
- * @property {number} total
- * @property {number} downloaded
- * @property {number} skipped
- * @property {number} totalBytes
- */
-
-/**
- * Download tiles from a list of tile URLs within a bounding box and zoom range.
- * Returns an async generator of tile data as readable streams and tile info objects.
- *
- * @param {object} opts
- * @param {string[]} opts.tileUrls Array of tile URL templates. Use `{x}`, `{y}`, `{z}` placeholders, and optional `{scheme}` placeholder which can be `xyz` or `tms`.
- * @param {import('./utils/geo.js').BBox} opts.bounds Bounding box of the area to download
- * @param {number} opts.maxzoom Maximum zoom level to download
- * @param {(progress: TileDownloadStats) => void} [opts.onprogress] Callback to report download progress
- * @param {boolean} [opts.trackErrors=false] Include errors in the returned array of skipped tiles - this has memory overhead so should only be used for debugging.
- * @param {import('./utils/geo.js').BBox} [opts.sourceBounds=MAX_BOUNDS] Bounding box of source data.
- * @param {boolean} [opts.boundsBuffer=false] Buffer the bounds by one tile at each zoom level to ensure no tiles are missed at the edges. With this set to false, in most instances the map will appear incomplete when viewed because the downloaded tiles at lower zoom levels will not cover the map view area.
- * @param {number} [opts.minzoom=0] Minimum zoom level to download (for most cases this should be left as `0` - the size overhead is minimal, because each zoom level has 4x as many tiles)
- * @param {number} [opts.concurrency=8] Number of concurrent downloads (ignored if `fetchQueue` is provided)
- * @param {FetchQueue} [opts.fetchQueue=new FetchQueue(concurrency)] Optional fetch queue to use for downloading tiles
- * @param {'xyz' | 'tms'} [opts.scheme='xyz'] Tile scheme to use for tile URLs
- * @returns {AsyncGenerator<[import('stream').Readable, TileInfo]> & { readonly skipped: Array<TileInfo & { error?: Error }>, readonly stats: TileDownloadStats }}
- */
-export function downloadTiles({
-  tileUrls,
-  bounds,
-  maxzoom,
-  onprogress = noop,
-  trackErrors = false,
-  sourceBounds = MAX_BOUNDS,
-  boundsBuffer = false,
-  minzoom = 0,
-  concurrency = 8,
-  fetchQueue = new FetchQueue(concurrency),
-  scheme = 'xyz',
-}) {
-  /** @type {Array<TileInfo & { error?: Error }>} */
-  const skipped = []
-  let completed = 0
-  /** @type {TileDownloadStats} */
-  let stats = {
-    total: 0,
-    downloaded: 0,
-    skipped: 0,
-    totalBytes: 0,
-  }
-  /** @type {import('./utils/streams.js').ProgressCallback} */
-  function onDownloadProgress({ chunkBytes }) {
-    stats.totalBytes += chunkBytes
-    onprogress(stats)
-  }
-  /**
-   *
-   * @param {Error} error
-   * @param {TileInfo} tileInfo
-   */
-  function onDownloadError(error, tileInfo) {
-    if (trackErrors) {
-      skipped.push({ ...tileInfo, error })
-    } else {
-      skipped.push(tileInfo)
-    }
-    onprogress(stats)
-  }
-  function onDownloadComplete() {
-    stats.downloaded = ++completed - skipped.length
-    stats.skipped = skipped.length
-    onprogress(stats)
-  }
-
-  /** @type {ReturnType<downloadTiles>} */
-  const tiles = (async function* () {
-    /** @type {Queue<[Promise<void | import('./utils/fetch.js').DownloadResponse>, TileInfo]>} */
-    const queue = new Queue()
-    const tiles = tileIterator({
-      bounds,
-      minzoom,
-      maxzoom,
-      sourceBounds,
-      boundsBuffer,
-    })
-    for (const { x, y, z } of tiles) {
-      const tileURL = getTileUrl(tileUrls, { x, y, z, scheme })
-      const tileInfo = { z, x, y }
-      const result = fetchQueue
-        .fetch(tileURL, { onprogress: onDownloadProgress })
-        // We handle error here rather than below to avoid uncaught errors
-        .catch((err) => onDownloadError(err, tileInfo))
-      queue.enqueue([result, tileInfo])
-    }
-
-    stats.total = queue.size
-    if (onprogress) onprogress(stats)
-
-    for (const [result, tileInfo] of queue) {
-      // We handle any error above and add to `skipped`
-      const downloadResponse = await result.catch(noop)
-      if (!downloadResponse) continue
-      let { body, mimeType } = downloadResponse
-      body.on('end', onDownloadComplete)
-      body.on('error', (err) => onDownloadError(err, tileInfo))
-      /** @type {import('./writer.js').TileFormat} */
-      let format
-      if (mimeType) {
-        format = getFormatFromMimeType(mimeType)
-      } else {
-        ;[format, body] = await getTileFormatFromStream(body)
-      }
-
-      let stream = body
-      if (format === 'mvt') {
-        // MVT tiles are always gzipped. Unfortunately we can't stop fetch from
-        // ungzipping the data during download, so we need to re-gzip it.
-        const gzipStream = zlib.createGzip()
-        stream = body.pipe(gzipStream)
-        stream.on('error', (err) => gzipStream.destroy(err))
-      }
-
-      yield [stream, { ...tileInfo, format }]
-    }
-  })()
-
-  Object.defineProperty(tiles, 'skipped', {
-    get() {
-      return skipped
-    },
-  })
-
-  Object.defineProperty(tiles, 'stats', {
-    get() {
-      return stats
-    },
-  })
-
-  return tiles
-}
-
-/**
- *
- * @param {object} opts
- * @param {import('./utils/geo.js').BBox} [opts.bounds]
- * @param {import('./utils/geo.js').BBox} [opts.sourceBounds]
- * @param {boolean} [opts.boundsBuffer]
- * @param {number} [opts.minzoom]
- * @param {number} opts.maxzoom
- */
-export function* tileIterator({
-  bounds = [...MAX_BOUNDS],
-  minzoom = 0,
-  maxzoom,
-  sourceBounds,
-  boundsBuffer = false,
-}) {
-  const sm = new SphericalMercator({ size: 256 })
-  for (let z = minzoom; z <= maxzoom; z++) {
-    // Cloning bounds passed to sm.xyz because no guarantee it won't mutate the array
-    let { minX, minY, maxX, maxY } = sm.xyz([...bounds], z)
-    let sourceXYBounds = sourceBounds
-      ? sm.xyz([...sourceBounds], z)
-      : { minX, minY, maxX, maxY }
-    const buffer = boundsBuffer ? 1 : 0
-    minX = Math.max(0, minX - buffer, sourceXYBounds.minX)
-    minY = Math.max(0, minY - buffer, sourceXYBounds.minY)
-    maxX = Math.min(Math.pow(2, z) - 1, maxX + buffer, sourceXYBounds.maxX)
-    maxY = Math.min(Math.pow(2, z) - 1, maxY + buffer, sourceXYBounds.maxY)
-    for (let x = minX; x <= maxX; x++) {
-      for (let y = minY; y <= maxY; y++) {
-        yield { x, y, z }
-      }
-    }
-  }
-}

package/lib/types.ts

@@ -1,104 +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 { Except, SetRequired, Simplify } 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
-
-type SetRequiredIfPresent<
-  BaseType,
-  Keys extends keyof any,
-> = BaseType extends unknown
-  ? Keys extends keyof BaseType
-    ? Simplify<
-        // Pick just the keys that are optional from the base type.
-        Except<BaseType, Keys> &
-          // Pick the keys that should be required from the base type and make them required.
-          Required<Pick<BaseType, Keys>>
-      >
-    : never
-  : never

package/lib/utils/errors.js

@@ -1,24 +0,0 @@
-export class ENOENT extends Error {
-  code = 'ENOENT'
-  /** @param {string} path */
-  constructor(path) {
-    const message = `ENOENT: no such file or directory, open '${path}'`
-    super(message)
-    this.path = path
-  }
-}
-
-/**
- * Returns true if the error if because a file is not found. On Windows, some
- * operations like fs.watch() throw an EPERM error rather than ENOENT.
- *
- * @param {unknown} error
- * @returns {error is Error & { code: 'ENOENT' | 'EPERM' }}
- */
-export function isFileNotThereError(error) {
-  return (
-    error instanceof Error &&
-    'code' in error &&
-    (error.code === 'ENOENT' || error.code === 'EPERM')
-  )
-}

package/lib/utils/fetch.js

@@ -1,100 +0,0 @@
-import ky from 'ky'
-import { pEvent } from 'p-event'
-import pLimit from 'p-limit'
-
-import { fromWebReadableStream, ProgressStream } from './streams.js'
-
-/**
- * @typedef {object} DownloadResponse
- * @property {import('stream').Readable} body Node ReadableStream of the response body
- * @property {string | null} mimeType Content mime-type (from http content-type header)
- * @property {number | null} contentLength Content length in bytes (from http content-length header)
- */
-
-/**
- * A wrapper for fetch that limits the number of concurrent downloads.
- */
-export class FetchQueue {
-  /** @type {import('p-limit').LimitFunction} */
-  #limit
-  /** @param {number} concurrency */
-  constructor(concurrency) {
-    this.#limit = pLimit(concurrency)
-  }
-
-  get activeCount() {
-    return this.#limit.activeCount
-  }
-
-  /**
-   * Fetch a URL, limiting the number of concurrent downloads. Resolves with a
-   * `DownloadResponse`, which is a parsed from the Fetch `Response` objects,
-   * with `body` as a Node readable stream, and the MIME type and content length
-   * of the response.
-   *
-   * NB: The response body stream must be consumed to the end, otherwise the
-   * queue will never be emptied.
-   *
-   * @param {string} url
-   * @param {{ onprogress?: import('./streams.js').ProgressCallback }} opts
-   * @returns {Promise<DownloadResponse>}
-   */
-  fetch(url, { onprogress } = {}) {
-    // This is wrapped like this so that pLimit limits concurrent `fetchStream`
-    // calls, which only resolve when the body is completely downloaded, but
-    // this method will return a response as soon as it is available. NB: If the
-    // body of a response is never "consumed" (e.g. by reading it to the end),
-    // the fetchStream function will never resolve, and the limit will never be
-    // released.
-    return new Promise((resolveResponse, rejectResponse) => {
-      this.#limit(fetchStream, {
-        url,
-        onresponse: resolveResponse,
-        onerror: rejectResponse,
-        onprogress,
-      })
-    })
-  }
-}
-
-/**
- * This will resolve when the download is complete, regardless of success or
- * failure, but a readable stream is available before download via the
- * onReadStream param. This strange function signature is used for limiting the
- * number of simultaneous downloads, but still being able to expose the Response
- * as soon as it is available. This is implmented this way to avoid creating
- * unnecessary closures, which is important here because we can have thousands
- * of tile requests.
- *
- * @param {object} opts
- * @param {string} opts.url
- * @param {(response: DownloadResponse) => void} opts.onresponse
- * @param {(err: Error) => void} opts.onerror
- * @param {import('./streams.js').ProgressCallback} [opts.onprogress]
- * @returns {Promise<void>}
- */
-async function fetchStream({ url, onresponse, onerror, onprogress }) {
-  try {
-    const response = await ky(url, { retry: 3 })
-    if (!response.body) {
-      throw new Error('No body in response')
-    }
-    const body = fromWebReadableStream(response.body)
-    const contentType = response.headers.get('content-type')
-    const mimeType =
-      typeof contentType === 'string' ? contentType.split(';')[0] : null
-    const contentLengthHeader = response.headers.get('content-length')
-    const contentLength =
-      contentLengthHeader === null ? null : parseInt(contentLengthHeader, 10)
-    onresponse({
-      body: onprogress ? body.pipe(new ProgressStream({ onprogress })) : body,
-      mimeType,
-      contentLength,
-    })
-    // Wait for the read stream to end before resolving this function, so that
-    // we limit concurrent downloads
-    await pEvent(body, 'end')
-  } catch (err) {
-    onerror(err instanceof Error ? err : new Error('Unknown error'))
-  }
-}

package/lib/utils/file-formats.js

@@ -1,85 +0,0 @@
-import BufferPeerStream from 'buffer-peek-stream'
-
-import { hasOwn } from './misc.js'
-
-const peek = BufferPeerStream.promise
-
-const MAGIC_BYTES = /** @type {const} */ ({
-  png: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a],
-  jpg: [0xff, 0xd8, 0xff],
-  // eslint-disable-next-line no-sparse-arrays
-  webp: [0x52, 0x49, 0x46, 0x46, , , , , 0x57, 0x45, 0x42, 0x50],
-  // Include the compression-type byte, which is always 0x08 (DEFLATE) for gzip
-  gz: [0x1f, 0x8b, 0x08],
-})
-
-const MIME_TYPES = /** @type {const} */ ({
-  'image/png': 'png',
-  'image/jpeg': 'jpg',
-  'image/webp': 'webp',
-})
-
-/** @type {Map<number, keyof typeof MAGIC_BYTES>} */
-const magicByteMap = new Map()
-for (const [ext, bytes] of Object.entries(MAGIC_BYTES)) {
-  magicByteMap.set(
-    bytes[0],
-    // @ts-ignore
-    ext,
-  )
-}
-/**
- * For a given buffer, determine the tile format based on the magic bytes.
- * Will throw for unknown file types.
- * Smaller and faster version of magic-bytes.js due to the limited use case.
- *
- * @param {Buffer | Uint8Array} buf
- * @returns {import("../writer.js").TileFormat}
- */
-export function getTileFormatFromBuffer(buf) {
-  const ext = magicByteMap.get(buf[0])
-  if (!ext) {
-    throw new Error('Unknown file type')
-  }
-  const sig = MAGIC_BYTES[ext]
-  for (let i = 1; i < sig.length; i++) {
-    if (typeof sig[i] !== 'undefined' && sig[i] !== buf[i]) {
-      throw new Error('Unknown file type')
-    }
-  }
-  if (ext === 'gz') {
-    // Gzipped tiles are always MVT
-    return 'mvt'
-  }
-  return ext
-}
-
-/**
- * Determine the tile format from either a readable stream, buffer or Uint8Array
- * from the magic bytes at the start of the file. Used if data is served without
- * a content-type header.
- *
- * @param {import('stream').Readable} tileData
- * @returns {Promise<[import("../writer.js").TileFormat, import('stream').Readable]>}
- */
-export async function getTileFormatFromStream(tileData) {
-  // NB: The buffer-peek-stream library uses the peeked bytes as the high
-  // water mark for the transform stream, so we set this to the default high
-  // water mark of 16KB
-  const [peekedData, outputStream] = await peek(tileData, 16 * 1024)
-  tileData = outputStream
-  const format = getTileFormatFromBuffer(peekedData)
-  return [format, outputStream]
-}
-
-/**
- * Get the tile format from a MIME type. Throws for unsupported types.
- *
- * @param {string} mimeType
- * @returns {import("../writer.js").TileFormat}
- */
-export function getFormatFromMimeType(mimeType) {
-  if (mimeType.startsWith('application/')) return 'mvt'
-  if (hasOwn(MIME_TYPES, mimeType)) return MIME_TYPES[mimeType]
-  throw new Error('Unsupported MIME type ' + mimeType)
-}

package/lib/utils/geo.js

@@ -1,87 +0,0 @@
-// Adapted from https://github.com/mapbox/tilebelt
-
-const r2d = 180 / Math.PI
-
-/** Spherical Mercator max bounds, rounded to 6 decimal places */
-export const MAX_BOUNDS = /** @type {BBox} */ ([
-  -180, -85.051129, 180, 85.051129,
-])
-
-/**
- * @typedef {[number, number, number, number]} BBox
- */
-
-/**
- * Return the bounding box for the given tile.
- *
- * @param {{ x: number, y: number, z: number }} tile
- * @returns {BBox} Bounding Box [w, s, e, n]
- */
-export function tileToBBox({ x, y, z }) {
-  const e = tile2lon({ x: x + 1, z })
-  const w = tile2lon({ x, z })
-  const s = tile2lat({ y: y + 1, z })
-  const n = tile2lat({ y, z })
-  return [w, s, e, n]
-}
-
-/**
- * @param {{ x: number, y: number, z: number }} tile
- */
-export function getQuadkey({ x, y, z }) {
-  let quadkey = ''
-  let mask
-  for (let i = z; i > 0; i--) {
-    mask = 1 << (i - 1)
-    quadkey += (x & mask ? 1 : 0) + (y & mask ? 2 : 0)
-  }
-  return quadkey
-}
-
-/**
- * From an array of tile URL templates, get the URL for the given tile.
- *
- * @param {string[]} urls
- * @param {{ x: number, y: number, z: number, scheme?: 'xyz' | 'tms' }} opts
- */
-export function getTileUrl(urls, { x, y, z, scheme = 'xyz' }) {
-  const bboxEspg3857 = tileToBBox({ x, y: Math.pow(2, z) - y - 1, z })
-  const quadkey = getQuadkey({ x, y, z })
-
-  return urls[(x + y) % urls.length]
-    .replace('{prefix}', (x % 16).toString(16) + (y % 16).toString(16))
-    .replace(/{z}/g, String(z))
-    .replace(/{x}/g, String(x))
-    .replace(/{y}/g, String(scheme === 'tms' ? Math.pow(2, z) - y - 1 : y))
-    .replace('{quadkey}', quadkey)
-    .replace('{bbox-epsg-3857}', bboxEspg3857.join(','))
-}
-
-/**
- * Returns a bbox that is the smallest bounding box that contains all the input bboxes.
- *
- * @param {[BBox, ...BBox[]]} bboxes
- * @returns {BBox} Bounding Box [w, s, e, n]
- */
-export function unionBBox(bboxes) {
-  let [w, s, e, n] = bboxes[0]
-  for (let i = 1; i < bboxes.length; i++) {
-    const [w1, s1, e1, n1] = bboxes[i]
-    w = Math.min(w, w1)
-    s = Math.min(s, s1)
-    e = Math.max(e, e1)
-    n = Math.max(n, n1)
-  }
-  return [w, s, e, n]
-}
-
-/** @param {{ x: number, z: number }} opts */
-function tile2lon({ x, z }) {
-  return (x / Math.pow(2, z)) * 360 - 180
-}
-
-/** @param {{ y: number, z: number }} opts */
-function tile2lat({ y, z }) {
-  const n = Math.PI - (2 * Math.PI * y) / Math.pow(2, z)
-  return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)))
-}