styled-map-package 1.1.0 → 2.2.0

package/bin/smp-download.js

@@ -1,32 +1,125 @@
 #!/usr/bin/env node
-import { Command, InvalidArgumentError } from 'commander'
+import { Command, InvalidArgumentError } from '@commander-js/extra-typings'
+import { input, number } from '@inquirer/prompts'
 import fs from 'fs'
 import { pipeline } from 'stream/promises'
 
 import download from '../lib/download.js'
 import { ttyReporter } from '../lib/reporters.js'
+import { isMapboxURL, API_URL as MAPBOX_API_URL } from '../lib/utils/mapbox.js'
 
 const program = new Command()
 
 program
   .description('Download a map style for offline usage')
-  .option('-o, --output [file]', 'output file (if omitted, writes to stdout)')
-  .requiredOption(
+  .option('-o, --output <file>', 'output file (if omitted, writes to stdout)')
+  .option(
     '-b, --bbox <west,south,east,north>',
     'bounding box of area to download e.g. 11,47,12,47.5',
     parseBbox,
   )
-  .requiredOption(
-    '-z, --zoom <number>',
-    'max zoom level to download',
-    parseZoom,
-  )
+  .option('-z, --zoom <number>', 'max zoom level to download', parseZoom)
   .option(
     '-t, --token <token>',
     'Mapbox access token (necessary for Mapbox styles)',
   )
-  .argument('<styleUrl>', 'URL to style to download', parseUrl)
+  .argument('[styleUrl]', 'URL to style to download', parseUrl)
   .action(async (styleUrl, { bbox, zoom, output, token }) => {
+    const promptOutput =
+      !output &&
+      process.stdout.isTTY &&
+      (!styleUrl || !bbox || zoom === undefined)
+
+    if (!styleUrl) {
+      styleUrl = await input({
+        message: 'Style URL to download',
+        required: true,
+        validate: (value) => {
+          try {
+            new URL(value)
+            return true
+          } catch {
+            return 'Please enter a valid URL.'
+          }
+        },
+      })
+    }
+
+    if (!bbox) {
+      const west = await number({
+        message: 'Bounding box west',
+        required: true,
+        step: 'any',
+        min: -180,
+        max: 180,
+      })
+      const south = await number({
+        message: 'Bounding box south',
+        required: true,
+        step: 'any',
+        min: -90,
+        max: 90,
+      })
+      const east = await number({
+        message: 'Bounding box east',
+        required: true,
+        step: 'any',
+        min: -180,
+        max: 180,
+      })
+      const north = await number({
+        message: 'Bounding box north',
+        required: true,
+        step: 'any',
+        min: -90,
+        max: 90,
+      })
+      if (
+        west === undefined ||
+        south === undefined ||
+        east === undefined ||
+        north === undefined
+      ) {
+        throw new InvalidArgumentError('Bounding box values are required.')
+      }
+      bbox = [west, south, east, north]
+    }
+
+    if (zoom === undefined) {
+      zoom = await number({
+        message: 'Max zoom level to download',
+        required: true,
+        min: 0,
+        max: 22,
+      })
+      if (zoom === undefined) {
+        throw new InvalidArgumentError('Zoom level is required.')
+      }
+    }
+
+    if (
+      (isMapboxURL(styleUrl) || styleUrl.startsWith(MAPBOX_API_URL)) &&
+      !token
+    ) {
+      token = await input({
+        message: 'Mapbox access token',
+        required: true,
+      })
+    }
+
+    if (promptOutput) {
+      output = await input({
+        message: 'Output filename (.smp extension will be added)',
+        required: true,
+        transformer: (value) =>
+          value.endsWith('.smp') ? value : `${value}.smp`,
+      })
+    }
+
+    if (output && !output.endsWith('.smp')) {
+      output += '.smp'
+    }
+
     const reporter = ttyReporter()
     const readStream = download({
       bbox,
@@ -63,7 +156,7 @@ function parseBbox(bbox) {
   if (bounds.some(isNaN)) {
     throw new InvalidArgumentError('Bounding box values must be numbers.')
   }
-  return bounds
+  return /** @type {[number, number, number, number]} */ (bounds)
 }
 
 /** @param {string} url */

package/bin/smp-mbtiles.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { Command } from 'commander'
+import { pipeline } from 'stream/promises'
+
+import fromMBTiles from '../lib/from-mbtiles.js'
+
+const program = new Command()
+
+program
+  .description('Convert a MBTiles file to a styled map package file')
+  .option('-o, --output <file>', 'output smp file')
+  .argument('<mbtiles>', 'MBTiles file to convert')
+  .action(async (mbtilesPath, { output }) => {
+    if (output) {
+      await fromMBTiles(mbtilesPath, output)
+    } else {
+      await pipeline(fromMBTiles(mbtilesPath), process.stdout)
+    }
+  })
+
+program.parseAsync(process.argv)

package/bin/smp.js

@@ -7,5 +7,6 @@ program
   .name('smp')
   .command('download', 'Download a map style to a styled map package file')
   .command('view', 'Preview a styled map package in a web browser')
+  .command('mbtiles', 'Convert a MBTiles file to a styled map package file')
 
 program.parse(process.argv)

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

@@ -0,0 +1,13 @@
+/**
+ * @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/{index.d.ts → lib/index.d.ts}

@@ -1,8 +1,10 @@
 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

@@ -0,0 +1,13 @@
+/** @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/{reader.d.ts → lib/reader.d.ts}

@@ -27,7 +27,7 @@ export default class Reader {
      * @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>}
      */
-    getStyle(baseUrl?: string | null | undefined): Promise<import("./types.js").SMPStyle>;
+    getStyle(baseUrl?: string | null): Promise<import("./types.js").SMPStyle>;
     /**
      * Get a resource from the styled map package. The path should be relative to
      * the root of the package.

package/dist/{server.d.ts → lib/server.d.ts}

@@ -1,12 +1,15 @@
 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 PluginOptions = {
-    lazy?: boolean | undefined;
-    prefix?: string | undefined;
+export type PluginOptionsFilepath = {
     /**
      * Path to styled map package (`.smp`) file
      */
+    filepath: string;
+};
+export type PluginOptionsReader = {
     /**
-     * Path to styled map package (`.smp`) file
+     * SMP Reader interface (also supports ReaderWatch)
      */
-    filepath: string;
+    reader: Pick<Reader, keyof Reader>;
 };
+export type PluginOptions = PluginOptionsFilepath | PluginOptionsReader;
+import Reader from './reader.js';

package/dist/{style-downloader.d.ts → lib/style-downloader.d.ts}

@@ -24,7 +24,7 @@ export default class StyleDownloader {
     constructor(style: string | StyleSpecification, { concurrency, mapboxAccessToken }?: {
         concurrency?: number | undefined;
         mapboxAccessToken?: string | undefined;
-    } | undefined);
+    });
     /**
      * Number of active downloads.
      */

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

@@ -0,0 +1,16 @@
+/**
+ * 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: unknown): error is Error & {
+    code: "ENOENT" | "EPERM";
+};
+export class ENOENT extends Error {
+    /** @param {string} path */
+    constructor(path: string);
+    code: string;
+    path: string;
+}

package/dist/{utils → lib/utils}/fetch.d.ts

@@ -30,23 +30,14 @@ export class FetchQueue {
     #private;
 }
 export type DownloadResponse = {
-    /**
-     * Node ReadableStream of the response body
-     */
     /**
      * Node ReadableStream of the response body
      */
     body: import("stream").Readable;
-    /**
-     * Content mime-type (from http content-type header)
-     */
     /**
      * Content mime-type (from http content-type header)
      */
     mimeType: string | null;
-    /**
-     * Content length in bytes (from http content-length header)
-     */
     /**
      * Content length in bytes (from http content-length header)
      */

package/dist/{utils → lib/utils}/mapbox.d.ts

@@ -4,34 +4,35 @@ export function isMapboxURL(url: string): boolean;
  * @param {string} url
  * @param {string} [accessToken]
  */
-export function normalizeStyleURL(url: string, accessToken?: string | undefined): string;
+export function normalizeStyleURL(url: string, accessToken?: string): string;
 /**
  * @param {string} url
  * @param {string} [accessToken]
  */
-export function normalizeGlyphsURL(url: string, accessToken?: string | undefined): string;
+export function normalizeGlyphsURL(url: string, accessToken?: string): string;
 /**
  * @param {string} url
  * @param {string} [accessToken]
  */
-export function normalizeSourceURL(url: string, accessToken?: string | undefined): string;
+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 | undefined): string;
+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 | undefined, { devicePixelRatio, supportsWebp }?: {
+export function normalizeTileURL(tileURL: any, sourceURL: string, tileSize?: 256 | 512, { devicePixelRatio, supportsWebp }?: {
     devicePixelRatio?: number;
     supportsWebp?: boolean;
-} | undefined): any;
+}): any;
+export const API_URL: "https://api.mapbox.com";
 export type URLObject = {
     protocol: string;
     authority: string;

package/dist/{utils → lib/utils}/streams.d.ts

@@ -28,7 +28,7 @@ export function fromWebReadableStream(readableStream: ReadableStream, options?:
     encoding?: string;
     objectMode?: boolean;
     signal?: AbortSignal;
-} | undefined): import("stream").Readable;
+}): import("stream").Readable;
 /**
  * @param {unknown} obj
  * @returns {obj is ReadableStream}
@@ -46,7 +46,7 @@ export class ProgressStream extends Transform {
     /**
      * @param {ProgressStreamOptions} [opts]
      */
-    constructor({ onprogress, ...opts }?: ProgressStreamOptions | undefined);
+    constructor({ onprogress, ...opts }?: ProgressStreamOptions);
     /** Total bytes that have passed through this stream */
     get byteLength(): number;
     /**

package/dist/{writer.d.ts → lib/writer.d.ts}

@@ -45,7 +45,7 @@ export default class Writer extends EventEmitter<[never]> {
     /**
      * @returns {import('stream').Readable} Readable stream of the styled map package
      */
-    get outputStream(): Readable;
+    get outputStream(): import("stream").Readable;
     /**
      * Add a tile to the styled map package
      *
@@ -127,4 +127,3 @@ export type GlyphInfo = {
     range: GlyphRange;
 };
 import { EventEmitter } from 'events';
-import { Readable } from 'stream';

package/lib/from-mbtiles.js

@@ -0,0 +1,83 @@
+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

@@ -2,8 +2,10 @@
 /** @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

@@ -0,0 +1,133 @@
+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/server.js

@@ -1,17 +1,23 @@
 import createError from 'http-errors'
 
 import Reader from './reader.js'
+import { isFileNotThereError } from './utils/errors.js'
 import { noop } from './utils/misc.js'
 
 /** @import { FastifyPluginCallback, FastifyReply } from 'fastify' */
 /** @import { Resource } from './reader.js' */
 
 /**
- * @typedef {object} PluginOptions
- * @property {boolean} [lazy=false]
- * @property {string} [prefix]
+ * @typedef {object} PluginOptionsFilepath
  * @property {string} filepath Path to styled map package (`.smp`) file
  */
+/**
+ * @typedef {object} PluginOptionsReader
+ * @property {Pick<Reader, keyof Reader>} reader SMP Reader interface (also supports ReaderWatch)
+ */
+/**
+ * @typedef {PluginOptionsFilepath | PluginOptionsReader} PluginOptions
+ */
 
 /**
  * @param {FastifyReply} reply
@@ -29,60 +35,28 @@ function sendResource(reply, resource) {
 }
 
 /**
- * Fastify plugin for serving a styled map package. User `lazy: true` to defer
- * opening the file until the first request.
+ * Fastify plugin for serving a styled map package.
+ *
+ * If you provide a `Reader` (or `ReaderWatch`) instance via the `reader` opt,
+ * you must manually close the instance yourself.
  *
  * @type {FastifyPluginCallback<PluginOptions>}
  */
-export default function (fastify, { lazy = false, filepath }, done) {
-  /** @type {Reader | undefined} */
-  let _reader
-  /** @type {Promise<Reader> | undefined} */
-  let _readerOpeningPromise
-
-  async function getReader() {
-    // 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 (_reader) return _reader
-    if (_readerOpeningPromise) return _readerOpeningPromise
-    const maybeReader = new Reader(filepath)
-    _readerOpeningPromise = maybeReader
-      .opened()
-      .then(() => {
-        _reader = maybeReader
-        return _reader
-      })
-      .finally(() => {
-        _readerOpeningPromise = undefined
-      })
-    return _readerOpeningPromise
-  }
+export default function (fastify, opts, done) {
+  const reader = 'reader' in opts ? opts.reader : new Reader(opts.filepath)
 
-  if (!lazy) {
-    getReader().catch(noop)
+  // Only close the reader if it was created by this plugin
+  if (!('reader' in opts)) {
+    fastify.addHook('onClose', () => reader.close().catch(noop))
   }
 
-  fastify.addHook('onClose', async () => {
-    try {
-      const reader = await getReader()
-      await reader.close()
-    } catch {
-      // ignore
-    }
-  })
-
   fastify.get('/style.json', async () => {
     try {
-      const reader = await getReader()
       const baseUrl = new URL(fastify.prefix, fastify.listeningOrigin)
-      return reader.getStyle(baseUrl.href)
+      const style = await reader.getStyle(baseUrl.href)
+      return style
     } catch (error) {
-      if (isENOENT(error)) {
+      if (isFileNotThereError(error)) {
         throw createError(404, error.message)
       }
       throw error
@@ -94,11 +68,10 @@ export default function (fastify, { lazy = false, filepath }, done) {
     const path = request.params['*']
 
     try {
-      const reader = await getReader()
       const resource = await reader.getResource(path)
       return sendResource(reply, resource)
     } catch (error) {
-      if (isENOENT(error)) {
+      if (isFileNotThereError(error)) {
         throw createError(404, error.message)
       }
       throw error
@@ -106,11 +79,3 @@ export default function (fastify, { lazy = false, filepath }, done) {
   })
   done()
 }
-
-/**
- * @param {unknown} error
- * @returns {error is Error & { code: 'ENOENT' }}
- */
-function isENOENT(error) {
-  return error instanceof Error && 'code' in error && error.code === 'ENOENT'
-}

package/lib/utils/errors.js

@@ -7,3 +7,18 @@ export class ENOENT extends Error {
     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/mapbox.js

@@ -1,7 +1,7 @@
 'use strict'
 // from https://github.com/mapbox/mapbox-gl-js/blob/495a695/src/util/mapbox.js
 
-const API_URL = 'https://api.mapbox.com'
+export const API_URL = 'https://api.mapbox.com'
 const HELP = 'See https://www.mapbox.com/api-documentation/#access-tokens'
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "styled-map-package",
-  "version": "1.1.0",
+  "version": "2.2.0",
   "description": "",
   "exports": {
     ".": {
@@ -11,6 +11,10 @@
       "types": "./dist/reader.d.ts",
       "import": "./lib/reader.js"
     },
+    "./reader-watch": {
+      "types": "./dist/reader-watch.d.ts",
+      "import": "./lib/reader-watch.js"
+    },
     "./writer": {
       "types": "./dist/writer.d.ts",
       "import": "./lib/writer.js"
@@ -30,6 +34,10 @@
     "./download": {
       "types": "./dist/download.d.ts",
       "import": "./lib/download.js"
+    },
+    "./from-mbtiles": {
+      "types": "./dist/from-mbtiles.d.ts",
+      "import": "./lib/from-mbtiles.js"
     }
   },
   "main": "./lib/index.js",
@@ -57,68 +65,71 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@commander-js/extra-typings": "^12.1.0",
     "@fastify/static": "^7.0.4",
+    "@inquirer/prompts": "^6.0.1",
     "@mapbox/sphericalmercator": "^1.2.0",
     "@maplibre/maplibre-gl-style-spec": "^20.3.1",
     "@placemarkio/check-geojson": "^0.1.12",
-    "@turf/bbox": "^7.1.0",
-    "@turf/helpers": "^7.1.0",
+    "@turf/bbox": "^7.2.0",
+    "@turf/helpers": "^7.2.0",
     "ansi-diff": "^1.2.0",
     "archiver": "^7.0.1",
     "buffer-peek-stream": "^1.1.0",
-    "chalk": "^5.3.0",
+    "chalk": "^5.4.1",
     "commander": "^12.1.0",
     "fastify": "^4.28.1",
     "filter-obj": "^6.1.0",
     "http-errors": "^2.0.0",
     "into-stream": "^8.0.1",
     "is-stream": "^4.0.1",
-    "ky": "^1.7.1",
+    "ky": "^1.7.5",
     "log-symbols": "^7.0.0",
     "map-obj": "^5.0.2",
+    "mbtiles-reader": "^1.0.0",
     "open": "^10.1.0",
-    "ora": "^8.1.0",
+    "ora": "^8.2.0",
     "p-event": "^6.0.1",
-    "p-limit": "^6.1.0",
+    "p-limit": "^6.2.0",
     "pretty-bytes": "^6.1.1",
-    "pretty-ms": "^9.1.0",
-    "readable-stream": "^4.5.2",
+    "pretty-ms": "^9.2.0",
+    "readable-stream": "^4.7.0",
     "temp-dir": "^3.0.0",
     "yauzl-promise": "^4.0.0",
     "yocto-queue": "^1.1.1"
   },
   "devDependencies": {
-    "@eslint/js": "^9.9.1",
+    "@eslint/js": "^9.21.0",
     "@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.2",
+    "@types/archiver": "^6.0.3",
     "@types/eslint": "^9.6.1",
     "@types/eslint__js": "^8.42.3",
-    "@types/geojson": "^7946.0.14",
+    "@types/geojson": "^7946.0.16",
     "@types/http-errors": "^2.0.4",
     "@types/mapbox__sphericalmercator": "^1.2.3",
     "@types/node": "^20.16.3",
-    "@types/readable-stream": "^4.0.15",
+    "@types/readable-stream": "^4.0.18",
     "@types/yauzl-promise": "^4.0.1",
-    "ava": "^6.1.3",
+    "ava": "^6.2.0",
     "block-stream2": "^2.1.0",
-    "eslint": "^9.9.1",
+    "eslint": "^9.21.0",
     "execa": "^9.4.0",
     "globals": "^15.9.0",
-    "husky": "^9.1.5",
+    "husky": "^9.1.7",
     "jpg-stream": "^1.1.2",
-    "lint-staged": "^15.2.10",
+    "lint-staged": "^15.4.3",
     "pixel-stream": "^1.0.3",
-    "playwright": "^1.46.1",
+    "playwright": "^1.50.1",
     "png-stream": "^1.0.5",
-    "prettier": "^3.3.3",
+    "prettier": "^3.5.2",
     "random-bytes-readable-stream": "^3.0.0",
     "rimraf": "^4.4.1",
     "tempy": "^3.1.0",
-    "type-fest": "^4.26.0",
-    "typescript": "5.5.4"
+    "type-fest": "^4.35.0",
+    "typescript": "^5.7.3"
   },
   "prettier": {
     "semi": false,

package/dist/utils/errors.d.ts

@@ -1,6 +0,0 @@
-export class ENOENT extends Error {
-    /** @param {string} path */
-    constructor(path: string);
-    code: string;
-    path: string;
-}