@expofp/offline 3.0.0-alpha.3

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,66 @@
+#!/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)
+  -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' },
+            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);
+    }
+    console.log(`Resolving @expofp/floorplan runtime...`);
+    const runtimeBaseUrl = await resolveFloorplanDir();
+    console.log(`Creating offline ZIP from ${manifestUrl}...`);
+    await saveOfflineZip({ $ref: manifestUrl }, outputPath, { runtimeBaseUrl });
+    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/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,27 @@
+import { readFileFromUrl } from '@expofp/utils';
+import debug from 'debug';
+const log = debug('efp:offline:data-to-files');
+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 });
+            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/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,102 @@
+import { resolve } from '@expofp/resolve';
+import { deepClone, makeLocalPath, niceFetch } from '@expofp/utils';
+import debug from 'debug';
+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;
+}
+/**
+ * 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 niceFetch(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)) {
+        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,43 @@
+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 { 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}`);
+    if (manifest.legacyDataUrlBase) {
+        yield* generateOfflineDataLegacy(manifest, options);
+    }
+    // transform entire manifest + assets
+    const data = await offlinizeAssetsInPlace(manifest, options);
+    for (const d of data) {
+        yield d;
+    }
+    // add runtime files
+    const { entry } = yield* generateRuntimeFilesData(options.runtimeBaseUrl);
+    // generate index.html
+    yield {
+        text: getIndexHtml(entry, manifest),
+        targetFilePath: './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);
+}
+function getIndexHtml(entry, manifest) {
+    return `\
+<!DOCTYPE html>
+<script type="module">
+  import { load } from ${JSON.stringify(entry)};
+  await load(${JSON.stringify(manifest)});
+  console.info('loaded');
+</script>
+`;
+}

package/dist/lib/generate-runtime-files-data.d.ts

@@ -0,0 +1,5 @@
+import type { LocalDataFetch } from './types.js';
+export declare function generateRuntimeFilesData(runtimeBaseUrl: string): AsyncGenerator<LocalDataFetch, {
+    entry: string;
+}, void>;
+//# sourceMappingURL=generate-runtime-files-data.d.ts.map

package/dist/lib/generate-runtime-files-data.js

@@ -0,0 +1,16 @@
+import { importJsonModule } from '@expofp/utils';
+import debug from 'debug';
+const log = debug('efp:offline:generate-runtime-files-data');
+export async function* generateRuntimeFilesData(runtimeBaseUrl) {
+    const bundleJsonUrl = new URL('bundle.json', runtimeBaseUrl).href;
+    const bundleJson = await importJsonModule(bundleJsonUrl);
+    log(`Generating runtime files from ${bundleJsonUrl}, ${bundleJson.files.length} files found`);
+    const basePath = './runtime/';
+    for (const file of bundleJson.files) {
+        yield {
+            url: new URL(file.file, runtimeBaseUrl),
+            targetFilePath: `${basePath}${file.file}`,
+        };
+    }
+    return { entry: `${basePath}${bundleJson.entry}` };
+}

package/dist/lib/offlinize-asset-url.d.ts

@@ -0,0 +1,6 @@
+import type { LocalDataFetch } from './types.js';
+export declare function offlinizeAssetUrl(url: URL, variants?: string[]): Promise<{
+    url: string;
+    assets: LocalDataFetch[];
+}>;
+//# sourceMappingURL=offlinize-asset-url.d.ts.map

package/dist/lib/offlinize-asset-url.js

@@ -0,0 +1,35 @@
+import { makeLocalPath } from '@expofp/utils';
+import debug from 'debug';
+const log = debug('efp:offline:offlinize-asset-url');
+export async function offlinizeAssetUrl(url, variants = []) {
+    // main
+    const targetFilePath = await makeLocalPath(url);
+    const assets = [];
+    log(`Offlinized asset: ${url.href} -> ${targetFilePath}`);
+    assets.push({ url, targetFilePath });
+    // extra variants (don’t mutate JSON; just add extra fetches)
+    for (const variant of variants) {
+        const variantUrl = withVariant(url, variant);
+        const variantTargetFilePath = await makeLocalPath(url, variant);
+        assets.push({ url: variantUrl, targetFilePath: variantTargetFilePath });
+        log(`Offlinized variant: ${variantUrl.href} -> ${variantTargetFilePath}`);
+    }
+    return {
+        url: targetFilePath,
+        assets,
+    };
+    function withVariant(url, variant) {
+        const u = new URL(url); // clone
+        const pathname = u.pathname;
+        const lastSlash = pathname.lastIndexOf('/');
+        const filename = lastSlash >= 0 ? pathname.slice(lastSlash + 1) : pathname;
+        const dot = filename.lastIndexOf('.');
+        const nextFilename = dot > 0
+            ? `${filename.slice(0, dot)}${variant}${filename.slice(dot)}`
+            : `${filename}${variant}`;
+        u.pathname =
+            lastSlash >= 0 ? `${pathname.slice(0, lastSlash + 1)}${nextFilename}` : nextFilename;
+        // IMPORTANT: do not touch u.search
+        return u;
+    }
+}

package/dist/lib/offlinize-assets-in-place.d.ts

@@ -0,0 +1,6 @@
+import type { LocalData } from './types.js';
+export declare function offlinizeAssetsInPlace(data: unknown, opts: {
+    legacyDataUrlBase?: string;
+    signal?: AbortSignal;
+}): Promise<LocalData[]>;
+//# sourceMappingURL=offlinize-assets-in-place.d.ts.map

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

@@ -0,0 +1,139 @@
+import { makeLocalPath, niceFetch } from '@expofp/utils';
+import debug from 'debug';
+import { offlinizeAssetUrl } from './offlinize-asset-url.js';
+import { offlinizeCssAssetText } from './offlinize-css-asset-text.js';
+const log = debug('efp:offline:offlinize-assets-in-place');
+const ASSET_URL_SUFFIX = 'AssetUrl';
+const CSS_ASSET_TEXT_SUFFIX = 'CssAssetText';
+// Legacy fields, remove in future versions
+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 = [];
+    const fetchedUrls = new Map(); // targetPath to LocalData
+    const mergeFetches = (newFetches) => {
+        // push only new fetches
+        // error if duplicate targetFilePath with different content
+        for (const nf of newFetches) {
+            const existing = fetchedUrls.get(nf.targetFilePath);
+            // test only if both have url (i.e., are not JSON)
+            if (existing && 'url' in nf && 'url' in existing) {
+                const isSame = existing.url.href === nf.url.href;
+                if (!isSame) {
+                    throw new Error(`Conflicting fetch for targetFilePath ${nf.targetFilePath}: ${existing.url.href} vs ${nf.url.href}`);
+                }
+            }
+            else {
+                fetchedUrls.set(nf.targetFilePath, nf);
+                fetches.push(nf);
+            }
+        }
+    };
+    const processedRefs = new Map(); // Cache for $ref documents
+    const isPlainObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+    const toAbsoluteUrl = (value) => legacyDataUrlBase ? new URL(value, legacyDataUrlBase) : new URL(value);
+    const enableLegacy = !!legacyDataUrlBase;
+    async function walk(node) {
+        if (Array.isArray(node)) {
+            for (let i = 0; i < node.length; i++) {
+                const el = node[i];
+                if (el && typeof el === 'object') {
+                    await walk(el);
+                }
+            }
+            return;
+        }
+        if (!isPlainObject(node))
+            return;
+        // Handle $ref field
+        if ('$ref' in node && typeof node.$ref === 'string') {
+            const refValue = node.$ref;
+            if (refValue) {
+                const url = toAbsoluteUrl(refValue);
+                const fragment = url.hash; // Preserve JSON pointer fragment
+                // Create URL without fragment for fetching
+                const urlWithoutFragment = new URL(url.href);
+                urlWithoutFragment.hash = '';
+                const urlKey = urlWithoutFragment.href;
+                const targetFilePath = await makeLocalPath(urlWithoutFragment);
+                // Update $ref to local path with preserved fragment
+                node.$ref = targetFilePath + fragment;
+                // Check if we've already processed this $ref URL
+                if (!processedRefs.has(urlKey)) {
+                    // Mark as fetched to prevent duplicates
+                    log(`Offlinizing $ref: ${refValue} -> ${targetFilePath}${fragment}`);
+                    // Fetch and recursively process the referenced document
+                    const response = await niceFetch(urlKey, { signal: opts.signal });
+                    if (response.ok) {
+                        const referencedData = await response.json();
+                        processedRefs.set(urlKey, referencedData);
+                        log(`Processing referenced document: ${urlKey}`);
+                        // Recursively offlinize assets in the referenced document
+                        const refFetches = await offlinizeAssetsInPlace(referencedData, opts);
+                        fetches.push(...refFetches);
+                        // Store the transformed referenced data as a separate JSON file
+                        fetches.push({
+                            targetFilePath,
+                            text: JSON.stringify(referencedData, null, 2),
+                        });
+                    }
+                    else {
+                        throw new Error(`Failed to fetch $ref URL: ${urlKey}, status: ${response.status}`);
+                    }
+                }
+                else {
+                    log(`Skipping already processed $ref: ${refValue}`);
+                }
+            }
+        }
+        for (const key of Object.keys(node)) {
+            const value = node[key];
+            // CSS asset text handling
+            if (typeof value === 'string' &&
+                (key.endsWith(CSS_ASSET_TEXT_SUFFIX) || key === LEGACY_CSS_ASSET_TEXT_FIELD)) {
+                const { css, assets } = await offlinizeCssAssetText(value);
+                node[key] = css;
+                mergeFetches(assets);
+                continue;
+            }
+            // URL asset handling
+            if (typeof value === 'string' && key.endsWith(ASSET_URL_SUFFIX)) {
+                const { url: localUrl, assets } = await offlinizeAssetUrl(toAbsoluteUrl(value));
+                node[key] = localUrl;
+                mergeFetches(assets);
+                continue;
+            }
+            // Legacy asset URL fields handling
+            if (enableLegacy && LEGACY_ASSET_URL_FIELDS.includes(key) && typeof value === 'string') {
+                let variants = [];
+                if (key === 'logo' || (value.includes('exhibitor/') && value.includes('/media/'))) {
+                    variants = LEGACY_EXHIBITOR_LOGO_VARIANTS;
+                }
+                const { url: localUrl, assets } = await offlinizeAssetUrl(toAbsoluteUrl(value), variants);
+                node[key] = localUrl;
+                mergeFetches(assets);
+                continue;
+            }
+            // Legacy asset URL fields handling for arrays
+            if (enableLegacy && LEGACY_ASSET_URL_FIELDS.includes(key) && Array.isArray(value)) {
+                for (let i = 0; i < value.length; i++) {
+                    const el = value[i];
+                    if (typeof el === 'string') {
+                        const { url: localUrl, assets } = await offlinizeAssetUrl(toAbsoluteUrl(el));
+                        value[i] = localUrl;
+                        mergeFetches(assets);
+                    }
+                }
+                continue;
+            }
+            if (value && typeof value === 'object') {
+                await walk(value);
+            }
+        }
+    }
+    await walk(data);
+    return fetches;
+}

package/dist/lib/offlinize-css-asset-text.d.ts

@@ -0,0 +1,6 @@
+import type { LocalDataFetch } from './types.js';
+export declare function offlinizeCssAssetText(css: string): Promise<{
+    css: string;
+    assets: LocalDataFetch[];
+}>;
+//# sourceMappingURL=offlinize-css-asset-text.d.ts.map

package/dist/lib/offlinize-css-asset-text.js

@@ -0,0 +1,52 @@
+import { makeLocalPath } from '@expofp/utils';
+import debug from 'debug';
+const log = debug('efp:offline:offlinize-css-asset-text');
+export async function offlinizeCssAssetText(css) {
+    const assets = [];
+    const urlRegex = /url\(\s*(['"]?)(.*?)\1\s*\)/g;
+    // Collect all URL matches first
+    const matches = [];
+    let regexMatch;
+    while ((regexMatch = urlRegex.exec(css)) !== null) {
+        matches.push({
+            match: regexMatch[0],
+            quote: regexMatch[1],
+            urlString: regexMatch[2],
+            index: regexMatch.index,
+        });
+    }
+    // Process all URLs and await their local paths
+    const replacements = await Promise.all(matches.map(async ({ match, quote, urlString }) => {
+        // Do not process data: URLs
+        if (urlString.startsWith('data:')) {
+            return { original: match, replacement: match };
+        }
+        // Only process if it's a valid URL
+        try {
+            const url = new URL(urlString);
+            const localPath = await makeLocalPath(url);
+            assets.push({
+                url,
+                targetFilePath: localPath,
+            });
+            log(`Offlinized CSS asset: ${urlString} -> ${localPath}`);
+            return {
+                original: match,
+                replacement: `url(${quote}${localPath}${quote})`,
+            };
+        }
+        catch {
+            console.warn(`Invalid URL in CSS: ${urlString}`);
+            return { original: match, replacement: match };
+        }
+    }));
+    // Apply all replacements
+    let processedCss = css;
+    for (const { original, replacement } of replacements) {
+        processedCss = processedCss.replace(original, replacement);
+    }
+    return {
+        css: processedCss,
+        assets,
+    };
+}

package/dist/lib/resolve-floorplan-dir.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Locates the `@expofp/floorplan` browser build directory on disk and
+ * returns a `file://` URL string (with trailing slash) pointing at it.
+ *
+ * Throws if the package or its `bundle.json` cannot be found.
+ */
+export declare function resolveFloorplanDir(): Promise<string>;
+//# sourceMappingURL=resolve-floorplan-dir.d.ts.map

package/dist/lib/resolve-floorplan-dir.js

@@ -0,0 +1,34 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { importFsPromises } from '@expofp/utils';
+/**
+ * Locates the `@expofp/floorplan` browser build directory on disk and
+ * returns a `file://` URL string (with trailing slash) pointing at it.
+ *
+ * Throws if the package or its `bundle.json` cannot be found.
+ */
+export async function resolveFloorplanDir() {
+    const require = createRequire(import.meta.url);
+    let pkgJsonPath;
+    try {
+        pkgJsonPath = require.resolve('@expofp/floorplan/package.json');
+    }
+    catch {
+        throw new Error('Could not find @expofp/floorplan. ' +
+            'Ensure it is installed (it should be a dependency of @expofp/offline).');
+    }
+    const pkgDir = path.dirname(pkgJsonPath);
+    const browserDir = path.join(pkgDir, 'dist', 'browser');
+    const bundleJsonPath = path.join(browserDir, 'bundle.json');
+    const fs = await importFsPromises();
+    try {
+        await fs.access(bundleJsonPath);
+    }
+    catch {
+        throw new Error(`Found @expofp/floorplan at ${pkgDir} but dist/browser/bundle.json is missing. ` +
+            'Ensure the package has been built (pnpm nx build-browser @expofp/floorplan).');
+    }
+    // Return file:// URL with trailing slash so new URL(file, base) works
+    return pathToFileURL(browserDir).href + '/';
+}

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

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

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

@@ -0,0 +1,21 @@
+import { importFsPromises } from '@expofp/utils';
+import debug from 'debug';
+import { buildOfflineZip } from './generate-offline-data.js';
+const log = debug('efp:offline:save-offline-zip');
+export async function saveOfflineZip(manifest, path, options) {
+    if (typeof process === 'undefined' || !process.versions?.node) {
+        throw new Error('saveOfflineZip can only be used in a Node.js environment');
+    }
+    if (!path) {
+        throw new Error('Path is required to save the ZIP file');
+    }
+    if (!path.endsWith('.zip')) {
+        throw new Error('The specified path must end with .zip');
+    }
+    log('Saving offline ZIP bundle to', path);
+    const blob = await buildOfflineZip(manifest, options);
+    const arrayBuffer = await blob.arrayBuffer();
+    const fs = await importFsPromises();
+    await fs.writeFile(path, Buffer.from(arrayBuffer));
+    log('Saved offline ZIP bundle to', path);
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,14 @@
+export type LocalData = LocalDataFetch | LocalDataText;
+export interface LocalDataFetch {
+    url: URL;
+    targetFilePath: string;
+}
+export interface LocalDataText {
+    text: string;
+    targetFilePath: string;
+}
+export interface OfflineOptions {
+    signal?: AbortSignal;
+    runtimeBaseUrl: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@expofp/offline",
+  "version": "3.0.0-alpha.3",
+  "type": "module",
+  "description": "CLI tool for creating offline copies of ExpoFP floor plans",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@expofp/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "expofp-offline": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.map"
+  ],
+  "dependencies": {
+    "debug": "^4.4.3",
+    "tslib": "^2.3.0",
+    "@expofp/data": "3.0.0-alpha.3",
+    "@expofp/floorplan": "3.0.0-alpha.3",
+    "@expofp/resolve": "3.0.0-alpha.3",
+    "@expofp/utils": "3.0.0-alpha.3"
+  }
+}