@expofp/offline 0.0.0-experimental.d269d30

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

@@ -0,0 +1,463 @@
+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'],
+];
+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.signal);
+        log('Extracting PMTiles for bbox', bbox.join(','));
+        const pmtilesFile = await extractPmtiles(options.mapSource, bbox);
+        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) {
+    if (!options.mapSource) {
+        console.log('Looking for latest Protomaps map source...');
+        options.mapSource = await resolveDefaultMapSource();
+    }
+    await assertValidMapSource(options.mapSource);
+    console.log(`Using map source ${options.mapSource}`);
+    await assertPmtilesCliAvailable();
+    return options;
+}
+async function resolveDefaultMapSource() {
+    for (let dayOffset = 0; dayOffset < DEFAULT_MAP_SOURCE_LOOKBACK_DAYS; dayOffset++) {
+        const source = createDefaultMapSource(dayOffset);
+        const response = await fetch(source, { method: 'HEAD' });
+        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, signal) {
+    const version = await resolve(manifest.legacyDataVersion)
+        .then((json) => json?.version)
+        .catch(() => Date.now().toString());
+    const ctx = await execScriptInSandbox(`${manifest.legacyDataUrlBase}fp.svg.js?v=${version}`, 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];
+}
+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() {
+    try {
+        await runPmtiles(['version']);
+    }
+    catch (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) {
+    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');
+    const tempDir = await mkdtemp(path.join(tmpdir(), 'expofp-offline-map-'));
+    const targetPath = path.join(tempDir, 'basemap.pmtiles');
+    try {
+        await runPmtiles(['extract', mapSource, targetPath, `--bbox=${bbox.join(',')}`]);
+        return { url: pathToFileURL(targetPath), tempDir };
+    }
+    catch (error) {
+        await cleanupTempDir(tempDir);
+        throw error;
+    }
+}
+async function cleanupTempDir(tempDir) {
+    const { rm } = await import('node:fs/promises');
+    await rm(tempDir, { recursive: true, force: true });
+}
+async function runPmtiles(args) {
+    const { execFile } = await import('node:child_process');
+    await new Promise((resolvePromise, reject) => {
+        execFile('pmtiles', args, (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/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 { importJson } 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 importJson(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 { fetchWithRetry, makeLocalPath } 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 fetchWithRetry(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