tileserver-gl-light 4.1.2 → 4.2.1

package/src/main.js

@@ -4,73 +4,52 @@
 
 import fs from 'node:fs';
 import path from 'path';
-import {fileURLToPath} from 'url';
+import { fileURLToPath } from 'url';
 import request from 'request';
-import {server} from './server.js';
+import { server } from './server.js';
 
 import MBTiles from '@mapbox/mbtiles';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const packageJson = JSON.parse(fs.readFileSync(__dirname + '/../package.json', 'utf8'));
+const packageJson = JSON.parse(
+  fs.readFileSync(__dirname + '/../package.json', 'utf8'),
+);
 
 const args = process.argv;
 if (args.length >= 3 && args[2][0] !== '-') {
   args.splice(2, 0, '--mbtiles');
 }
 
-import {program} from 'commander';
+import { program } from 'commander';
 program
   .description('tileserver-gl startup options')
   .usage('tileserver-gl [mbtiles] [options]')
   .option(
     '--mbtiles <file>',
     'MBTiles file (uses demo configuration);\n' +
-    '\t                  ignored if the configuration file is also specified'
+      '\t                  ignored if the configuration file is also specified',
   )
   .option(
     '-c, --config <file>',
     'Configuration file [config.json]',
-    'config.json'
-  )
-  .option(
-    '-b, --bind <address>',
-    'Bind address'
-  )
-  .option(
-    '-p, --port <port>',
-    'Port [8080]',
-    8080,
-    parseInt
-  )
-  .option(
-    '-C|--no-cors',
-    'Disable Cross-origin resource sharing headers'
+    'config.json',
   )
+  .option('-b, --bind <address>', 'Bind address')
+  .option('-p, --port <port>', 'Port [8080]', 8080, parseInt)
+  .option('-C|--no-cors', 'Disable Cross-origin resource sharing headers')
   .option(
     '-u|--public_url <url>',
-    'Enable exposing the server on subpaths, not necessarily the root of the domain'
-  )
-  .option(
-    '-V, --verbose',
-    'More verbose output'
-  )
-  .option(
-    '-s, --silent',
-    'Less verbose output'
-  )
-  .option(
-    '-l|--log_file <file>',
-    'output log file (defaults to standard out)'
+    'Enable exposing the server on subpaths, not necessarily the root of the domain',
   )
+  .option('-V, --verbose', 'More verbose output')
+  .option('-s, --silent', 'Less verbose output')
+  .option('-l|--log_file <file>', 'output log file (defaults to standard out)')
   .option(
     '-f|--log_format <format>',
-    'define the log format:  https://github.com/expressjs/morgan#morganformat-options'
-  )
-  .version(
-    packageJson.version,
-    '-v, --version'
+    'define the log format:  https://github.com/expressjs/morgan#morganformat-options',
   )
+  .version(packageJson.version, '-v, --version');
 program.parse(process.argv);
 const opts = program.opts();
 
@@ -91,14 +70,16 @@ const startServer = (configPath, config) => {
     silent: opts.silent,
     logFile: opts.log_file,
     logFormat: opts.log_format,
-    publicUrl: publicUrl
+    publicUrl: publicUrl,
   });
 };
 
 const startWithMBTiles = (mbtilesFile) => {
   console.log(`[INFO] Automatically creating config file for ${mbtilesFile}`);
   console.log(`[INFO] Only a basic preview style will be used.`);
-  console.log(`[INFO] See documentation to learn how to create config.json file.`);
+  console.log(
+    `[INFO] See documentation to learn how to create config.json file.`,
+  );
 
   mbtilesFile = path.resolve(process.cwd(), mbtilesFile);
 
@@ -110,60 +91,70 @@ const startWithMBTiles = (mbtilesFile) => {
   const instance = new MBTiles(mbtilesFile + '?mode=ro', (err) => {
     if (err) {
       console.log('ERROR: Unable to open MBTiles.');
-      console.log(`       Make sure ${path.basename(mbtilesFile)} is valid MBTiles.`);
+      console.log(`Make sure ${path.basename(mbtilesFile)} is valid MBTiles.`);
       process.exit(1);
     }
 
     instance.getInfo((err, info) => {
       if (err || !info) {
         console.log('ERROR: Metadata missing in the MBTiles.');
-        console.log(`       Make sure ${path.basename(mbtilesFile)} is valid MBTiles.`);
+        console.log(
+          `Make sure ${path.basename(mbtilesFile)} is valid MBTiles.`,
+        );
         process.exit(1);
       }
       const bounds = info.bounds;
 
-      const styleDir = path.resolve(__dirname, '../node_modules/tileserver-gl-styles/');
+      const styleDir = path.resolve(
+        __dirname,
+        '../node_modules/tileserver-gl-styles/',
+      );
 
       const config = {
-        'options': {
-          'paths': {
-            'root': styleDir,
-            'fonts': 'fonts',
-            'styles': 'styles',
-            'mbtiles': path.dirname(mbtilesFile)
-          }
+        options: {
+          paths: {
+            root: styleDir,
+            fonts: 'fonts',
+            styles: 'styles',
+            mbtiles: path.dirname(mbtilesFile),
+          },
         },
-        'styles': {},
-        'data': {}
+        styles: {},
+        data: {},
       };
 
-      if (info.format === 'pbf' &&
-        info.name.toLowerCase().indexOf('openmaptiles') > -1) {
+      if (
+        info.format === 'pbf' &&
+        info.name.toLowerCase().indexOf('openmaptiles') > -1
+      ) {
         config['data'][`v3`] = {
-          'mbtiles': path.basename(mbtilesFile)
+          mbtiles: path.basename(mbtilesFile),
         };
 
-
         const styles = fs.readdirSync(path.resolve(styleDir, 'styles'));
         for (const styleName of styles) {
           const styleFileRel = styleName + '/style.json';
           const styleFile = path.resolve(styleDir, 'styles', styleFileRel);
           if (fs.existsSync(styleFile)) {
             config['styles'][styleName] = {
-              'style': styleFileRel,
-              'tilejson': {
-                'bounds': bounds
-              }
+              style: styleFileRel,
+              tilejson: {
+                bounds: bounds,
+              },
             };
           }
         }
       } else {
-        console.log(`WARN: MBTiles not in "openmaptiles" format. Serving raw data only...`);
-        config['data'][(info.id || 'mbtiles')
+        console.log(
+          `WARN: MBTiles not in "openmaptiles" format. Serving raw data only...`,
+        );
+        config['data'][
+          (info.id || 'mbtiles')
             .replace(/\//g, '_')
             .replace(/:/g, '_')
-            .replace(/\?/g, '_')] = {
-          'mbtiles': path.basename(mbtilesFile)
+            .replace(/\?/g, '_')
+        ] = {
+          mbtiles: path.basename(mbtilesFile),
         };
       }
 
@@ -197,7 +188,8 @@ fs.stat(path.resolve(opts.config), (err, stats) => {
         console.log(`No MBTiles specified, using ${mbtiles}`);
         return startWithMBTiles(mbtiles);
       } else {
-        const url = 'https://github.com/maptiler/tileserver-gl/releases/download/v1.3.0/zurich_switzerland.mbtiles';
+        const url =
+          'https://github.com/maptiler/tileserver-gl/releases/download/v1.3.0/zurich_switzerland.mbtiles';
         const filename = 'zurich_switzerland.mbtiles';
         const stream = fs.createWriteStream(filename);
         console.log(`No MBTiles found`);

package/src/serve_data.js

@@ -10,97 +10,111 @@ import MBTiles from '@mapbox/mbtiles';
 import Pbf from 'pbf';
 import VectorTile from '@mapbox/vector-tile';
 
-import {getTileUrls, fixTileJSONCenter} from './utils.js';
+import { getTileUrls, fixTileJSONCenter } from './utils.js';
 
 export const serve_data = {
   init: (options, repo) => {
     const app = express().disable('x-powered-by');
 
-    app.get('/:id/:z(\\d+)/:x(\\d+)/:y(\\d+).:format([\\w.]+)', (req, res, next) => {
-      const item = repo[req.params.id];
-      if (!item) {
-        return res.sendStatus(404);
-      }
-      const tileJSONFormat = item.tileJSON.format;
-      const z = req.params.z | 0;
-      const x = req.params.x | 0;
-      const y = req.params.y | 0;
-      let format = req.params.format;
-      if (format === options.pbfAlias) {
-        format = 'pbf';
-      }
-      if (format !== tileJSONFormat &&
-          !(format === 'geojson' && tileJSONFormat === 'pbf')) {
-        return res.status(404).send('Invalid format');
-      }
-      if (z < item.tileJSON.minzoom || 0 || x < 0 || y < 0 ||
+    app.get(
+      '/:id/:z(\\d+)/:x(\\d+)/:y(\\d+).:format([\\w.]+)',
+      (req, res, next) => {
+        const item = repo[req.params.id];
+        if (!item) {
+          return res.sendStatus(404);
+        }
+        const tileJSONFormat = item.tileJSON.format;
+        const z = req.params.z | 0;
+        const x = req.params.x | 0;
+        const y = req.params.y | 0;
+        let format = req.params.format;
+        if (format === options.pbfAlias) {
+          format = 'pbf';
+        }
+        if (
+          format !== tileJSONFormat &&
+          !(format === 'geojson' && tileJSONFormat === 'pbf')
+        ) {
+          return res.status(404).send('Invalid format');
+        }
+        if (
+          z < item.tileJSON.minzoom ||
+          0 ||
+          x < 0 ||
+          y < 0 ||
           z > item.tileJSON.maxzoom ||
-          x >= Math.pow(2, z) || y >= Math.pow(2, z)) {
-        return res.status(404).send('Out of bounds');
-      }
-      item.source.getTile(z, x, y, (err, data, headers) => {
-        let isGzipped;
-        if (err) {
-          if (/does not exist/.test(err.message)) {
-            return res.status(204).send();
-          } else {
-            return res.status(500).send(err.message);
-          }
-        } else {
-          if (data == null) {
-            return res.status(404).send('Not found');
+          x >= Math.pow(2, z) ||
+          y >= Math.pow(2, z)
+        ) {
+          return res.status(404).send('Out of bounds');
+        }
+        item.source.getTile(z, x, y, (err, data, headers) => {
+          let isGzipped;
+          if (err) {
+            if (/does not exist/.test(err.message)) {
+              return res.status(204).send();
+            } else {
+              return res
+                .status(500)
+                .header('Content-Type', 'text/plain')
+                .send(err.message);
+            }
           } else {
-            if (tileJSONFormat === 'pbf') {
-              isGzipped = data.slice(0, 2).indexOf(
-                  Buffer.from([0x1f, 0x8b])) === 0;
-              if (options.dataDecoratorFunc) {
+            if (data == null) {
+              return res.status(404).send('Not found');
+            } else {
+              if (tileJSONFormat === 'pbf') {
+                isGzipped =
+                  data.slice(0, 2).indexOf(Buffer.from([0x1f, 0x8b])) === 0;
+                if (options.dataDecoratorFunc) {
+                  if (isGzipped) {
+                    data = zlib.unzipSync(data);
+                    isGzipped = false;
+                  }
+                  data = options.dataDecoratorFunc(id, 'data', data, z, x, y);
+                }
+              }
+              if (format === 'pbf') {
+                headers['Content-Type'] = 'application/x-protobuf';
+              } else if (format === 'geojson') {
+                headers['Content-Type'] = 'application/json';
+
                 if (isGzipped) {
                   data = zlib.unzipSync(data);
                   isGzipped = false;
                 }
-                data = options.dataDecoratorFunc(id, 'data', data, z, x, y);
-              }
-            }
-            if (format === 'pbf') {
-              headers['Content-Type'] = 'application/x-protobuf';
-            } else if (format === 'geojson') {
-              headers['Content-Type'] = 'application/json';
-
-              if (isGzipped) {
-                data = zlib.unzipSync(data);
-                isGzipped = false;
-              }
 
-              const tile = new VectorTile(new Pbf(data));
-              const geojson = {
-                'type': 'FeatureCollection',
-                'features': []
-              };
-              for (const layerName in tile.layers) {
-                const layer = tile.layers[layerName];
-                for (let i = 0; i < layer.length; i++) {
-                  const feature = layer.feature(i);
-                  const featureGeoJSON = feature.toGeoJSON(x, y, z);
-                  featureGeoJSON.properties.layer = layerName;
-                  geojson.features.push(featureGeoJSON);
+                const tile = new VectorTile(new Pbf(data));
+                const geojson = {
+                  type: 'FeatureCollection',
+                  features: [],
+                };
+                for (const layerName in tile.layers) {
+                  const layer = tile.layers[layerName];
+                  for (let i = 0; i < layer.length; i++) {
+                    const feature = layer.feature(i);
+                    const featureGeoJSON = feature.toGeoJSON(x, y, z);
+                    featureGeoJSON.properties.layer = layerName;
+                    geojson.features.push(featureGeoJSON);
+                  }
                 }
+                data = JSON.stringify(geojson);
               }
-              data = JSON.stringify(geojson);
-            }
-            delete headers['ETag']; // do not trust the tile ETag -- regenerate
-            headers['Content-Encoding'] = 'gzip';
-            res.set(headers);
+              delete headers['ETag']; // do not trust the tile ETag -- regenerate
+              headers['Content-Encoding'] = 'gzip';
+              res.set(headers);
 
-            if (!isGzipped) {
-              data = zlib.gzipSync(data);
-              isGzipped = true;
-            }
+              if (!isGzipped) {
+                data = zlib.gzipSync(data);
+                isGzipped = true;
+              }
 
-            return res.status(200).send(data);
+              return res.status(200).send(data);
+            }
           }
-        }
-      });
-    });
+        });
+      },
+    );
 
     app.get('/:id.json', (req, res, next) => {
       const item = repo[req.params.id];
@@ -108,10 +122,16 @@ export const serve_data = {
         return res.sendStatus(404);
       }
       const info = clone(item.tileJSON);
-      info.tiles = getTileUrls(req, info.tiles,
-          `data/${req.params.id}`, info.format, item.publicUrl, {
-            'pbf': options.pbfAlias
-          });
+      info.tiles = getTileUrls(
+        req,
+        info.tiles,
+        `data/${req.params.id}`,
+        info.format,
+        item.publicUrl,
+        {
+          pbf: options.pbfAlias,
+        },
+      );
       return res.send(info);
     });
 
@@ -120,7 +140,7 @@ export const serve_data = {
   add: (options, repo, params, id, publicUrl) => {
     const mbtilesFile = path.resolve(options.paths.mbtiles, params.mbtiles);
     let tileJSON = {
-      'tiles': params.domains || options.domains
+      tiles: params.domains || options.domains,
     };
 
     const mbtilesFileStats = fs.statSync(mbtilesFile);
@@ -129,7 +149,7 @@ export const serve_data = {
     }
     let source;
     const sourceInfoPromise = new Promise((resolve, reject) => {
-      source = new MBTiles(mbtilesFile + '?mode=ro', err => {
+      source = new MBTiles(mbtilesFile + '?mode=ro', (err) => {
         if (err) {
           reject(err);
           return;
@@ -164,8 +184,8 @@ export const serve_data = {
       repo[id] = {
         tileJSON,
         publicUrl,
-        source
+        source,
       };
     });
-  }
+  },
 };

package/src/serve_font.js

@@ -4,7 +4,7 @@ import express from 'express';
 import fs from 'node:fs';
 import path from 'path';
 
-import {getFontsPbf} from './utils.js';
+import { getFontsPbf } from './utils.js';
 
 export const serve_font = (options, allowedFonts) => {
   const app = express().disable('x-powered-by');
@@ -26,8 +26,10 @@ export const serve_font = (options, allowedFonts) => {
             reject(err);
             return;
           }
-          if (stats.isDirectory() &&
-            fs.existsSync(path.join(fontPath, file, '0-255.pbf'))) {
+          if (
+            stats.isDirectory() &&
+            fs.existsSync(path.join(fontPath, file, '0-255.pbf'))
+          ) {
             existingFonts[path.basename(file)] = true;
           }
         });
@@ -40,19 +42,26 @@ export const serve_font = (options, allowedFonts) => {
     const fontstack = decodeURI(req.params.fontstack);
     const range = req.params.range;
 
-    getFontsPbf(options.serveAllFonts ? null : allowedFonts,
-        fontPath, fontstack, range, existingFonts).then((concated) => {
-      res.header('Content-type', 'application/x-protobuf');
-      res.header('Last-Modified', lastModified);
-      return res.send(concated);
-    }, (err) => res.status(400).send(err)
+    getFontsPbf(
+      options.serveAllFonts ? null : allowedFonts,
+      fontPath,
+      fontstack,
+      range,
+      existingFonts,
+    ).then(
+      (concated) => {
+        res.header('Content-type', 'application/x-protobuf');
+        res.header('Last-Modified', lastModified);
+        return res.send(concated);
+      },
+      (err) => res.status(400).header('Content-Type', 'text/plain').send(err),
     );
   });
 
   app.get('/fonts.json', (req, res, next) => {
     res.header('Content-type', 'application/json');
     return res.send(
-        Object.keys(options.serveAllFonts ? existingFonts : allowedFonts).sort()
+      Object.keys(options.serveAllFonts ? existingFonts : allowedFonts).sort(),
     );
   });
 

package/src/serve_light.js

@@ -1,10 +1,9 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 'use strict';
 
 export const serve_rendered = {
-  init: (options, repo) => {
-  },
-  add: (options, repo, params, id, publicUrl, dataResolver) => {
-  },
-  remove: (repo, id) => {
-  }
+  init: (options, repo) => {},
+  add: (options, repo, params, id, publicUrl, dataResolver) => {},
+  remove: (repo, id) => {},
 };