@expofp/offline 3.15.0 → 3.16.1

package/dist/lib/generate-offline-map-data.js

@@ -1,5 +1,7 @@
 import { Box, projectLocalToGps } from '@expofp/geometry';
 import debug from 'debug';
+import { resolveMapTheme } from './map-theme.js';
+import { createOfflineMapStyle, OFFLINE_GLYPH_FONTSTACK } from './offline-map-style.js';
 const log = debug('efp:offline:generate-offline-map-data');
 const MAPS_BASE_PATH = 'maps/';
 const MAP_STYLE_PATH = `${MAPS_BASE_PATH}style.json`;
@@ -20,23 +22,24 @@ const MAP_BOUNDS_MIN_PADDING_FRACTION = 0.05;
 const OFFLINE_PADDING_SAFETY = 1.5;
 const DEFAULT_MAP_SOURCE_BASE = 'https://build.protomaps.com';
 const DEFAULT_MAP_SOURCE_LOOKBACK_DAYS = 7;
-const PROTOMAPS_SPRITE_BASE = 'https://protomaps.github.io/basemaps-assets/sprites/v4/white';
+// Protomaps ships one sprite per palette; the icons are baked light-on-dark or
+// dark-on-light, so the sprite has to follow the theme. (The `white` set this
+// replaced was white-on-white against the light basemap.)
+const PROTOMAPS_SPRITE_BASE = 'https://protomaps.github.io/basemaps-assets/sprites/v4';
 const PROTOMAPS_FONT_BASE = 'https://protomaps.github.io/basemaps-assets/fonts';
-const GLYPH_FONTSTACK = 'Noto Sans Regular';
+const MAP_GLYPHS_STYLE_URL = './fonts/{fontstack}/{range}.pbf';
 const GLYPH_RANGES = createGlyphRanges(0, 8447);
-const ENGLISH_LABEL_FIELD = [
-    'coalesce',
-    ['get', 'name:en'],
-    ['get', 'name_en'],
-    ['get', 'name:latin'],
-    ['get', 'name'],
-];
 const tempDirExitCleanups = new Map();
 export function generateOfflineMapData(options) {
     const maplibre = {
         styleUrl: `./${MAP_STYLE_PATH}`,
         offline: true,
     };
+    // The drawing decides the palette and the drawing is frozen inside the
+    // archive, so the theme is resolved once here and baked into the style —
+    // the runtime has no basis to re-decide it offline.
+    const theme = deriveMapTheme(options.fpSvgContext);
+    log('Resolved offline basemap theme', theme);
     async function* files() {
         const bbox = derivePaddedVenueBbox(options.fpSvgContext);
         log('Extracting PMTiles for bbox', bbox.join(','));
@@ -47,10 +50,15 @@ export function generateOfflineMapData(options) {
                 targetFilePath: MAP_PMTILES_PATH,
             };
             yield {
-                text: JSON.stringify(createMapStyle(), null, 2),
+                text: JSON.stringify(createOfflineMapStyle({
+                    theme,
+                    tiles: MAP_PMTILES_STYLE_URL,
+                    sprite: `./sprites/${spriteName(theme)}`,
+                    glyphs: MAP_GLYPHS_STYLE_URL,
+                }), null, 2),
                 targetFilePath: MAP_STYLE_PATH,
             };
-            yield* getSpriteAssets();
+            yield* getSpriteAssets(theme);
             yield* getGlyphAssets();
         }
         finally {
@@ -291,22 +299,28 @@ async function runPmtiles(args, signal) {
         });
     });
 }
-function* getSpriteAssets() {
-    const targetBase = `${MAPS_BASE_PATH}sprites/protomaps-white`;
-    yield { url: new URL(`${PROTOMAPS_SPRITE_BASE}.json`), targetFilePath: `${targetBase}.json` };
-    yield { url: new URL(`${PROTOMAPS_SPRITE_BASE}.png`), targetFilePath: `${targetBase}.png` };
-    yield {
-        url: new URL(`${PROTOMAPS_SPRITE_BASE}@2x.json`),
-        targetFilePath: `${targetBase}@2x.json`,
-    };
-    yield { url: new URL(`${PROTOMAPS_SPRITE_BASE}@2x.png`), targetFilePath: `${targetBase}@2x.png` };
+function deriveMapTheme(ctx) {
+    const fpGeo = ctx.__fpGeo;
+    const fpSettings = ctx.__fpSettings;
+    return resolveMapTheme(fpGeo?.properties?.config?.style, fpSettings?.backgroundColor);
+}
+function spriteName(theme) {
+    return `protomaps-${theme}`;
+}
+function* getSpriteAssets(theme) {
+    const source = `${PROTOMAPS_SPRITE_BASE}/${theme}`;
+    const targetBase = `${MAPS_BASE_PATH}sprites/${spriteName(theme)}`;
+    yield { url: new URL(`${source}.json`), targetFilePath: `${targetBase}.json` };
+    yield { url: new URL(`${source}.png`), targetFilePath: `${targetBase}.png` };
+    yield { url: new URL(`${source}@2x.json`), targetFilePath: `${targetBase}@2x.json` };
+    yield { url: new URL(`${source}@2x.png`), targetFilePath: `${targetBase}@2x.png` };
 }
 function* getGlyphAssets() {
-    const encodedFontstack = encodeURIComponent(GLYPH_FONTSTACK);
+    const encodedFontstack = encodeURIComponent(OFFLINE_GLYPH_FONTSTACK);
     for (const range of GLYPH_RANGES) {
         yield {
             url: new URL(`${PROTOMAPS_FONT_BASE}/${encodedFontstack}/${range}.pbf`),
-            targetFilePath: `${MAPS_BASE_PATH}fonts/${GLYPH_FONTSTACK}/${range}.pbf`,
+            targetFilePath: `${MAPS_BASE_PATH}fonts/${OFFLINE_GLYPH_FONTSTACK}/${range}.pbf`,
         };
     }
 }
@@ -317,187 +331,6 @@ function createGlyphRanges(min, max) {
     }
     return ranges;
 }
-function createMapStyle() {
-    return {
-        version: 8,
-        sources: {
-            protomaps: {
-                type: 'vector',
-                attribution: '<a href="https://github.com/protomaps/basemaps">Protomaps</a> © <a href="https://openstreetmap.org">OpenStreetMap</a>',
-                url: `pmtiles://${MAP_PMTILES_STYLE_URL}`,
-            },
-        },
-        sprite: './sprites/protomaps-white',
-        glyphs: './fonts/{fontstack}/{range}.pbf',
-        layers: [
-            {
-                id: 'background',
-                type: 'background',
-                paint: { 'background-color': '#f5f1ef' },
-            },
-            {
-                id: 'earth',
-                type: 'fill',
-                source: 'protomaps',
-                'source-layer': 'earth',
-                paint: { 'fill-color': '#f5f1ef' },
-            },
-            {
-                id: 'landuse',
-                type: 'fill',
-                source: 'protomaps',
-                'source-layer': 'landuse',
-                paint: {
-                    'fill-color': [
-                        'match',
-                        ['get', 'kind'],
-                        ['park', 'nature_reserve', 'forest', 'wood', 'grass'],
-                        '#bdebb3',
-                        ['hospital'],
-                        '#f2dfdf',
-                        ['school', 'university'],
-                        '#e6dccf',
-                        ['industrial'],
-                        '#e2e3eb',
-                        ['commercial'],
-                        '#f5efdf',
-                        '#e3d9d4',
-                    ],
-                    'fill-opacity': 0.75,
-                },
-            },
-            {
-                id: 'water',
-                type: 'fill',
-                source: 'protomaps',
-                'source-layer': 'water',
-                paint: { 'fill-color': '#99ddff' },
-            },
-            {
-                id: 'buildings',
-                type: 'fill',
-                source: 'protomaps',
-                'source-layer': 'buildings',
-                minzoom: 13,
-                paint: { 'fill-color': '#ded6d3', 'fill-opacity': 0.75 },
-            },
-            {
-                id: 'roads-minor-casing',
-                type: 'line',
-                source: 'protomaps',
-                'source-layer': 'roads',
-                minzoom: 12,
-                filter: ['in', ['get', 'kind'], ['literal', ['minor_road', 'path', 'other']]],
-                paint: {
-                    'line-color': '#d2d6df',
-                    'line-width': ['interpolate', ['linear'], ['zoom'], 12, 1, 16, 3.5, 19, 10],
-                },
-            },
-            {
-                id: 'roads-major-casing',
-                type: 'line',
-                source: 'protomaps',
-                'source-layer': 'roads',
-                filter: ['==', ['get', 'kind'], 'major_road'],
-                paint: {
-                    'line-color': '#d2d6df',
-                    'line-width': ['interpolate', ['linear'], ['zoom'], 8, 1.4, 14, 4.5, 18, 14],
-                },
-            },
-            {
-                id: 'roads-highway-casing',
-                type: 'line',
-                source: 'protomaps',
-                'source-layer': 'roads',
-                filter: ['==', ['get', 'kind'], 'highway'],
-                paint: {
-                    'line-color': '#f9fafc',
-                    'line-width': ['interpolate', ['linear'], ['zoom'], 8, 1.6, 14, 5, 18, 16],
-                },
-            },
-            {
-                id: 'roads-minor',
-                type: 'line',
-                source: 'protomaps',
-                'source-layer': 'roads',
-                minzoom: 12,
-                filter: ['in', ['get', 'kind'], ['literal', ['minor_road', 'path', 'other']]],
-                paint: {
-                    'line-color': '#ffffff',
-                    'line-width': ['interpolate', ['linear'], ['zoom'], 12, 0.5, 16, 2.5, 19, 8],
-                },
-            },
-            {
-                id: 'roads-major',
-                type: 'line',
-                source: 'protomaps',
-                'source-layer': 'roads',
-                filter: ['==', ['get', 'kind'], 'major_road'],
-                paint: {
-                    'line-color': '#ffffff',
-                    'line-width': ['interpolate', ['linear'], ['zoom'], 8, 0.8, 14, 3, 18, 12],
-                },
-            },
-            {
-                id: 'roads-highway',
-                type: 'line',
-                source: 'protomaps',
-                'source-layer': 'roads',
-                filter: ['==', ['get', 'kind'], 'highway'],
-                paint: {
-                    'line-color': '#ffb366',
-                    'line-width': ['interpolate', ['linear'], ['zoom'], 8, 0.8, 14, 3, 18, 12],
-                },
-            },
-            {
-                id: 'road-labels',
-                type: 'symbol',
-                source: 'protomaps',
-                'source-layer': 'roads',
-                minzoom: 14,
-                filter: ['has', 'name'],
-                layout: {
-                    'symbol-placement': 'line',
-                    'text-field': ENGLISH_LABEL_FIELD,
-                    'text-font': [GLYPH_FONTSTACK],
-                    'text-size': ['interpolate', ['linear'], ['zoom'], 14, 10, 18, 13],
-                },
-                paint: {
-                    'text-color': '#000000',
-                    'text-halo-color': '#ffffff',
-                    'text-halo-width': 1,
-                },
-            },
-            {
-                id: 'place-labels',
-                type: 'symbol',
-                source: 'protomaps',
-                'source-layer': 'places',
-                filter: ['has', 'name'],
-                layout: {
-                    'icon-image': [
-                        'step',
-                        ['zoom'],
-                        ['case', ['==', ['get', 'capital'], 'yes'], 'capital', 'townspot'],
-                        8,
-                        '',
-                    ],
-                    'icon-size': 0.7,
-                    'text-field': ENGLISH_LABEL_FIELD,
-                    'text-font': [GLYPH_FONTSTACK],
-                    'text-size': ['interpolate', ['linear'], ['zoom'], 6, 11, 14, 16],
-                    'text-anchor': 'center',
-                    'text-offset': [0, 0.8],
-                },
-                paint: {
-                    'text-color': '#333333',
-                    'text-halo-color': '#ffffff',
-                    'text-halo-width': 1.25,
-                },
-            },
-        ],
-    };
-}
 // Builds the two-anchor affine bridge (p0 -> anchor a, p2 -> anchor b) used to
 // project the SVG-area corners into GPS. All GeoConfig parsing / SVG extraction /
 // anchor validation stays at the callsite; only the pure projection math lives in

package/dist/lib/map-theme.d.ts

@@ -0,0 +1,15 @@
+import { type MapTheme } from '@expofp/schema';
+/**
+ * The palette implied by the drawing's background color — the fallback for
+ * drawings that predate `__fpGeo.properties.config.style`.
+ *
+ * `'none'` is a real authored value and is not a parseable color, so it and
+ * anything else unparseable resolve to the light palette.
+ */
+export declare function deriveMapThemeFromBackground(backgroundColor: string | undefined): MapTheme;
+/**
+ * Resolve the basemap palette: the one the drawing declares in its geo config,
+ * else the one its background color implies.
+ */
+export declare function resolveMapTheme(drawingTheme: MapTheme | undefined, backgroundColor: string | undefined): MapTheme;
+//# sourceMappingURL=map-theme.d.ts.map

package/dist/lib/map-theme.js

@@ -0,0 +1,48 @@
+import Color from 'color';
+/**
+ * Which basemap palette a drawing is authored for.
+ *
+ * A deliberate duplicate of the floorplan's
+ * `components/Maplibre/utils/map-theme.ts`. The two must agree: online the SDK
+ * resolves the palette at runtime, offline the generator resolves it once and
+ * bakes the answer into the archived style, and a drawing must not change
+ * appearance just because it was taken offline.
+ *
+ * The background-color fallback below is on its way out; when it goes, both
+ * copies collapse to reading the declared style and this file loses its only
+ * non-trivial logic.
+ */
+/**
+ * Below this HSL lightness (0–100) a background counts as dark. Matches the
+ * floorplan's threshold — see the note there on why HSL and not WCAG luminance.
+ */
+const DARK_BACKGROUND_LIGHTNESS = 50;
+function isMapTheme(value) {
+    return value === 'light' || value === 'dark';
+}
+/**
+ * The palette implied by the drawing's background color — the fallback for
+ * drawings that predate `__fpGeo.properties.config.style`.
+ *
+ * `'none'` is a real authored value and is not a parseable color, so it and
+ * anything else unparseable resolve to the light palette.
+ */
+export function deriveMapThemeFromBackground(backgroundColor) {
+    if (!backgroundColor || backgroundColor === 'none')
+        return 'light';
+    try {
+        return Color(backgroundColor).lightness() < DARK_BACKGROUND_LIGHTNESS ? 'dark' : 'light';
+    }
+    catch {
+        return 'light';
+    }
+}
+/**
+ * Resolve the basemap palette: the one the drawing declares in its geo config,
+ * else the one its background color implies.
+ */
+export function resolveMapTheme(drawingTheme, backgroundColor) {
+    if (isMapTheme(drawingTheme))
+        return drawingTheme;
+    return deriveMapThemeFromBackground(backgroundColor);
+}

package/dist/lib/offline-map-style.d.ts

@@ -0,0 +1,51 @@
+import { type MapTheme } from '@expofp/schema';
+import { type Flavor } from '@protomaps/basemaps';
+/** The one font stack every label in {@link createOfflineMapStyle} asks for. */
+export declare const OFFLINE_GLYPH_FONTSTACK = "Noto Sans Regular";
+/**
+ * The Protomaps flavor recolored to CARTO Positron.
+ *
+ * `pois` is deliberately absent: it is optional, and leaving it out drops the
+ * colored POI icon layers entirely — the CARTO styles show no POI icons, so
+ * emitting them would be the loudest departure from the online look.
+ */
+export declare const POSITRON_FLAVOR: Flavor;
+/**
+ * The Protomaps flavor recolored to CARTO Dark Matter.
+ *
+ * Dark Matter tints no landuse at all — its parks, landcover and residential
+ * blocks are all painted the background color — so every land field here
+ * collapses onto {@link DARK_MATTER_BACKGROUND}. That is the intended look, not
+ * an omission.
+ */
+export declare const DARK_MATTER_FLAVOR: Flavor;
+export interface OfflineMapStyleOptions {
+    /** Basemap palette the drawing is authored for. */
+    theme: MapTheme;
+    /** Tile source URL, relative to the style document. */
+    tiles: string;
+    /** Sprite base URL, relative to the style document. */
+    sprite: string;
+    /** Glyph template URL, relative to the style document. */
+    glyphs: string;
+}
+/**
+ * Build the offline style document.
+ *
+ * URLs stay relative to the style so the archive is relocatable; the SDK
+ * absolutizes them at load time (see `MapLibreConfigSchema`).
+ */
+export declare function createOfflineMapStyle(options: OfflineMapStyleOptions): {
+    version: number;
+    sources: {
+        protomaps: {
+            type: string;
+            attribution: string;
+            url: string;
+        };
+    };
+    sprite: string;
+    glyphs: string;
+    layers: LayerSpecification[];
+};
+//# sourceMappingURL=offline-map-style.d.ts.map

package/dist/lib/offline-map-style.js

@@ -0,0 +1,283 @@
+import { layers } from '@protomaps/basemaps';
+/**
+ * The offline basemap style, built to look like the online one.
+ *
+ * Online the SDK serves the CARTO pair (`map-helpers.ts` in the floorplan):
+ * Positron for the light theme, Dark Matter for the dark one. Those are
+ * OpenMapTiles-schema styles; offline tiles come from a Protomaps basemap
+ * build, a different schema, so the *style* cannot be shared — only the
+ * palette. This module therefore renders the upstream Protomaps layer set
+ * (`@protomaps/basemaps`, kept current with the tile schema) through flavors
+ * whose colors are lifted from the two CARTO styles.
+ *
+ * Parity is visual, not pixel-exact: the two schemas classify roads, landuse
+ * and labels differently, so features are colored to the nearest CARTO
+ * equivalent rather than reproduced stop for stop.
+ */
+/**
+ * Backgrounds the two CARTO styles paint their land on. Fills that CARTO makes
+ * translucent are pre-blended over these, because the Protomaps layers paint
+ * them opaque.
+ */
+const POSITRON_BACKGROUND = '#fafaf8';
+const DARK_MATTER_BACKGROUND = '#0e0e0e';
+/**
+ * Protomaps draws buildings at 50% opacity; these are the fills that land on
+ * the CARTO building color once blended over the background.
+ *
+ * The target is CARTO's `building-top` (`#ededed` light, `#393939` dark), not
+ * its `building`: the latter is the extruded wall — `transparent` in Dark
+ * Matter — visible only as a sliver along the offset edge, so matching it
+ * would paint every roof wrong.
+ */
+const POSITRON_BUILDING_FILL = '#e0e0e2';
+const DARK_MATTER_BUILDING_FILL = '#646464';
+/**
+ * A single font stack for every label.
+ *
+ * The Protomaps layers ask for Regular, Medium and Italic; pinning all three to
+ * Regular keeps the offline archive at one downloaded glyph set instead of
+ * three, at the cost of unemphasized city and shield labels. The CARTO styles'
+ * own label weights are light throughout, so the flattening is barely visible.
+ */
+const GLYPH_FONTSTACK = 'Noto Sans Regular';
+/** The one font stack every label in {@link createOfflineMapStyle} asks for. */
+export const OFFLINE_GLYPH_FONTSTACK = GLYPH_FONTSTACK;
+/** CARTO Positron's road casing (`#ddd`) and its paler low-zoom variant. */
+const LIGHT_ROAD_CASING = '#dddddd';
+const LIGHT_ROAD_CASING_LOW_ZOOM = '#e6e6e6';
+/** Positron road fills: `#fdfdfd` for minor roads, pure white for the rest. */
+const LIGHT_ROAD_MINOR_FILL = '#fdfdfd';
+const LIGHT_ROAD_MAJOR_FILL = '#ffffff';
+/** Positron's translucent green landuse and grey residential, pre-blended. */
+const LIGHT_GREEN_FILL = '#f2f6f1';
+const LIGHT_GREY_FILL = '#f6f6f5';
+/**
+ * The Protomaps flavor recolored to CARTO Positron.
+ *
+ * `pois` is deliberately absent: it is optional, and leaving it out drops the
+ * colored POI icon layers entirely — the CARTO styles show no POI icons, so
+ * emitting them would be the loudest departure from the online look.
+ */
+export const POSITRON_FLAVOR = {
+    background: POSITRON_BACKGROUND,
+    earth: POSITRON_BACKGROUND,
+    park_a: LIGHT_GREEN_FILL,
+    park_b: LIGHT_GREEN_FILL,
+    hospital: LIGHT_GREY_FILL,
+    industrial: LIGHT_GREY_FILL,
+    school: LIGHT_GREY_FILL,
+    wood_a: LIGHT_GREEN_FILL,
+    wood_b: LIGHT_GREEN_FILL,
+    pedestrian: '#f4f4f2',
+    scrub_a: LIGHT_GREEN_FILL,
+    scrub_b: LIGHT_GREEN_FILL,
+    glacier: '#f7f7f7',
+    sand: '#f7f6f2',
+    beach: '#f7f6f2',
+    aerodrome: '#f4f4f4',
+    runway: '#e8e8e8',
+    water: '#d4dadc',
+    zoo: LIGHT_GREEN_FILL,
+    military: LIGHT_GREEN_FILL,
+    tunnel_other_casing: LIGHT_ROAD_CASING,
+    tunnel_minor_casing: LIGHT_ROAD_CASING,
+    tunnel_link_casing: LIGHT_ROAD_CASING,
+    tunnel_major_casing: LIGHT_ROAD_CASING,
+    tunnel_highway_casing: LIGHT_ROAD_CASING,
+    tunnel_other: '#eeeeee',
+    tunnel_minor: '#eeeeee',
+    tunnel_link: '#eeeeee',
+    tunnel_major: '#eeeeee',
+    tunnel_highway: '#eeeeee',
+    pier: '#f0f0ee',
+    buildings: POSITRON_BUILDING_FILL,
+    minor_service_casing: LIGHT_ROAD_CASING,
+    minor_casing: LIGHT_ROAD_CASING,
+    link_casing: LIGHT_ROAD_CASING,
+    major_casing_late: LIGHT_ROAD_CASING,
+    highway_casing_late: LIGHT_ROAD_CASING,
+    other: LIGHT_ROAD_MINOR_FILL,
+    minor_service: LIGHT_ROAD_MINOR_FILL,
+    // Minor roads fade from casing grey to their fill as they widen, the way
+    // Positron's thin low-zoom casings read before the white fill takes over.
+    minor_a: LIGHT_ROAD_CASING_LOW_ZOOM,
+    minor_b: LIGHT_ROAD_MINOR_FILL,
+    link: LIGHT_ROAD_MAJOR_FILL,
+    major_casing_early: LIGHT_ROAD_CASING,
+    major: LIGHT_ROAD_MAJOR_FILL,
+    highway_casing_early: LIGHT_ROAD_CASING,
+    highway: LIGHT_ROAD_MAJOR_FILL,
+    railway: '#dddddd',
+    boundaries: '#e1c5c7',
+    bridges_other_casing: LIGHT_ROAD_CASING,
+    bridges_minor_casing: LIGHT_ROAD_CASING,
+    bridges_link_casing: LIGHT_ROAD_CASING,
+    bridges_major_casing: LIGHT_ROAD_CASING,
+    bridges_highway_casing: LIGHT_ROAD_CASING,
+    bridges_other: LIGHT_ROAD_MINOR_FILL,
+    bridges_minor: LIGHT_ROAD_MINOR_FILL,
+    bridges_link: LIGHT_ROAD_MAJOR_FILL,
+    bridges_major: LIGHT_ROAD_MAJOR_FILL,
+    bridges_highway: LIGHT_ROAD_MAJOR_FILL,
+    roads_label_minor: '#838383',
+    roads_label_minor_halo: '#ffffff',
+    roads_label_major: '#838383',
+    roads_label_major_halo: '#ffffff',
+    ocean_label: '#abb6be',
+    subplace_label: '#697b89',
+    subplace_label_halo: '#ffffff',
+    city_label: '#697b89',
+    city_label_halo: '#ffffff',
+    state_label: '#97a4ae',
+    state_label_halo: POSITRON_BACKGROUND,
+    country_label: '#8a99a4',
+    address_label: '#a3a3a3',
+    address_label_halo: '#ffffff',
+    regular: GLYPH_FONTSTACK,
+    bold: GLYPH_FONTSTACK,
+    italic: GLYPH_FONTSTACK,
+    landcover: {
+        grassland: LIGHT_GREEN_FILL,
+        barren: '#f7f6f2',
+        urban_area: LIGHT_GREY_FILL,
+        farmland: LIGHT_GREEN_FILL,
+        glacier: '#f7f7f7',
+        scrub: LIGHT_GREEN_FILL,
+        forest: LIGHT_GREEN_FILL,
+    },
+};
+/** Dark Matter's road bands: minor and secondary flat, primary and motorway lifted. */
+const DARK_ROAD_MINOR_FILL = '#414758';
+const DARK_ROAD_MAJOR_FILL = '#535666';
+const DARK_ROAD_HIGHWAY_FILL = '#494949';
+const DARK_ROAD_SERVICE_FILL = '#0b0b0b';
+/** Dark Matter outlines its bigger roads; minor roads get no visible casing. */
+const DARK_ROAD_CASING = '#232323';
+const DARK_TUNNEL_CASING = '#1a1a1a';
+/**
+ * The Protomaps flavor recolored to CARTO Dark Matter.
+ *
+ * Dark Matter tints no landuse at all — its parks, landcover and residential
+ * blocks are all painted the background color — so every land field here
+ * collapses onto {@link DARK_MATTER_BACKGROUND}. That is the intended look, not
+ * an omission.
+ */
+export const DARK_MATTER_FLAVOR = {
+    background: DARK_MATTER_BACKGROUND,
+    earth: DARK_MATTER_BACKGROUND,
+    park_a: DARK_MATTER_BACKGROUND,
+    park_b: DARK_MATTER_BACKGROUND,
+    hospital: DARK_MATTER_BACKGROUND,
+    industrial: DARK_MATTER_BACKGROUND,
+    school: DARK_MATTER_BACKGROUND,
+    wood_a: DARK_MATTER_BACKGROUND,
+    wood_b: DARK_MATTER_BACKGROUND,
+    pedestrian: DARK_MATTER_BACKGROUND,
+    scrub_a: DARK_MATTER_BACKGROUND,
+    scrub_b: DARK_MATTER_BACKGROUND,
+    glacier: DARK_MATTER_BACKGROUND,
+    sand: DARK_MATTER_BACKGROUND,
+    beach: DARK_MATTER_BACKGROUND,
+    aerodrome: DARK_MATTER_BACKGROUND,
+    runway: '#111111',
+    water: '#2c353c',
+    zoo: DARK_MATTER_BACKGROUND,
+    military: DARK_MATTER_BACKGROUND,
+    tunnel_other_casing: DARK_TUNNEL_CASING,
+    tunnel_minor_casing: DARK_TUNNEL_CASING,
+    tunnel_link_casing: DARK_TUNNEL_CASING,
+    tunnel_major_casing: DARK_ROAD_CASING,
+    tunnel_highway_casing: DARK_ROAD_CASING,
+    tunnel_other: '#161616',
+    tunnel_minor: '#161616',
+    tunnel_link: '#161616',
+    tunnel_major: DARK_ROAD_MINOR_FILL,
+    tunnel_highway: DARK_ROAD_MINOR_FILL,
+    pier: DARK_TUNNEL_CASING,
+    buildings: DARK_MATTER_BUILDING_FILL,
+    minor_service_casing: '#1c1c1c',
+    // Dark Matter paints the minor casing the same color as the fill, so minor
+    // roads read as one flat band rather than a lined one.
+    minor_casing: DARK_ROAD_MINOR_FILL,
+    link_casing: DARK_ROAD_CASING,
+    major_casing_late: DARK_ROAD_CASING,
+    highway_casing_late: DARK_ROAD_CASING,
+    other: DARK_ROAD_SERVICE_FILL,
+    minor_service: DARK_ROAD_SERVICE_FILL,
+    minor_a: DARK_ROAD_MINOR_FILL,
+    minor_b: DARK_ROAD_MINOR_FILL,
+    link: DARK_ROAD_MINOR_FILL,
+    major_casing_early: DARK_ROAD_CASING,
+    major: DARK_ROAD_MAJOR_FILL,
+    highway_casing_early: DARK_ROAD_CASING,
+    highway: DARK_ROAD_HIGHWAY_FILL,
+    railway: '#1a1a1a',
+    boundaries: '#5c5e5e',
+    // Deliberate deviation: Dark Matter fills most bridge decks near-black
+    // (`#0b0b0b`) and lets the casing carry them, which on the Protomaps layer
+    // set reads as a bridge that vanishes. Mirroring the road colors keeps
+    // bridges legible at the cost of an exact match on a feature that is rare
+    // inside a venue's bbox.
+    bridges_other_casing: DARK_ROAD_CASING,
+    bridges_minor_casing: DARK_ROAD_CASING,
+    bridges_link_casing: DARK_ROAD_CASING,
+    bridges_major_casing: DARK_ROAD_CASING,
+    bridges_highway_casing: DARK_ROAD_CASING,
+    bridges_other: DARK_ROAD_SERVICE_FILL,
+    bridges_minor: DARK_ROAD_MINOR_FILL,
+    bridges_link: DARK_ROAD_MINOR_FILL,
+    bridges_major: DARK_ROAD_MAJOR_FILL,
+    bridges_highway: DARK_ROAD_HIGHWAY_FILL,
+    roads_label_minor: '#b5b4b4',
+    roads_label_minor_halo: '#111111',
+    roads_label_major: '#b5b4b4',
+    roads_label_major_halo: '#111111',
+    ocean_label: '#6d7b81',
+    subplace_label: '#ccd0e4',
+    subplace_label_halo: '#222222',
+    city_label: '#ccd0e4',
+    city_label_halo: '#222222',
+    state_label: '#cbe6e6',
+    state_label_halo: '#222222',
+    country_label: '#9d9d9d',
+    address_label: '#515151',
+    address_label_halo: '#111111',
+    regular: GLYPH_FONTSTACK,
+    bold: GLYPH_FONTSTACK,
+    italic: GLYPH_FONTSTACK,
+    landcover: {
+        grassland: DARK_MATTER_BACKGROUND,
+        barren: DARK_MATTER_BACKGROUND,
+        urban_area: DARK_MATTER_BACKGROUND,
+        farmland: DARK_MATTER_BACKGROUND,
+        glacier: DARK_MATTER_BACKGROUND,
+        scrub: DARK_MATTER_BACKGROUND,
+        forest: DARK_MATTER_BACKGROUND,
+    },
+};
+const FLAVORS = {
+    light: POSITRON_FLAVOR,
+    dark: DARK_MATTER_FLAVOR,
+};
+/**
+ * Build the offline style document.
+ *
+ * URLs stay relative to the style so the archive is relocatable; the SDK
+ * absolutizes them at load time (see `MapLibreConfigSchema`).
+ */
+export function createOfflineMapStyle(options) {
+    return {
+        version: 8,
+        sources: {
+            protomaps: {
+                type: 'vector',
+                attribution: '<a href="https://github.com/protomaps/basemaps">Protomaps</a> © <a href="https://openstreetmap.org">OpenStreetMap</a>',
+                url: `pmtiles://${options.tiles}`,
+            },
+        },
+        sprite: options.sprite,
+        glyphs: options.glyphs,
+        layers: layers('protomaps', FLAVORS[options.theme], { lang: 'en' }),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/offline",
-  "version": "3.15.0",
+  "version": "3.16.1",
   "type": "module",
   "description": "CLI tool for creating offline copies of ExpoFP floor plans",
   "homepage": "https://developer.expofp.com/",
@@ -29,13 +29,18 @@
     "!**/*.map"
   ],
   "dependencies": {
+    "@protomaps/basemaps": "^5.7.2",
+    "color": "^3.1.2",
     "debug": "^4.4.3",
     "tslib": "^2.3.0",
-    "@expofp/config": "3.15.0",
-    "@expofp/floorplan": "3.15.0",
-    "@expofp/geometry": "3.15.0",
-    "@expofp/resolve": "3.15.0",
-    "@expofp/schema": "3.15.0",
-    "@expofp/utils": "3.15.0"
+    "@expofp/floorplan": "3.16.1",
+    "@expofp/geometry": "3.16.1",
+    "@expofp/resolve": "3.16.1",
+    "@expofp/utils": "3.16.1",
+    "@expofp/config": "3.16.1",
+    "@expofp/schema": "3.16.1"
+  },
+  "devDependencies": {
+    "@types/color": "^3.0.7"
   }
 }