@expofp/offline 3.3.8 → 3.4.0

package/README.md

@@ -10,11 +10,14 @@ npx @expofp/offline@<tag-or-version> <manifest-url> [options]
 
 Use a dist-tag or exact version to match the deployed floor plan (e.g. `@latest`, `@stable`, `@customer1`, `@3.0.0-alpha.9`).
 
-| Option            | Description         | Default       |
-| ----------------- | ------------------- | ------------- |
-| `-o`, `--output`  | Output file path    | `offline.zip` |
-| `-h`, `--help`    | Show help message   |               |
-| `-v`, `--version` | Show version number |               |
+| Option             | Description                                                              | Default                                |
+| ------------------ | ------------------------------------------------------------------------ | -------------------------------------- |
+| `-o`, `--output`   | Output file path                                                         | `offline.zip`                          |
+| `--map-debug`      | Enable debug-only map flags. Do not use in production.                   |                                        |
+| `--no-offline-map` | Disable automatic MapLibre basemap detection. Requires `--map-debug`.    |                                        |
+| `--map-source`     | Global PMTiles source URL/path for offline maps. Requires `--map-debug`. | Latest available Protomaps daily build |
+| `-h`, `--help`     | Show help message                                                        |                                        |
+| `-v`, `--version`  | Show version number                                                      |                                        |
 
 ### Example
 
@@ -22,6 +25,29 @@ Use a dist-tag or exact version to match the deployed floor plan (e.g. `@latest`
 npx @expofp/offline@stable https://demo.expofp.com/manifest.json -o offline.zip
 ```
 
+Offline MapLibre basemaps are inferred automatically from `__fpGeo.properties.config`:
+
+```bash
+npx @expofp/offline@next https://demo.expofp.com/manifest.json -o offline.zip
+```
+
+To skip automatic offline map generation for debugging only:
+
+```bash
+npx @expofp/offline@next https://demo.expofp.com/manifest.json \
+  --map-debug \
+  --no-offline-map \
+  -o offline.zip
+```
+
+If `--map-source` is omitted, the CLI checks `https://build.protomaps.com/YYYYMMDD.pmtiles`
+starting from the current date and falls back to previous dates for up to 7 days.
+For debugging only, pass `--map-debug --map-source` explicitly to use a specific PMTiles URL or local file.
+
+Offline map extraction requires the `pmtiles` CLI binary to be available in `PATH`.
+This is separate from the `pmtiles` npm package used by the browser runtime.
+On macOS, install the CLI with `brew install pmtiles`.
+
 ### Debugging
 
 Enable debug output with the `DEBUG` env variable:

package/dist/cli.js

@@ -13,14 +13,33 @@ Arguments:
 
 Options:
   -o, --output   Output file path (default: offline.zip)
+      --map-debug
+                Enable debug-only map flags. Do not use in production.
+      --no-offline-map
+                Disable automatic offline MapLibre basemap detection (requires --map-debug)
+      --map-source <source>
+                Global PMTiles source URL/path used for the offline map
+                Defaults to the latest available Protomaps daily build (requires --map-debug)
   -h, --help     Show this help message
   -v, --version  Show version number
 `.trim();
 async function main() {
+    const abortController = new AbortController();
+    const abortOnSigint = () => {
+        console.error('\nAborting offline ZIP creation...');
+        abortController.abort(new Error('Aborted by SIGINT'));
+    };
+    process.once('SIGINT', abortOnSigint);
+    const rawArgs = process.argv.slice(2);
+    const noOfflineMap = rawArgs.includes('--no-offline-map');
     const { values, positionals } = parseArgs({
+        args: rawArgs.filter((arg) => arg !== '--no-offline-map'),
         allowPositionals: true,
+        allowNegative: true,
         options: {
             output: { type: 'string', short: 'o', default: 'offline.zip' },
+            'map-debug': { type: 'boolean', default: false },
+            'map-source': { type: 'string' },
             help: { type: 'boolean', short: 'h', default: false },
             version: { type: 'boolean', short: 'v', default: false },
         },
@@ -54,10 +73,34 @@ async function main() {
         console.error('Error: output path must end with .zip\n');
         process.exit(1);
     }
+    if (!values['map-debug'] && noOfflineMap) {
+        console.error('Error: --no-offline-map requires --map-debug and is for debug only\n');
+        process.exit(1);
+    }
+    if (!values['map-debug'] && values['map-source']) {
+        console.error('Error: --map-source requires --map-debug and is for debug only\n');
+        process.exit(1);
+    }
+    if (noOfflineMap && values['map-source']) {
+        console.error('Error: --map-source cannot be used with --no-offline-map\n');
+        process.exit(1);
+    }
+    const offlineMap = values['map-source'] ? { mapSource: values['map-source'] } : undefined;
+    const inferOfflineMap = !noOfflineMap;
     console.log(`Resolving @expofp/floorplan runtime...`);
     const runtimeBaseUrl = await resolveFloorplanDir();
     console.log(`Creating offline ZIP from ${manifestUrl}...`);
-    await saveOfflineZip({ $ref: manifestUrl }, outputPath, { runtimeBaseUrl });
+    try {
+        await saveOfflineZip({ $ref: manifestUrl }, outputPath, {
+            runtimeBaseUrl,
+            offlineMap,
+            inferOfflineMap,
+            signal: abortController.signal,
+        });
+    }
+    finally {
+        process.removeListener('SIGINT', abortOnSigint);
+    }
     console.log(`Done! Offline ZIP saved to ${outputPath}`);
 }
 main().catch((err) => {

package/dist/lib/abort-signal.d.ts

@@ -0,0 +1,2 @@
+export declare function withTimeout(signal: AbortSignal | undefined, ms: number): AbortSignal;
+//# sourceMappingURL=abort-signal.d.ts.map

package/dist/lib/abort-signal.js

@@ -0,0 +1,6 @@
+export function withTimeout(signal, ms) {
+    if (signal?.aborted)
+        return signal;
+    const timeout = AbortSignal.timeout(ms);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}

package/dist/lib/data-to-files.js

@@ -1,10 +1,13 @@
 import { readFileFromUrl } from '@expofp/utils';
 import debug from 'debug';
+import { withTimeout } from './abort-signal.js';
 const log = debug('efp:offline:data-to-files');
+const FILE_FETCH_TIMEOUT_MS = 60_000;
 export async function* dataToFiles(data, options) {
     for await (const file of data) {
         if ('url' in file) {
-            const response = await readFileFromUrl(file.url, { signal: options?.signal });
+            const signal = withTimeout(options?.signal, FILE_FETCH_TIMEOUT_MS);
+            const response = await readFileFromUrl(file.url, { signal });
             if (!response.ok) {
                 console.warn(`Skipping file ${file.url} as it could not be downloaded`);
             }

package/dist/lib/download-offline-zip.js

@@ -4,9 +4,11 @@ export async function downloadOfflineZip(manifest, options) {
         throw new Error('downloadOfflineZip can only be used in a browser environment');
     }
     const blob = await buildOfflineZip(manifest, options);
+    const objectUrl = URL.createObjectURL(blob);
     const a = document.createElement('a');
-    a.href = URL.createObjectURL(blob);
+    a.href = objectUrl;
     a.download = 'offline.zip';
     a.click();
-    URL.revokeObjectURL(a.href);
+    // revoke to prevent race conditions with the download
+    setTimeout(() => URL.revokeObjectURL(objectUrl), 60_000);
 }

package/dist/lib/exec-script-in-sandbox.d.ts

@@ -0,0 +1,3 @@
+/** Fetch a legacy data script and execute it in a compatibility vm context. */
+export declare function execScriptInSandbox(url: string, signal?: AbortSignal): Promise<Record<string, unknown>>;
+//# sourceMappingURL=exec-script-in-sandbox.d.ts.map

package/dist/lib/exec-script-in-sandbox.js

@@ -0,0 +1,44 @@
+import { fetchWithRetry } from '@expofp/utils';
+import { withTimeout } from './abort-signal.js';
+const SCRIPT_FETCH_TIMEOUT_MS = 60_000;
+const SCRIPT_EXECUTION_TIMEOUT_MS = 5_000;
+const LEGACY_SCRIPT_ALLOWED_ORIGINS_ENV = 'EXPOFP_OFFLINE_LEGACY_SCRIPT_ORIGINS';
+/** Fetch a legacy data script and execute it in a compatibility vm context. */
+export async function execScriptInSandbox(url, signal) {
+    assertTrustedLegacyScriptUrl(url);
+    const fetchSignal = withTimeout(signal, SCRIPT_FETCH_TIMEOUT_MS);
+    const response = await fetchWithRetry(url, { signal: fetchSignal });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch script (HTTP ${response.status}): ${url}`);
+    }
+    const code = await response.text();
+    const { runInNewContext } = await import('node:vm');
+    const sandbox = {};
+    sandbox.window = sandbox; // legacy scripts expect window === globalThis
+    // The vm context is not a security boundary; origin validation above is required.
+    runInNewContext(code, sandbox, { timeout: SCRIPT_EXECUTION_TIMEOUT_MS });
+    return sandbox;
+}
+function assertTrustedLegacyScriptUrl(url) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new Error(`Legacy script URL must use http or https: ${url}`);
+    }
+    const allowedOrigins = getAllowedLegacyScriptOrigins();
+    if (isDefaultAllowedHost(parsed.hostname) || allowedOrigins.includes(parsed.origin))
+        return;
+    throw new Error(`Legacy script host is not allowed: ${parsed.hostname}. Add ${parsed.origin} to ${LEGACY_SCRIPT_ALLOWED_ORIGINS_ENV} to allow it.`);
+}
+function getAllowedLegacyScriptOrigins() {
+    return (process.env[LEGACY_SCRIPT_ALLOWED_ORIGINS_ENV] ?? '')
+        .split(',')
+        .map((origin) => origin.trim())
+        .filter(Boolean);
+}
+function isDefaultAllowedHost(hostname) {
+    return (hostname === 'expofp.com' ||
+        hostname.endsWith('.expofp.com') ||
+        hostname === 'localhost' ||
+        hostname === '127.0.0.1' ||
+        hostname === '::1');
+}

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

@@ -1,6 +1,7 @@
 import { resolve } from '@expofp/resolve';
-import { deepClone, fetchWithRetry, makeLocalPath } from '@expofp/utils';
+import { deepClone, makeLocalPath } from '@expofp/utils';
 import debug from 'debug';
+import { execScriptInSandbox } from './exec-script-in-sandbox.js';
 import { offlinizeAssetsInPlace } from './offlinize-assets-in-place.js';
 const log = debug('efp:offline:generate-offline-data-legacy');
 export async function* generateOfflineDataLegacy(manifest, options) {
@@ -9,7 +10,7 @@ export async function* generateOfflineDataLegacy(manifest, options) {
     }
     const { signal } = options;
     const legacyDataUrlBase = manifest.legacyDataUrlBase;
-    const version = await resolve(manifest.legacyDataVersion)
+    const version = await resolve(manifest.legacyDataVersion, { signal })
         .then((json) => json?.version)
         .catch(() => {
         log('Could not resolve legacyDataVersion, proceeding without it');
@@ -46,24 +47,6 @@ export async function* generateOfflineDataLegacy(manifest, options) {
     }
     manifest.legacyDataUrlBase = localDataUrlBase;
 }
-/**
- * Fetch a script and execute it in an isolated Node.js vm context.
- * Returns the sandbox object containing any globals the script set.
- * Uses dynamic import so the module can still be loaded in browser bundles
- * (the function itself is Node-only).
- */
-async function execScriptInSandbox(url, signal) {
-    const response = await fetchWithRetry(url, { signal });
-    if (!response.ok) {
-        throw new Error(`Failed to fetch script (HTTP ${response.status}): ${url}`);
-    }
-    const code = await response.text();
-    const { runInNewContext } = await import('node:vm');
-    const sandbox = {};
-    sandbox.window = sandbox; // legacy scripts expect window === globalThis
-    runInNewContext(code, sandbox);
-    return sandbox;
-}
 /** Strip a path prefix from all string values in a data tree (in place). */
 function stripPathPrefix(node, prefix) {
     if (Array.isArray(node)) {

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

@@ -3,21 +3,32 @@ import { buildZipArchive, deepClone } from '@expofp/utils';
 import debug from 'debug';
 import { dataToFiles } from './data-to-files.js';
 import { generateOfflineDataLegacy } from './generate-offline-data-legacy.js';
+import { generateOfflineMapData, inferOfflineMapOptions, validateOfflineMapOptions, } from './generate-offline-map-data.js';
 import { generateRuntimeFilesData } from './generate-runtime-files-data.js';
 import { offlinizeAssetsInPlace } from './offlinize-assets-in-place.js';
 const log = debug('efp:offline:generate-offline-data');
 export async function* generateOfflineData(inputManifest, options) {
-    const manifest = deepClone(await resolve(inputManifest));
+    const manifest = deepClone(await resolve(inputManifest, { signal: options.signal }));
     log(`Generating offline files for expo: ${manifest.expo}`);
     const pathPrefix = manifest.expo;
     // this is a requirement of mobile SDK, paths in the ZIP must be prefixed with the expo name
     // TODO: make sure SDK works with unprefixed paths, and remove the prefixing logic from this function
     const prefixPath = (path) => `${pathPrefix}/${path}`;
+    const legacyDataUrlBase = manifest.legacyDataUrlBase;
+    let maplibre;
+    const offlineMap = await resolveOfflineMapOptions(manifest, options);
     if (manifest.legacyDataUrlBase) {
         for await (const d of generateOfflineDataLegacy(manifest, options)) {
             yield { ...d, targetFilePath: prefixPath(d.targetFilePath) };
         }
     }
+    if (offlineMap) {
+        const mapData = generateOfflineMapData({ ...manifest, legacyDataUrlBase }, { ...offlineMap, signal: options.signal });
+        for await (const d of mapData.files) {
+            yield { ...d, targetFilePath: prefixPath(d.targetFilePath) };
+        }
+        maplibre = mapData.maplibre;
+    }
     // transform entire manifest + assets
     const data = await offlinizeAssetsInPlace(manifest, options);
     for (const d of data) {
@@ -36,10 +47,19 @@ export async function* generateOfflineData(inputManifest, options) {
     const { entry } = runtimeResult.value;
     // generate index.html
     yield {
-        text: getIndexHtml(entry, manifest),
+        text: getIndexHtml(entry, manifest, maplibre),
         targetFilePath: prefixPath('index.html'),
     };
 }
+async function resolveOfflineMapOptions(manifest, options) {
+    if (options.inferOfflineMap) {
+        return await inferOfflineMapOptions(manifest, options.offlineMap, options.signal);
+    }
+    if (options.offlineMap) {
+        return await validateOfflineMapOptions(options.offlineMap, options.signal);
+    }
+    return undefined;
+}
 /** Build a complete offline ZIP archive from a manifest. */
 export async function buildOfflineZip(manifest, options) {
     const data = generateOfflineData(manifest, options);
@@ -48,7 +68,7 @@ export async function buildOfflineZip(manifest, options) {
 }
 /** Known path — file lives in `packages/floorplan/public/` and is copied to dist by Vite. */
 const COMPAT_HELPER = 'compat-helper.js';
-function getIndexHtml(entry, manifest) {
+function getIndexHtml(entry, manifest, maplibre) {
     // entry is "./runtime/index.js", derive the runtime base path
     const runtimeBase = entry.slice(0, entry.lastIndexOf('/') + 1);
     return `\
@@ -56,7 +76,22 @@ function getIndexHtml(entry, manifest) {
 <script src="${runtimeBase}${COMPAT_HELPER}"></script>
 <script type="module">
   import { load } from ${JSON.stringify(entry)};
-  await load(${JSON.stringify(manifest)});
+  const options = ${JSON.stringify({ ...manifest, maplibre })};
+  if (options.maplibre && options.maplibre.offline && options.maplibre.styleUrl) {
+    const styleUrl = new URL(options.maplibre.styleUrl, window.location.href);
+    const style = await fetch(styleUrl).then((response) => response.json());
+    const resolveStyleUrl = (url) => new URL(url, styleUrl).href.replaceAll('%7B', '{').replaceAll('%7D', '}');
+    if (typeof style.sprite === 'string') style.sprite = resolveStyleUrl(style.sprite);
+    if (typeof style.glyphs === 'string') style.glyphs = resolveStyleUrl(style.glyphs);
+    for (const source of Object.values(style.sources || {})) {
+      if (source && typeof source.url === 'string' && source.url.startsWith('pmtiles://')) {
+        source.url = 'pmtiles://' + new URL(source.url.slice('pmtiles://'.length), styleUrl).href;
+      }
+    }
+    options.maplibre.style = style;
+    delete options.maplibre.styleUrl;
+  }
+  await load(options);
 </script>
 `;
 }

package/dist/lib/generate-offline-map-data.d.ts

@@ -0,0 +1,19 @@
+import type { Manifest } from '@expofp/data';
+import type { MaplibreOptions } from '@expofp/floorplan';
+import type { LocalData, OfflineMapOptions } from './types.js';
+type FpSvgContext = Record<string, unknown>;
+export type ValidatedOfflineMapOptions = OfflineMapOptions & {
+    mapSource: string;
+    fpSvgContext?: FpSvgContext;
+};
+export interface OfflineMapResult {
+    files: AsyncIterable<LocalData>;
+    maplibre: MaplibreOptions;
+}
+export declare function generateOfflineMapData(manifest: Manifest, options: ValidatedOfflineMapOptions & {
+    signal?: AbortSignal;
+}): OfflineMapResult;
+export declare function validateOfflineMapOptions(options: OfflineMapOptions, signal?: AbortSignal): Promise<ValidatedOfflineMapOptions>;
+export declare function inferOfflineMapOptions(manifest: Manifest, options: OfflineMapOptions | undefined, signal?: AbortSignal): Promise<ValidatedOfflineMapOptions | undefined>;
+export {};
+//# sourceMappingURL=generate-offline-map-data.d.ts.map

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

@@ -0,0 +1,503 @@
+import { resolve } from '@expofp/resolve';
+import debug from 'debug';
+import { execScriptInSandbox } from './exec-script-in-sandbox.js';
+const log = debug('efp:offline:generate-offline-map-data');
+const MAPS_BASE_PATH = 'maps/';
+const MAP_STYLE_PATH = `${MAPS_BASE_PATH}style.json`;
+const MAP_PMTILES_PATH = `${MAPS_BASE_PATH}basemap.pmtiles`;
+const MAP_PMTILES_STYLE_URL = './basemap.pmtiles';
+const MAP_BOUNDS_PADDING_FACTOR = 3;
+const MAP_BOUNDS_MIN_PADDING_DEGREES = 0.02;
+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';
+const PROTOMAPS_FONT_BASE = 'https://protomaps.github.io/basemaps-assets/fonts';
+const GLYPH_FONTSTACK = 'Noto Sans Regular';
+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(manifest, options) {
+    const maplibre = {
+        styleUrl: `./${MAP_STYLE_PATH}`,
+        offline: true,
+    };
+    async function* files() {
+        if (!manifest.legacyDataUrlBase) {
+            throw new Error('Offline map generation requires legacyDataUrlBase in the manifest.');
+        }
+        const bbox = await derivePaddedVenueBbox(manifest, options.fpSvgContext, options.signal);
+        log('Extracting PMTiles for bbox', bbox.join(','));
+        const pmtilesFile = await extractPmtiles(options.mapSource, bbox, options.signal);
+        try {
+            yield {
+                url: pmtilesFile.url,
+                targetFilePath: MAP_PMTILES_PATH,
+            };
+            yield {
+                text: JSON.stringify(createMapStyle(), null, 2),
+                targetFilePath: MAP_STYLE_PATH,
+            };
+            yield* getSpriteAssets();
+            yield* getGlyphAssets();
+        }
+        finally {
+            await cleanupTempDir(pmtilesFile.tempDir);
+        }
+    }
+    return { files: files(), maplibre };
+}
+export async function validateOfflineMapOptions(options, signal) {
+    let mapSource = options.mapSource;
+    if (!mapSource) {
+        console.log('Looking for latest Protomaps map source...');
+        mapSource = await resolveDefaultMapSource(signal);
+    }
+    await assertValidMapSource(mapSource);
+    console.log(`Using map source ${mapSource}`);
+    await assertPmtilesCliAvailable(signal);
+    return { ...options, mapSource };
+}
+export async function inferOfflineMapOptions(manifest, options, signal) {
+    if (!manifest.legacyDataUrlBase)
+        return undefined;
+    const fpSvgContext = await resolveFpSvgContext(manifest, signal);
+    const fpGeo = fpSvgContext.__fpGeo;
+    if (!fpGeo?.properties?.config)
+        return undefined;
+    return {
+        ...(await validateOfflineMapOptions(options ?? {}, signal)),
+        fpSvgContext,
+    };
+}
+async function resolveDefaultMapSource(signal) {
+    for (let dayOffset = 0; dayOffset < DEFAULT_MAP_SOURCE_LOOKBACK_DAYS; dayOffset++) {
+        const source = createDefaultMapSource(dayOffset);
+        const response = await fetch(source, { method: 'HEAD', signal });
+        if (response.ok)
+            return source;
+        if (response.status !== 404) {
+            throw new Error(`Unable to check default offline map source ${source}: HTTP ${response.status}`);
+        }
+    }
+    throw new Error(`Could not find a default Protomaps PMTiles build from the last ${DEFAULT_MAP_SOURCE_LOOKBACK_DAYS} days. Specify --map-source explicitly.`);
+}
+function createDefaultMapSource(dayOffset) {
+    const date = new Date();
+    date.setUTCDate(date.getUTCDate() - dayOffset);
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    return `${DEFAULT_MAP_SOURCE_BASE}/${year}${month}${day}.pmtiles`;
+}
+async function derivePaddedVenueBbox(manifest, fpSvgContext, signal) {
+    const ctx = fpSvgContext ?? (await resolveFpSvgContext(manifest, signal));
+    const fpGeo = ctx.__fpGeo;
+    const config = fpGeo?.properties?.config;
+    if (!config) {
+        throw new Error('Offline map generation requires fpGeo.properties.config.');
+    }
+    const svgArea = deriveSvgArea(ctx);
+    const corners = [
+        [svgArea.x1, svgArea.y1],
+        [svgArea.x2, svgArea.y1],
+        [svgArea.x2, svgArea.y2],
+        [svgArea.x1, svgArea.y2],
+    ].map(([x, y]) => convertLocalToGps(x, y, config));
+    if (!corners.every(([lng, lat]) => Number.isFinite(lng) && Number.isFinite(lat))) {
+        throw new Error('Offline map generation produced invalid venue GPS bounds.');
+    }
+    const lngs = corners.map(([lng]) => lng);
+    const lats = corners.map(([, lat]) => lat);
+    const minLng = Math.min(...lngs);
+    const maxLng = Math.max(...lngs);
+    const minLat = Math.min(...lats);
+    const maxLat = Math.max(...lats);
+    const lngPadding = Math.max((maxLng - minLng) * MAP_BOUNDS_PADDING_FACTOR, MAP_BOUNDS_MIN_PADDING_DEGREES);
+    const latPadding = Math.max((maxLat - minLat) * MAP_BOUNDS_PADDING_FACTOR, MAP_BOUNDS_MIN_PADDING_DEGREES);
+    return [minLng - lngPadding, minLat - latPadding, maxLng + lngPadding, maxLat + latPadding];
+}
+async function resolveFpSvgContext(manifest, signal) {
+    if (!manifest.legacyDataUrlBase) {
+        throw new Error('Offline map generation requires legacyDataUrlBase in the manifest.');
+    }
+    const version = await resolve(manifest.legacyDataVersion, { signal })
+        .then((json) => json?.version)
+        .catch(() => Date.now().toString());
+    return await execScriptInSandbox(`${manifest.legacyDataUrlBase}fp.svg.js?v=${version}`, signal);
+}
+function deriveSvgArea(ctx) {
+    const viewboxObj = ctx.__viewbox;
+    if (viewboxObj) {
+        return fromXywh(viewboxObj.x, viewboxObj.y, viewboxObj.width, viewboxObj.height);
+    }
+    const fpSvg = ctx.__fp;
+    if (typeof fpSvg !== 'string') {
+        throw new Error('Offline map generation requires __fp SVG data.');
+    }
+    const viewboxRect = getSvgRectById(fpSvg, 'VIEWBOX');
+    if (viewboxRect)
+        return viewboxRect;
+    const svgViewBox = getSvgViewBox(fpSvg);
+    if (!svgViewBox) {
+        throw new Error('Offline map generation could not derive the SVG viewBox.');
+    }
+    return withPadding(svgViewBox, -width(svgViewBox) * 0.05, -height(svgViewBox) * 0.05);
+}
+function getSvgViewBox(svg) {
+    const match = svg.match(/\bviewBox\s*=\s*["']([^"']+)["']/i);
+    if (!match)
+        return null;
+    const [x, y, w, h] = match[1]
+        .trim()
+        .split(/[\s,]+/)
+        .map(Number);
+    if (![x, y, w, h].every(Number.isFinite))
+        return null;
+    return fromXywh(x, y, w, h);
+}
+function getSvgRectById(svg, id) {
+    const rectMatch = svg.match(new RegExp(`<rect\\b(?=[^>]*\\bid=["']${id}["'])[^>]*/?>`, 'i'));
+    if (!rectMatch)
+        return null;
+    const rect = rectMatch[0];
+    const x = Number(getSvgAttribute(rect, 'x') ?? 0);
+    const y = Number(getSvgAttribute(rect, 'y') ?? 0);
+    const w = Number(getSvgAttribute(rect, 'width'));
+    const h = Number(getSvgAttribute(rect, 'height'));
+    if (![x, y, w, h].every(Number.isFinite))
+        return null;
+    return fromXywh(x, y, w, h);
+}
+function getSvgAttribute(element, name) {
+    return element.match(new RegExp(`\\b${name}\\s*=\\s*["']([^"']+)["']`, 'i'))?.[1];
+}
+async function assertPmtilesCliAvailable(signal) {
+    try {
+        await runPmtiles(['version'], signal);
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        throw new Error(`Offline map extraction requires the pmtiles CLI. Install it with "brew install pmtiles" and try again.`, { cause: error });
+    }
+}
+async function assertValidMapSource(mapSource) {
+    const source = mapSource.trim();
+    if (!source || source !== mapSource || source.startsWith('-')) {
+        throw new Error('Offline map --map-source must be an http(s)/file URL or absolute path.');
+    }
+    const path = await import('node:path');
+    if (path.isAbsolute(source) || path.win32.isAbsolute(source))
+        return;
+    try {
+        const url = new URL(source);
+        if (url.protocol === 'https:' || url.protocol === 'http:' || url.protocol === 'file:')
+            return;
+    }
+    catch {
+        // Fall through to the consistent validation error below.
+    }
+    throw new Error('Offline map --map-source must be an http(s)/file URL or absolute path.');
+}
+async function extractPmtiles(mapSource, bbox, signal) {
+    const { mkdtemp } = await import('node:fs/promises');
+    const { tmpdir } = await import('node:os');
+    const path = await import('node:path');
+    const { pathToFileURL } = await import('node:url');
+    throwIfAborted(signal);
+    const tempDir = await mkdtemp(path.join(tmpdir(), 'expofp-offline-map-'));
+    await registerTempDirExitCleanup(tempDir);
+    const targetPath = path.join(tempDir, 'basemap.pmtiles');
+    try {
+        throwIfAborted(signal);
+        await runPmtiles(['extract', mapSource, targetPath, `--bbox=${bbox.join(',')}`], signal);
+        return { url: pathToFileURL(targetPath), tempDir };
+    }
+    catch (error) {
+        await cleanupTempDir(tempDir);
+        throw error;
+    }
+}
+async function cleanupTempDir(tempDir) {
+    const { rm } = await import('node:fs/promises');
+    tempDirExitCleanups.get(tempDir)?.();
+    tempDirExitCleanups.delete(tempDir);
+    await rm(tempDir, { recursive: true, force: true });
+}
+async function registerTempDirExitCleanup(tempDir) {
+    if (typeof process === 'undefined' || !process.versions?.node)
+        return;
+    const { rmSync } = await import('node:fs');
+    const cleanup = () => rmSync(tempDir, { recursive: true, force: true });
+    tempDirExitCleanups.set(tempDir, () => process.removeListener('exit', cleanup));
+    process.once('exit', cleanup);
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error('Operation aborted.');
+}
+async function runPmtiles(args, signal) {
+    const { execFile } = await import('node:child_process');
+    await new Promise((resolvePromise, reject) => {
+        execFile('pmtiles', args, { signal }, (error, stdout, stderr) => {
+            if (stdout)
+                log(stdout.trim());
+            if (stderr)
+                log(stderr.trim());
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolvePromise();
+        });
+    });
+}
+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* getGlyphAssets() {
+    const encodedFontstack = encodeURIComponent(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`,
+        };
+    }
+}
+function createGlyphRanges(min, max) {
+    const ranges = [];
+    for (let start = min; start <= max; start += 256) {
+        ranges.push(`${start}-${start + 255}`);
+    }
+    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': '#f8f8f6' },
+            },
+            {
+                id: 'earth',
+                type: 'fill',
+                source: 'protomaps',
+                'source-layer': 'earth',
+                paint: { 'fill-color': '#f8f8f6' },
+            },
+            {
+                id: 'landuse',
+                type: 'fill',
+                source: 'protomaps',
+                'source-layer': 'landuse',
+                paint: { 'fill-color': '#eeeeea', 'fill-opacity': 0.7 },
+            },
+            {
+                id: 'water',
+                type: 'fill',
+                source: 'protomaps',
+                'source-layer': 'water',
+                paint: { 'fill-color': '#d8e7ef' },
+            },
+            {
+                id: 'buildings',
+                type: 'fill',
+                source: 'protomaps',
+                'source-layer': 'buildings',
+                minzoom: 13,
+                paint: { 'fill-color': '#dedbd4', 'fill-opacity': 0.65 },
+            },
+            {
+                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: ['in', ['get', 'kind'], ['literal', ['highway', 'major_road']]],
+                paint: {
+                    'line-color': '#ffffff',
+                    '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': '#707070',
+                    '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': '#545454',
+                    'text-halo-color': '#ffffff',
+                    'text-halo-width': 1.25,
+                },
+            },
+        ],
+    };
+}
+function fromXywh(x, y, w, h) {
+    return normalizeRect({ x1: x, y1: y, x2: x + w, y2: y + h });
+}
+function normalizeRect(rect) {
+    return {
+        x1: Math.min(rect.x1, rect.x2),
+        y1: Math.min(rect.y1, rect.y2),
+        x2: Math.max(rect.x1, rect.x2),
+        y2: Math.max(rect.y1, rect.y2),
+    };
+}
+function width(rect) {
+    return Math.abs(rect.x2 - rect.x1);
+}
+function height(rect) {
+    return Math.abs(rect.y2 - rect.y1);
+}
+function withPadding(rect, x, y = x) {
+    if (width(rect) < x * 2 || height(rect) < y * 2)
+        return rect;
+    const cx = (rect.x1 + rect.x2) / 2;
+    const cy = (rect.y1 + rect.y2) / 2;
+    const w = width(rect) - x * 2;
+    const h = height(rect) - y * 2;
+    return normalizeRect({ x1: cx - w / 2, y1: cy - h / 2, x2: cx + w / 2, y2: cy + h / 2 });
+}
+const earthRadius = 6371000.0;
+const minLongitude = -180.0;
+const maxLongitude = 180.0;
+const toRad = (value) => (value * Math.PI) / 180;
+const toDeg = (value) => (value * 180) / Math.PI;
+function convertLocalToGps(x, y, geoConfig) {
+    const diagAngle = -getAngle(geoConfig.p0, geoConfig.p2, {
+        x: geoConfig.p0.x + 10000,
+        y: geoConfig.p0.y,
+    });
+    const pointAngle = -getAngle(geoConfig.p0, { x, y }, { x: geoConfig.p0.x + 10000, y: geoConfig.p0.y });
+    const delta = pointAngle - diagAngle;
+    const diagLen = lineLength(geoConfig.p2, geoConfig.p0);
+    const pointLen = lineLength(geoConfig.p0, { x, y });
+    const perc = pointLen / diagLen;
+    const fullDistance = distance(geoConfig.p0.lat, geoConfig.p0.lng, geoConfig.p2.lat, geoConfig.p2.lng);
+    const pointDist = perc * fullDistance;
+    const baseBearing = bearing(geoConfig.p0.lat, geoConfig.p0.lng, geoConfig.p2.lat, geoConfig.p2.lng);
+    return destinationPoint(geoConfig.p0.lat, geoConfig.p0.lng, pointDist, baseBearing + delta);
+}
+function lineLength(p1, p2) {
+    return Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2);
+}
+function getAngle(centerPoint, startPoint, endPoint) {
+    const a = lineLength(startPoint, centerPoint);
+    const b = lineLength(endPoint, centerPoint);
+    const c = lineLength(startPoint, endPoint);
+    const cos = (a ** 2 + b ** 2 - c ** 2) / (2 * a * b);
+    const direction = getDirection(centerPoint, startPoint, endPoint);
+    return (direction * (Math.acos(Math.max(-1, Math.min(1, cos))) * 180)) / Math.PI || 0;
+}
+function getDirection(centerPoint, startPoint, endPoint) {
+    return (startPoint.x - centerPoint.x) * (endPoint.y - centerPoint.y) -
+        (startPoint.y - centerPoint.y) * (endPoint.x - centerPoint.x) <
+        0
+        ? -1
+        : 1;
+}
+function distance(lat1, lng1, lat2, lng2) {
+    const phi1 = toRad(lat1);
+    const phi2 = toRad(lat2);
+    const deltaPhi = toRad(lat2 - lat1);
+    const deltaLambda = toRad(lng2 - lng1);
+    const a = Math.sin(deltaPhi / 2) * Math.sin(deltaPhi / 2) +
+        Math.cos(phi1) * Math.cos(phi2) * Math.sin(deltaLambda / 2) * Math.sin(deltaLambda / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return earthRadius * c;
+}
+function bearing(lat1, lng1, lat2, lng2) {
+    const phi1 = toRad(lat1);
+    const phi2 = toRad(lat2);
+    const deltaLambda = toRad(lng2 - lng1);
+    const y = Math.sin(deltaLambda) * Math.cos(phi2);
+    const x = Math.cos(phi1) * Math.sin(phi2) - Math.sin(phi1) * Math.cos(phi2) * Math.cos(deltaLambda);
+    return (toDeg(Math.atan2(y, x)) + 360) % 360;
+}
+function destinationPoint(lat, lng, distanceMeters, pointBearing) {
+    const delta = distanceMeters / earthRadius;
+    const theta = toRad(pointBearing);
+    const phi1 = toRad(lat);
+    const lambda1 = toRad(lng);
+    const phi2 = Math.asin(Math.sin(phi1) * Math.cos(delta) + Math.cos(phi1) * Math.sin(delta) * Math.cos(theta));
+    let lambda2 = lambda1 +
+        Math.atan2(Math.sin(theta) * Math.sin(delta) * Math.cos(phi1), Math.cos(delta) - Math.sin(phi1) * Math.sin(phi2));
+    let longitude = toDeg(lambda2);
+    if (longitude < minLongitude || longitude > maxLongitude) {
+        lambda2 = ((lambda2 + 3 * Math.PI) % (2 * Math.PI)) - Math.PI;
+        longitude = toDeg(lambda2);
+    }
+    return [longitude, toDeg(phi2)];
+}

package/dist/lib/offlinize-assets-in-place.js

@@ -9,7 +9,6 @@ const CSS_ASSET_TEXT_SUFFIX = 'CssAssetText';
 const LEGACY_ASSET_URL_FIELDS = ['logo', 'gallery', 'leadingImageUrl', 'photoFile', 'logoFile'];
 const LEGACY_EXHIBITOR_LOGO_VARIANTS = ['__small', '__tiny'];
 const LEGACY_CSS_ASSET_TEXT_FIELD = 'customCss';
-// TODO: add AbortSignal support
 export async function offlinizeAssetsInPlace(data, opts) {
     const { legacyDataUrlBase } = opts;
     const fetches = [];

package/dist/lib/types.d.ts

@@ -10,5 +10,10 @@ export interface LocalDataText {
 export interface OfflineOptions {
     signal?: AbortSignal;
     runtimeBaseUrl: string;
+    offlineMap?: OfflineMapOptions;
+    inferOfflineMap?: boolean;
+}
+export interface OfflineMapOptions {
+    mapSource?: string;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/offline",
-  "version": "3.3.8",
+  "version": "3.4.0",
   "type": "module",
   "description": "CLI tool for creating offline copies of ExpoFP floor plans",
   "homepage": "https://developer.expofp.com/",
@@ -31,9 +31,9 @@
   "dependencies": {
     "debug": "^4.4.3",
     "tslib": "^2.3.0",
-    "@expofp/data": "3.3.8",
-    "@expofp/floorplan": "3.3.8",
-    "@expofp/resolve": "3.3.8",
-    "@expofp/utils": "3.3.8"
+    "@expofp/data": "3.4.0",
+    "@expofp/floorplan": "3.4.0",
+    "@expofp/resolve": "3.4.0",
+    "@expofp/utils": "3.4.0"
   }
 }