styled-map-package 2.0.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}

@@ -5,5 +5,6 @@ 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/{reader-watch.d.ts → lib/reader-watch.d.ts}

@@ -5,7 +5,7 @@ export default class ReaderWatch implements Pick<Reader, keyof Reader> {
      */
     constructor(filepath: string);
     opened(): Promise<void>;
-    getStyle(baseUrl?: string | null | undefined): Promise<import("./types.js").SMPStyle>;
+    getStyle(baseUrl?: string | null): Promise<import("./types.js").SMPStyle>;
     getResource(path: string): Promise<Resource>;
     close(): Promise<void>;
     #private;

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,17 +1,11 @@
 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 PluginOptionsFilepath = {
-    /**
-     * Path to styled map package (`.smp`) file
-     */
     /**
      * Path to styled map package (`.smp`) file
      */
     filepath: string;
 };
 export type PluginOptionsReader = {
-    /**
-     * SMP Reader interface (also supports ReaderWatch)
-     */
     /**
      * SMP Reader interface (also supports ReaderWatch)
      */

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/{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

@@ -8,3 +8,4 @@ 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/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": "2.0.0",
+  "version": "2.2.0",
   "description": "",
   "exports": {
     ".": {
@@ -34,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",
@@ -61,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,