@mapwhit/glyph-server 1.4.1

package/Readme.md

@@ -0,0 +1,56 @@
+[![NPM version][npm-image]][npm-url]
+[![Build Status][build-image]][build-url]
+[![Dependency Status][deps-image]][deps-url]
+
+# map-glyph-server
+
+Server for glyph/font files compatible with [mapbox-gl-js], [maplibre-gl-js], [mapwhit-gl-js]
+
+## Install
+
+```sh
+$ npm install --global @mapwhit/glyph-server
+```
+
+## Environment
+
+The following environment variables are used by `@mapwhit/glyph-server`
+
+- `MAP_GLYPH_SERVER_FONT_PATH` - needs to specify the location of the fonts files
+- `MAP_GLYPH_SERVER_PORT` - local port to which `@mapwhit/glyph-server` binds to default: *3060*
+- `MAP_GLYPH_SERVER_CACHE_MAX_AGE` - if specified used as a `max-age` value of the
+  [`Cache-Control` header][cache-control] when serving font/pbf files
+  (maximum amount of seconds a resource is considered fresh)
+
+`/etc/default/map-glyph-server` can be used to set environment variables
+
+## Usage
+
+Prior to starting the server glyphs should be located in `MAP_GLYPH_SERVER_FONT_PATH` directory. This can
+be achieved using [openmaptiles/fonts] or a similar utility.
+
+In order to use the fonts edit [Style JSON][glyphs-doc] and change the endpoint for glyphs:
+
+    "glyphs": "https://fonts.example.com/fonts/{fontstack}/{range}.pbf",
+
+## License
+
+MIT © [Damian Krzeminski](https://furkot.com)
+
+[npm-image]: https://img.shields.io/npm/v/@mapwhit/glyph-server
+[npm-url]: https://npmjs.org/package/@mapwhit/glyph-server
+
+[build-url]: https://github.com/mapwhit/glyph-server/actions/workflows/check.yaml
+[build-image]: https://img.shields.io/github/actions/workflow/status/mapwhit/glyph-server/check.yaml?branch=main
+
+[deps-image]: https://img.shields.io/librariesio/release/npm/@mapwhit/glyph-server
+[deps-url]: https://libraries.io/npm/@mapwhit%2Fglyph-server
+
+
+[openmaptiles/fonts]: https://github.com/openmaptiles/fonts
+[cache-control]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
+[glyphs-doc]: https://docs.mapbox.com/mapbox-gl-js/style-spec/glyphs/
+
+[mapbox-gl-js]: https://github.com/mapbox/mapbox-gl-js
+[maplibre-gl-js]: https://github.com/maplibre/maplibre-gl-js
+[mapwhit-gl-js]: https://github.com/mapwhit/mapwhit-gl-js

package/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+require('dotenv').config({ path: '/etc/default/map-glyph-server' });
+
+const connect = require('@pirxpilot/connect');
+const router = require('./lib/map-glyph-server');
+
+const PORT = process.env.MAP_GLYPH_SERVER_PORT || 3060;
+const FONT_PATH = process.env.MAP_GLYPH_SERVER_FONT_PATH;
+
+if (!FONT_PATH) {
+  console.error('Please configure MAP_GLYPH_SERVER_FONT_PATH');
+  process.exit(1);
+}
+
+const app = connect();
+
+app.use('/fonts', router(FONT_PATH));
+
+module.exports = app;
+
+if (!module.parent) {
+  app.listen(PORT);
+  console.log('Listening on port', PORT);
+}

package/lib/find-fonts.js

@@ -0,0 +1,35 @@
+const { readdir, stat } = require('node:fs/promises');
+const { join } = require('node:path');
+
+const debug = require('debug')('map-glyph-server');
+
+module.exports = findFonts;
+
+const memo = Object.create(null);
+
+function findFonts(fontPath) {
+  let p = memo[fontPath];
+  if (!p) {
+    memo[fontPath] = p = findFontsImplementation(fontPath);
+  }
+  return p;
+}
+
+async function findFontsImplementation(fontPath) {
+  debug('Looking for fonts in:', fontPath);
+  const dirs = await readdir(fontPath, { withFileTypes: true });
+  const fonts = {};
+  await Promise.all(
+    dirs.filter(d => d.isDirectory() || d.isSymbolicLink()).map(checkDir)
+  );
+  return fonts;
+
+  async function checkDir({ name, parentPath }) {
+    const filename = join(parentPath, name, '0-255.pbf');
+    const st = await stat(filename).catch(() => null);
+    if (st?.isFile()) {
+      debug('Found font', name);
+      fonts[name] = true;
+    }
+  }
+}

package/lib/get-fonts-pbf.js

@@ -0,0 +1,51 @@
+const { join } = require('node:path');
+const { readFile } = require('node:fs/promises');
+
+const { combine } = require('@furkot/glyph-pbf-composite');
+
+const debug = require('debug')('map-glyph-server');
+
+module.exports = getFontsPbf;
+
+async function getFontPbf(fontPath, choices, range) {
+  debug('Looking for', choices[0], range);
+  const checked = Object.create(null);
+
+  for (const name of choices) {
+    const pbf = await loadFont(name);
+    if (pbf) {
+      return pbf;
+    }
+  }
+
+  async function loadFont(name) {
+    const filename = join(fontPath, name, `${range}.pbf`);
+
+    if (checked[filename]) {
+      return;
+    }
+    try {
+      const data = await readFile(filename);
+      debug('Font found:', name);
+      return data;
+    } catch {
+      debug('Font not found:', name);
+      checked[filename] = true;
+    }
+  }
+}
+
+async function getFontsPbf(fontPath, fonts, range, fallbacks) {
+  let pbfs = await Promise.all(
+    fonts.map(font => getFontPbf(fontPath, [font, ...fallbacks], range))
+  );
+  // only non-empty fonts are OK
+  pbfs = pbfs.filter(p => p?.length);
+  debug(pbfs);
+  if (pbfs.length < fonts.length) {
+    console.log('here');
+    throw 404;
+  }
+  const result = pbfs.length > 1 ? combine(pbfs) : pbfs[0];
+  return result;
+}

package/lib/map-glyph-server.js

@@ -0,0 +1,66 @@
+const Router = require('@pirxpilot/router');
+
+const findFonts = require('./find-fonts');
+const getFontsPbf = require('./get-fonts-pbf');
+const entityTag = require('etag');
+const fresh = require('fresh');
+
+const CACHE_MAX_AGE = process.env.MAP_GLYPH_SERVER_CACHE_MAX_AGE;
+
+async function find(req, res, next) {
+  const fonts = await findFonts(req.fontPath);
+  req.fonts = fonts;
+  req.fontList = Object.keys(fonts);
+  next();
+}
+
+function sendFontsList(req, res) {
+  const fontList = req.fontList.sort();
+  const payload = JSON.stringify(fontList);
+  res.setHeader('Content-Type', 'application/json');
+  res.setHeader('Content-Length', Buffer.byteLength(payload));
+  return res.end(payload);
+}
+
+async function sendFontsPbf(req, res) {
+  const { fontPath } = req;
+  const { fontstack, range } = req.params;
+
+  const fontstacks = decodeURI(fontstack).split(',');
+
+  const pbf = await getFontsPbf(fontPath, fontstacks, range, req.fontList);
+  if (pbf.length === 0) {
+    return res.writeHeader(204).end();
+  }
+  if (CACHE_MAX_AGE) {
+    const etag = entityTag(pbf);
+    res.setHeader('Cache-Control', `public, max-age=${CACHE_MAX_AGE}`);
+    res.setHeader('ETag', etag);
+    if (fresh(req.headers, { etag })) {
+      return res.writeHeader(304).end();
+    }
+  }
+  res.setHeader('Content-Type', 'application/x-protobuf');
+  res.setHeader('Content-Length', pbf.length);
+  res.end(pbf);
+}
+
+module.exports = function (fontPath) {
+  const router = new Router({
+    strict: true,
+    caseSensitive: true
+  });
+
+  router.use(function (req, res, next) {
+    req.fontPath = fontPath;
+    next();
+  });
+
+  router.get(
+    /^\/(?<fontstack>[^/]+)\/(?<range>\d+-\d+)\.pbf$/,
+    find,
+    sendFontsPbf
+  );
+  router.get('/.json', find, sendFontsList);
+  return router;
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@mapwhit/glyph-server",
+  "version": "1.4.1",
+  "description": "Server for glyph/font files compatible with mapbox-gl-js",
+  "author": {
+    "name": "Damian Krzeminski",
+    "email": "pirxpilot@furkot.com",
+    "url": "https://furkot.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mapwhit/glyph-server.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "map-glyph-server",
+    "map",
+    "mapbox",
+    "font",
+    "vector tiles"
+  ],
+  "bin": {
+    "map-glyph-server": "index.js"
+  },
+  "dependencies": {
+    "@furkot/glyph-pbf-composite": "~1",
+    "@pirxpilot/connect": "~4",
+    "@pirxpilot/router": "~1",
+    "debug": "~4",
+    "dotenv": "~16",
+    "etag": "~1",
+    "fresh": "~2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "supertest-fetch": "~2"
+  },
+  "scripts": {
+    "test": "make check"
+  },
+  "files": [
+    "index.js",
+    "lib"
+  ]
+}