@expofp/offline 0.0.0-experimental.d269d30

package/README.md

@@ -0,0 +1,49 @@
+## Offline: generating ZIPs
+
+The `@expofp/offline` package provides a CLI (`expofp-offline`) that creates self-contained ZIP archives of floor plans. The ZIP can be opened in any browser without internet connectivity.
+
+### Usage
+
+```bash
+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`, `@next`, `@customer1`, `@3.0.0-alpha.9`).
+
+| Option            | Description                                        | Default                                |
+| ----------------- | -------------------------------------------------- | -------------------------------------- |
+| `-o`, `--output`  | Output file path                                   | `offline.zip`                          |
+| `--offline-map`   | Include an offline MapLibre basemap                |                                        |
+| `--map-source`    | Global PMTiles source URL/path for `--offline-map` | Latest available Protomaps daily build |
+| `-h`, `--help`    | Show help message                                  |                                        |
+| `-v`, `--version` | Show version number                                |                                        |
+
+### Example
+
+```bash
+npx @expofp/offline@next https://demo.expofp.com/manifest.json -o offline.zip
+```
+
+With an offline MapLibre basemap:
+
+```bash
+npx @expofp/offline@next https://demo.expofp.com/manifest.json \
+  --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.
+Pass `--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:
+
+```bash
+DEBUG=efp:offline:* npx @expofp/offline https://...
+```

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { parseArgs } from 'node:util';
+import { resolveFloorplanDir } from './lib/resolve-floorplan-dir.js';
+import { saveOfflineZip } from './lib/save-offline-zip.js';
+const HELP = `
+Usage: expofp-offline <manifest-url> [options]
+
+Create an offline ZIP archive of an ExpoFP floor plan.
+
+Arguments:
+  manifest-url   URL to the floor plan manifest JSON
+
+Options:
+  -o, --output   Output file path (default: offline.zip)
+      --offline-map
+                Include an offline MapLibre basemap in the ZIP
+      --map-source <source>
+                Global PMTiles source URL/path used with --offline-map
+                Defaults to the latest available Protomaps daily build
+  -h, --help     Show this help message
+  -v, --version  Show version number
+`.trim();
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            output: { type: 'string', short: 'o', default: 'offline.zip' },
+            'offline-map': { type: 'boolean', default: false },
+            'map-source': { type: 'string' },
+            help: { type: 'boolean', short: 'h', default: false },
+            version: { type: 'boolean', short: 'v', default: false },
+        },
+    });
+    if (values.help) {
+        console.log(HELP);
+        process.exit(0);
+    }
+    if (values.version) {
+        const require = createRequire(import.meta.url);
+        const pkg = require('../package.json');
+        console.log(pkg.version);
+        process.exit(0);
+    }
+    const manifestUrl = positionals[0];
+    if (!manifestUrl) {
+        console.error('Error: manifest URL is required.\n');
+        console.error(HELP);
+        process.exit(1);
+    }
+    // Validate URL
+    try {
+        new URL(manifestUrl);
+    }
+    catch {
+        console.error(`Error: "${manifestUrl}" is not a valid URL.\n`);
+        process.exit(1);
+    }
+    const outputPath = values.output;
+    if (!outputPath.endsWith('.zip')) {
+        console.error('Error: output path must end with .zip\n');
+        process.exit(1);
+    }
+    let offlineMap;
+    if (values['offline-map']) {
+        offlineMap = { mapSource: values['map-source'] };
+    }
+    console.log(`Resolving @expofp/floorplan runtime...`);
+    const runtimeBaseUrl = await resolveFloorplanDir();
+    console.log(`Creating offline ZIP from ${manifestUrl}...`);
+    await saveOfflineZip({ $ref: manifestUrl }, outputPath, {
+        runtimeBaseUrl,
+        offlineMap,
+    });
+    console.log(`Done! Offline ZIP saved to ${outputPath}`);
+}
+main().catch((err) => {
+    console.error('Error:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { downloadOfflineZip } from './lib/download-offline-zip.js';
+export { buildOfflineZip } from './lib/generate-offline-data.js';
+export { saveOfflineZip } from './lib/save-offline-zip.js';
+export type { OfflineOptions } from './lib/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+export { downloadOfflineZip } from './lib/download-offline-zip.js';
+export { buildOfflineZip } from './lib/generate-offline-data.js';
+export { saveOfflineZip } from './lib/save-offline-zip.js';

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

@@ -0,0 +1,6 @@
+export interface TimedAbortSignal {
+    signal: AbortSignal;
+    dispose(): void;
+}
+export declare function withTimeoutSignal(signal: AbortSignal | undefined, timeoutMs: number): TimedAbortSignal;
+//# sourceMappingURL=abort-signal.d.ts.map

package/dist/lib/abort-signal.js

@@ -0,0 +1,20 @@
+const noop = () => undefined;
+export function withTimeoutSignal(signal, timeoutMs) {
+    const controller = new AbortController();
+    if (signal?.aborted) {
+        controller.abort(signal.reason);
+        return { signal: controller.signal, dispose: noop };
+    }
+    const timeout = setTimeout(() => {
+        controller.abort(new Error(`Operation timed out after ${timeoutMs}ms.`));
+    }, timeoutMs);
+    const abortFromParent = () => controller.abort(signal?.reason);
+    signal?.addEventListener('abort', abortFromParent, { once: true });
+    return {
+        signal: controller.signal,
+        dispose() {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', abortFromParent);
+        },
+    };
+}

package/dist/lib/data-to-files.d.ts

@@ -0,0 +1,8 @@
+import type { LocalData } from './types.js';
+export declare function dataToFiles(data: AsyncIterable<LocalData>, options?: {
+    signal?: AbortSignal;
+}): AsyncIterable<{
+    path: string;
+    data: Uint8Array;
+}>;
+//# sourceMappingURL=data-to-files.d.ts.map

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

@@ -0,0 +1,36 @@
+import { readFileFromUrl } from '@expofp/utils';
+import debug from 'debug';
+import { withTimeoutSignal } 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 fetchSignal = withTimeoutSignal(options?.signal, FILE_FETCH_TIMEOUT_MS);
+            let response;
+            try {
+                response = await readFileFromUrl(file.url, { signal: fetchSignal.signal });
+            }
+            finally {
+                fetchSignal.dispose();
+            }
+            if (!response.ok) {
+                console.warn(`Skipping file ${file.url} as it could not be downloaded`);
+            }
+            else {
+                log('Bundling file from url', file.targetFilePath);
+                yield {
+                    path: file.targetFilePath,
+                    data: response.data,
+                };
+            }
+        }
+        else {
+            log('Bundling text file', file.targetFilePath);
+            yield {
+                path: file.targetFilePath,
+                data: new TextEncoder().encode(file.text),
+            };
+        }
+    }
+}

package/dist/lib/download-offline-zip.d.ts

@@ -0,0 +1,4 @@
+import type { Manifest, Ref } from '@expofp/data';
+import type { OfflineOptions } from './types.js';
+export declare function downloadOfflineZip(manifest: Manifest | Ref<Manifest>, options: OfflineOptions): Promise<void>;
+//# sourceMappingURL=download-offline-zip.d.ts.map

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

@@ -0,0 +1,12 @@
+import { buildOfflineZip } from './generate-offline-data.js';
+export async function downloadOfflineZip(manifest, options) {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        throw new Error('downloadOfflineZip can only be used in a browser environment');
+    }
+    const blob = await buildOfflineZip(manifest, options);
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(blob);
+    a.download = 'offline.zip';
+    a.click();
+    URL.revokeObjectURL(a.href);
+}

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,50 @@
+import { fetchWithRetry } from '@expofp/utils';
+import { withTimeoutSignal } 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 = withTimeoutSignal(signal, SCRIPT_FETCH_TIMEOUT_MS);
+    let code;
+    try {
+        const response = await fetchWithRetry(url, { signal: fetchSignal.signal });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch script (HTTP ${response.status}): ${url}`);
+        }
+        code = await response.text();
+    }
+    finally {
+        fetchSignal.dispose();
+    }
+    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.d.ts

@@ -0,0 +1,6 @@
+import type { Manifest } from '@expofp/data';
+import type { LocalData } from './types.js';
+export declare function generateOfflineDataLegacy(manifest: Manifest, options: {
+    signal?: AbortSignal;
+}): AsyncIterable<LocalData>;
+//# sourceMappingURL=generate-offline-data-legacy.d.ts.map

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

@@ -0,0 +1,85 @@
+import { resolve } from '@expofp/resolve';
+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) {
+    if (!manifest.legacyDataUrlBase) {
+        throw new Error('Manifest does not have legacyDataUrlBase');
+    }
+    const { signal } = options;
+    const legacyDataUrlBase = manifest.legacyDataUrlBase;
+    const version = await resolve(manifest.legacyDataVersion)
+        .then((json) => json?.version)
+        .catch(() => {
+        log('Could not resolve legacyDataVersion, proceeding without it');
+        return Date.now().toString();
+    });
+    const localDataUrlBase = await makeLocalPath(new URL(legacyDataUrlBase));
+    // data.js — execute in isolated vm context to extract __data
+    const dataCtx = await execScriptInSandbox(`${legacyDataUrlBase}data.js?v=${version}`, signal);
+    const data = deepClone(dataCtx.__data);
+    yield* offlinizeDataJs(data, legacyDataUrlBase, signal);
+    // Asset paths in data are absolute (e.g. "https-demo-expofp-com/data/exhibitors/...").
+    // The runtime resolves them relative to legacyDataUrlBase, so strip that prefix
+    // to avoid doubling (e.g. "base/base/exhibitors/...").
+    stripPathPrefix(data, localDataUrlBase);
+    yield {
+        text: `__data = ${JSON.stringify(data, null, 2)};`,
+        targetFilePath: `${localDataUrlBase}data.js`,
+    };
+    // wf.data.js
+    const wfDataUrl = `${legacyDataUrlBase}wf.data.js?v=${version}`;
+    yield { url: new URL(wfDataUrl), targetFilePath: `${localDataUrlBase}wf.data.js` };
+    // fp.svg.js — execute in isolated vm context to extract __fpLayers
+    const svgCtx = await execScriptInSandbox(`${legacyDataUrlBase}fp.svg.js?v=${version}`, signal);
+    yield {
+        url: new URL(`${legacyDataUrlBase}fp.svg.js?v=${version}`),
+        targetFilePath: `${localDataUrlBase}fp.svg.js`,
+    };
+    // fp.svg.{layer}.js
+    const fpLayers = svgCtx.__fpLayers || [];
+    for (const layer of fpLayers) {
+        const layerFile = `fp.svg.${layer.name}.js`;
+        const layerUrl = `${legacyDataUrlBase}${layerFile}?v=${version}`;
+        yield { url: new URL(layerUrl), targetFilePath: `${localDataUrlBase}${layerFile}` };
+    }
+    manifest.legacyDataUrlBase = localDataUrlBase;
+}
+/** Strip a path prefix from all string values in a data tree (in place). */
+function stripPathPrefix(node, prefix) {
+    if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+            if (typeof node[i] === 'string' && node[i].startsWith(prefix)) {
+                node[i] = node[i].slice(prefix.length);
+            }
+            else if (node[i] && typeof node[i] === 'object') {
+                stripPathPrefix(node[i], prefix);
+            }
+        }
+        return;
+    }
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    const obj = node;
+    for (const key of Object.keys(obj)) {
+        const val = obj[key];
+        if (typeof val === 'string' && val.startsWith(prefix)) {
+            obj[key] = val.slice(prefix.length);
+        }
+        else if (val && typeof val === 'object') {
+            stripPathPrefix(val, prefix);
+        }
+    }
+}
+async function* offlinizeDataJs(data, legacyDataUrlBase, signal) {
+    if (data.customCss) {
+        console.warn('data.customCss is deprecated, renaming to data.customCssAssetText');
+        data.customCssAssetText = data.customCss;
+        delete data.customCss;
+    }
+    const fetches = await offlinizeAssetsInPlace(data, { legacyDataUrlBase, signal });
+    yield* fetches;
+}

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

@@ -0,0 +1,6 @@
+import type { Manifest, Ref } from '@expofp/data';
+import type { LocalData, OfflineOptions } from './types.js';
+export declare function generateOfflineData(inputManifest: Manifest | Ref<Manifest>, options: OfflineOptions): AsyncIterable<LocalData, void>;
+/** Build a complete offline ZIP archive from a manifest. */
+export declare function buildOfflineZip(manifest: Manifest | Ref<Manifest>, options: OfflineOptions): Promise<Blob>;
+//# sourceMappingURL=generate-offline-data.d.ts.map

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

@@ -0,0 +1,90 @@
+import { resolve } from '@expofp/resolve';
+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, 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));
+    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 = options.offlineMap
+        ? await validateOfflineMapOptions(options.offlineMap)
+        : undefined;
+    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) {
+        yield { ...d, targetFilePath: prefixPath(d.targetFilePath) };
+    }
+    // add runtime files — manually iterate to prefix paths while capturing return value
+    const runtimeGen = generateRuntimeFilesData(options.runtimeBaseUrl);
+    let runtimeResult = await runtimeGen.next();
+    while (!runtimeResult.done) {
+        yield {
+            ...runtimeResult.value,
+            targetFilePath: prefixPath(runtimeResult.value.targetFilePath),
+        };
+        runtimeResult = await runtimeGen.next();
+    }
+    const { entry } = runtimeResult.value;
+    // generate index.html
+    yield {
+        text: getIndexHtml(entry, manifest, maplibre),
+        targetFilePath: prefixPath('index.html'),
+    };
+}
+/** Build a complete offline ZIP archive from a manifest. */
+export async function buildOfflineZip(manifest, options) {
+    const data = generateOfflineData(manifest, options);
+    const files = dataToFiles(data, { signal: options.signal });
+    return await buildZipArchive(files);
+}
+/** 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, maplibre) {
+    // entry is "./runtime/index.js", derive the runtime base path
+    const runtimeBase = entry.slice(0, entry.lastIndexOf('/') + 1);
+    return `\
+<!DOCTYPE html>
+<script src="${runtimeBase}${COMPAT_HELPER}"></script>
+<script type="module">
+  import { load } from ${JSON.stringify(entry)};
+  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,16 @@
+import type { Manifest } from '@expofp/data';
+import type { MaplibreOptions } from '@expofp/floorplan';
+import type { LocalData, OfflineMapOptions } from './types.js';
+type ValidatedOfflineMapOptions = OfflineMapOptions & {
+    mapSource: string;
+};
+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): Promise<ValidatedOfflineMapOptions>;
+export {};
+//# sourceMappingURL=generate-offline-map-data.d.ts.map