@expofp/loader 1.0.65 → 1.0.77

package/dist/esm/offline/index.js

@@ -1,3 +1,7 @@
+export async function makeOffline(manifest) {
+    const { makeOffline } = await import('./makeOffline');
+    return await makeOffline(manifest);
+}
 export async function makeOfflineBundle(manifest) {
     const { makeOfflineBundle } = await import('./makeOfflineBundle');
     return await makeOfflineBundle(manifest);

package/dist/esm/offline/makeOffline.js

@@ -1,9 +1,10 @@
 import debug from 'debug';
 import { canResolve, parseRefValue, resolverResolve, } from '../resolve';
 import { resolvers } from '../resolvers';
-import { createMergedObjectWithOverridenNonRefProps, deepClone } from '../shared';
+import { createMergedObjectWithOverridenNonRefProps, deepClone, shallowClone } from '../shared';
 import { makeTargetPathFromUrl, makeUniqueJsonTargetPathFromString } from './tools';
 const log = debug('efp:loader:makeOffline');
+const logWalk = debug('efp:loader:makeOffline:walk');
 export async function makeOffline(manifest) {
     log('makeOffline', manifest);
     // if (typeof manifest !== 'object' || manifest === null) {
@@ -37,6 +38,7 @@ async function* makeOfflineInternal(manifest) {
     return parent.manifest;
     async function* walk(node, key) {
         // console.log('walk', node, key, node[key]);
+        logWalk(key, node[key]);
         // let node[key] = node[key];
         if (typeof node[key] !== 'object' || node[key] === null) {
             return;
@@ -45,6 +47,7 @@ async function* makeOfflineInternal(manifest) {
         // const usedResolvers = new Set<Resolver>();
         // do {
         if ('$ref' in node[key]) {
+            logWalk('Found $ref:', node[key].$ref);
             const resolversToUse = resolvers.filter((r) => canResolve(r, node[key].$ref));
             if (resolversToUse.length === 0) {
                 throw new Error(`No resolver found for ref: ${node[key].$ref}`);
@@ -54,7 +57,7 @@ async function* makeOfflineInternal(manifest) {
             }
             const resolver = resolversToUse[0];
             let func;
-            switch (resolver.offlineMethod) {
+            switch (resolver.offlineFunc) {
                 case 'localizeRef':
                     func = offlineLocalizeRef;
                     break;
@@ -62,13 +65,18 @@ async function* makeOfflineInternal(manifest) {
                     func = offlineResolveRef;
                     break;
                 default:
-                    throw new Error(`Unknown offlineMethod: ${resolver.offlineMethod}`);
+                    const m = resolver.offlineFunc;
+                    func = (_resolver, ref, context) => m(ref, context);
+                // throw new Error(`Unknown offlineMethod: ${resolver.offlineMethod}`);
             }
             const mergeRef = yield* func(resolver, node[key].$ref, resolveContext);
             if (Object.isFrozen(node))
                 throw new Error('Unexpected frozen node during makeOffline');
             node[key] = createMergedObjectWithOverridenNonRefProps({ $ref: mergeRef }, node[key]);
         }
+        else {
+            node[key] = shallowClone(node[key]);
+        }
         // recurse
         if (Array.isArray(node[key])) {
             for (const [index] of node[key].entries()) {

package/dist/esm/offline/makeOfflineBundle.js

@@ -20,19 +20,35 @@ export async function* makeOfflineBundle(manifest) {
         }
         else if ('url' in file) {
             const blob = await downloadFile(file.url);
-            log('Bundling file from url', file.targetFilePath);
+            if (!blob) {
+                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: await blob.arrayBuffer(),
+                };
+            }
+        }
+        else if ('text' in file) {
+            log('Bundling text file', file.targetFilePath);
             yield {
                 path: file.targetFilePath,
-                data: await blob.arrayBuffer(),
+                data: new TextEncoder().encode(file.text).buffer,
             };
         }
+        else {
+            throw new Error('Unknown file type');
+        }
+    }
+    if (await resolve(offlineData.manifest, '/runtime', { preResolvedRefs })) {
+        const html = await getIndexHtml(offlineData.manifest, preResolvedRefs);
+        yield {
+            path: './index.html',
+            data: new TextEncoder().encode(html).buffer,
+        };
     }
-    // yield* generateJsLoaderFiles();
-    const html = await getIndexHtml(offlineData.manifest, preResolvedRefs);
-    yield {
-        path: './index.html',
-        data: new TextEncoder().encode(html).buffer,
-    };
 }
 const MAX_CONCURRENT_DOWNLOADS = 10;
 const queue = new Set();
@@ -49,7 +65,8 @@ async function downloadFile(url) {
             if (!url.includes('/data/fp.svg.ViewBox.js')) {
                 // throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
             }
-            console.warn(`Warning: Failed to fetch ${url}: ${response.status}`);
+            // console.warn(`Warning: Failed to fetch ${url}: ${response.status}`);
+            return;
         }
         return await response.blob();
     })();

package/dist/esm/offline/tools.d.ts

@@ -1,2 +1,3 @@
 export declare function makeUniqueJsonTargetPathFromString(str: string, namespace?: string): string;
+export declare function relativeUrlToFilePath(relativeUrl: string): string;
 export declare function makeTargetPathFromUrl(url: string, prefix?: string): string;

package/dist/esm/offline/tools.js

@@ -17,6 +17,52 @@ export function makeUniqueJsonTargetPathFromString(str, namespace = '') {
     return './' + result;
     // handle directory case
 }
+export function relativeUrlToFilePath(relativeUrl) {
+    const urlObj = new URL(relativeUrl, 'http://example.com');
+    const pathname = relativeUrl.startsWith('/') ? urlObj.pathname : urlObj.pathname.slice(1);
+    const search = urlObj.search;
+    return pathnameSearchToPahthname(pathname, search);
+}
+const MAX_PATHNAME_LENGTH = 120;
+function pathnameSearchToPahthname(pathname, search) {
+    // for directory
+    if (pathname.endsWith('/')) {
+        // just trust it for now
+        // TODO: need to combine with the logic below
+    }
+    else {
+        // if path doesn't end with extension, throw
+        if (!pathname.match(/\.[^\/]+$/)) {
+            throw new Error(`Cannot make target path from URL without file extension: ${pathname}`);
+        }
+        const extension = pathname.substring(pathname.lastIndexOf('.'));
+        let pathnameWithoutExtension = pathname.substring(0, pathname.lastIndexOf('.'));
+        // check the pathname contains only valid fs characters
+        const invalidPathnameChars = pathnameWithoutExtension.match(/[^a-zA-Z0-9\-._\/]/g);
+        if (invalidPathnameChars) {
+            const fixedPathnameWithoutExtension = slugifyFsUnique(pathnameWithoutExtension);
+            log(`Pathname contains invalid filesystem characters (${[...new Set(invalidPathnameChars)].join(', ')}), slugifying it: ${pathnameWithoutExtension}${extension} => ${fixedPathnameWithoutExtension}${extension}`);
+            pathnameWithoutExtension = fixedPathnameWithoutExtension;
+        }
+        pathname = pathnameWithoutExtension + extension;
+        if (pathname.length > MAX_PATHNAME_LENGTH) {
+            log(`Pathname is too long (${pathname.length} characters), truncating to ${MAX_PATHNAME_LENGTH} characters: ${pathname}`);
+            pathname = pathname.substring(0, MAX_PATHNAME_LENGTH - extension.length) + extension;
+        }
+        if (search) {
+            // create a hash from search params
+            const hash = hashString(search);
+            const dotIndex = pathname.lastIndexOf('.');
+            if (dotIndex !== -1) {
+                pathname = `${pathname.slice(0, dotIndex)}.${hash}${pathname.slice(dotIndex)}`;
+            }
+            else {
+                pathname = `${pathname}${hash}`;
+            }
+        }
+    }
+    return pathname;
+}
 export function makeTargetPathFromUrl(url, prefix = '') {
     // https://example.com/dir1/dir2/a.js => "{prefix}{origin-slug}/dir1/dir2/a.js";
     // https://example.com/dir1/dir2/a.js?params => "{prefix}{origin-slug}/dir1/dir2/a{paramsmd5hash}.js";
@@ -30,37 +76,7 @@ export function makeTargetPathFromUrl(url, prefix = '') {
     const urlObj = new URL(url);
     const origin = `${urlObj.protocol}//${urlObj.host}`;
     const originSlug = slugifyFsUnique(origin);
-    let pathname = urlObj.pathname;
-    let search = urlObj.search;
-    // if path doesn't end with extension, throw
-    if (!pathname.match(/\.[^\/]+$/)) {
-        throw new Error(`Cannot make target path from URL without file extension: ${url}`);
-    }
-    const extension = pathname.substring(pathname.lastIndexOf('.'));
-    let pathnameWithoutExtension = pathname.substring(0, pathname.lastIndexOf('.'));
-    // check the pathname contains only valid fs characters
-    const invalidPathnameChars = pathnameWithoutExtension.match(/[^a-zA-Z0-9\-._\/]/g);
-    if (invalidPathnameChars) {
-        const fixedPathnameWithoutExtension = slugifyFsUnique(pathnameWithoutExtension);
-        log(`Pathname contains invalid filesystem characters (${[...new Set(invalidPathnameChars)].join(', ')}), slugifying it: ${pathnameWithoutExtension}${extension} => ${fixedPathnameWithoutExtension}${extension}`);
-        pathnameWithoutExtension = fixedPathnameWithoutExtension;
-    }
-    pathname = pathnameWithoutExtension + extension;
-    if (pathname.length > 120) {
-        log(`Pathname is too long (${pathname.length} characters), truncating to 150 characters: ${pathname}`);
-        pathname = pathname.substring(0, 120 - extension.length) + extension;
-    }
-    if (search) {
-        // create a hash from search params
-        const hash = hashString(search);
-        const dotIndex = pathname.lastIndexOf('.');
-        if (dotIndex !== -1) {
-            pathname = `${pathname.slice(0, dotIndex)}.${hash}${pathname.slice(dotIndex)}`;
-        }
-        else {
-            pathname = `${pathname}${hash}`;
-        }
-    }
+    const pathname = pathnameSearchToPahthname(urlObj.pathname, urlObj.search);
     // // handle directory case
     // if (pathname.endsWith('/')) {
     //   pathname += '__index.json';

package/dist/esm/resolvers/assetResolver.d.ts

@@ -2,5 +2,5 @@ export declare function resolveAssetRefSync(ref: string): string;
 export declare const assetResolver: {
     schema: string;
     resolveRef: (ref: string) => Promise<string>;
-    offlineMethod: "localizeRef";
+    offlineFunc: "localizeRef";
 };

package/dist/esm/resolvers/assetResolver.js

@@ -8,7 +8,7 @@ export function resolveAssetRefSync(ref) {
 export const assetResolver = {
     schema: 'asset',
     resolveRef: async (ref) => resolveAssetRefSync(ref),
-    offlineMethod: 'localizeRef',
+    offlineFunc: 'localizeRef',
 };
 // async *makeOfflineRef(ref: string) {
 //   log('assetResolver makeOfflineRef:', ref);

package/dist/esm/resolvers/bundleAssetsResolver.js

@@ -16,5 +16,5 @@ export const bundleAssetsResolver = {
             return assets;
         });
     },
-    offlineMethod: 'localizeRef',
+    offlineFunc: 'localizeRef',
 };

package/dist/esm/resolvers/cssTextAssetResolver.d.ts

@@ -0,0 +1,8 @@
+import debug from 'debug';
+export declare const log: debug.Debugger;
+export declare const SCHEMA = "css-text-asset";
+export declare const cssTextAssetResolver: {
+    schema: string;
+    resolveRef(ref: string): Promise<string>;
+    offlineFunc: (ref: string, _context: import("../resolve").ResolveContextInternal) => AsyncGenerator<import("../types").LocalFile, string, void>;
+};

package/dist/esm/resolvers/cssTextAssetResolver.js

@@ -0,0 +1,15 @@
+import debug from 'debug';
+import { parseRefValue } from '../resolve';
+export const log = debug('efp:loader:resolver:cssTextAsset');
+export const SCHEMA = 'css-text-asset';
+export const cssTextAssetResolver = {
+    schema: SCHEMA,
+    resolveRef(ref) {
+        log('cssTextAssetResolver resolveRef:', ref);
+        return Promise.resolve(parseRefValue(ref));
+    },
+    offlineFunc: async function* (ref, _context) {
+        const { offlineFunc } = await import('./cssTextAssetResolver.offlineFunc');
+        return yield* offlineFunc(ref, _context);
+    },
+};

package/dist/esm/resolvers/cssTextAssetResolver.offlineFunc.d.ts

@@ -0,0 +1,2 @@
+import { OfflineFunc } from '../types';
+export declare const offlineFunc: OfflineFunc;

package/dist/esm/resolvers/cssTextAssetResolver.offlineFunc.js

@@ -0,0 +1,22 @@
+import { makeTargetPathFromUrl } from '../offline/tools';
+import { parseRefValue } from '../resolve';
+import { log, SCHEMA } from './cssTextAssetResolver';
+export const offlineFunc = async function* (ref, _context) {
+    const originalCss = parseRefValue(ref);
+    const { urls, css } = extractCssUrls(originalCss, makeTargetPathFromUrl);
+    for (const { originalUrl, replacedUrl } of urls) {
+        yield { url: originalUrl, targetFilePath: replacedUrl };
+    }
+    return `${SCHEMA}:${css}`;
+};
+function extractCssUrls(css, replace) {
+    const urlRegex = /url\(\s*(['"]?)(.*?)\1\s*\)/g;
+    const urls = [];
+    const replacedCss = css.replace(urlRegex, (_match, quote, url) => {
+        const replacedUrl = replace(url);
+        urls.push({ originalUrl: url, replacedUrl });
+        log('Extracted and replaced URL in CSS:', url, '->', replacedUrl);
+        return `url(${quote}${replacedUrl}${quote})`;
+    });
+    return { urls, css: replacedCss };
+}

package/dist/esm/resolvers/expoRuntimeBranchResolver.js

@@ -16,5 +16,5 @@ export const expoRuntimeBranchResolver = {
             };
         });
     },
-    offlineMethod: 'resolveRef',
+    offlineFunc: 'resolveRef',
 };

package/dist/esm/resolvers/expoRuntimeGetBranchResolver.js

@@ -10,5 +10,5 @@ export const expoRuntimeGetBranchResolver = {
         const url = `https://${expo}.expofp.com/get-branch`;
         return importJson(url, context);
     },
-    offlineMethod: 'resolveRef',
+    offlineFunc: 'resolveRef',
 };

package/dist/esm/resolvers/expoRuntimeResolver.js

@@ -35,5 +35,5 @@ export const expoRuntimeResolver = {
     //     yield { data, targetFilePath };
     //     return targetFilePath;
     //   },
-    offlineMethod: 'resolveRef',
+    offlineFunc: 'resolveRef',
 };

package/dist/esm/resolvers/httpResolver.d.ts

@@ -1,5 +1,5 @@
 export declare const httpResolver: {
     canResolve(ref: string): boolean;
     resolveRef(ref: string, context: import("../resolve").ResolveContextInternal): Promise<any>;
-    offlineMethod: "resolveRef";
+    offlineFunc: "resolveRef";
 };

package/dist/esm/resolvers/httpResolver.js

@@ -10,5 +10,5 @@ export const httpResolver = {
             throw new Error(`Unexpected ref in httpResolver: ${ref}`);
         return importJson(ref, context);
     },
-    offlineMethod: 'resolveRef',
+    offlineFunc: 'resolveRef',
 };

package/dist/esm/resolvers/index.js

@@ -1,11 +1,13 @@
 import { assetResolver } from './assetResolver';
 import { bundleAssetsResolver } from './bundleAssetsResolver';
+import { cssTextAssetResolver } from './cssTextAssetResolver';
 import { expoRuntimeBranchResolver } from './expoRuntimeBranchResolver';
 import { expoRuntimeGetBranchResolver } from './expoRuntimeGetBranchResolver';
 import { expoRuntimeResolver } from './expoRuntimeResolver';
 import { httpResolver } from './httpResolver';
 import { legacyAssetUrlsResolver } from './legacyAssetUrlsResolver';
 import { legacyDataResolver } from './legacyDataResolver';
+import { legacyDataUrlBaseResolver } from './legacyDataUrlBaseResolver';
 export const resolvers = [
     httpResolver,
     bundleAssetsResolver,
@@ -13,6 +15,8 @@ export const resolvers = [
     expoRuntimeResolver,
     expoRuntimeBranchResolver,
     expoRuntimeGetBranchResolver,
+    cssTextAssetResolver,
     legacyDataResolver,
     legacyAssetUrlsResolver,
+    legacyDataUrlBaseResolver,
 ];

package/dist/esm/resolvers/legacyAssetUrlsResolver.d.ts

@@ -1,6 +1,9 @@
 import { type ResolveContextInternal } from '../resolve';
+/**
+ * @deprecated Use legacyDataUrlBaseResolver instead
+ */
 export declare const legacyAssetUrlsResolver: {
     schema: string;
     resolveRef(ref: string, context: ResolveContextInternal): Promise<any>;
-    offlineMethod: "resolveRef";
+    offlineFunc: "resolveRef";
 };

package/dist/esm/resolvers/legacyAssetUrlsResolver.js

@@ -1,7 +1,10 @@
-import { loadAndWaitGlobal } from '../loadAndWaitGlobal';
+import { loadAndWaitGlobal } from '../loadScript';
 import { parseRefValue } from '../resolve';
 import { returnCachedRef } from '../returnCachedRef';
 import { log } from '../logger';
+/**
+ * @deprecated Use legacyDataUrlBaseResolver instead
+ */
 export const legacyAssetUrlsResolver = {
     schema: 'legacy-asset-urls',
     resolveRef(ref, context) {
@@ -73,7 +76,7 @@ export const legacyAssetUrlsResolver = {
             return { ...dataFilesAssets, ...populateDataJsAssetsMap(dataUrlBase, data) };
         });
     },
-    offlineMethod: 'resolveRef',
+    offlineFunc: 'resolveRef',
 };
 function populateDataJsAssetsMap(dataUrlBase, data) {
     const links = new Set();

package/dist/esm/resolvers/legacyDataResolver.d.ts

@@ -1,5 +1,8 @@
+/**
+ * @deprecated Use legacyDataUrlBaseResolver instead
+ */
 export declare const legacyDataResolver: {
     schema: string;
     resolveRef(ref: string, context: import("../resolve").ResolveContextInternal): Promise<any>;
-    offlineMethod: "resolveRef";
+    offlineFunc: "resolveRef";
 };

package/dist/esm/resolvers/legacyDataResolver.js

@@ -1,6 +1,9 @@
 import { parseRefValue } from '../resolve';
 import { returnCachedRef } from '../returnCachedRef';
 import { log } from '../logger';
+/**
+ * @deprecated Use legacyDataUrlBaseResolver instead
+ */
 export const legacyDataResolver = {
     schema: 'legacy-data',
     resolveRef(ref, context) {
@@ -13,5 +16,5 @@ export const legacyDataResolver = {
             };
         });
     },
-    offlineMethod: 'resolveRef',
+    offlineFunc: 'resolveRef',
 };

package/dist/esm/resolvers/legacyDataUrlBaseResolver.d.ts

@@ -0,0 +1,8 @@
+import debug from 'debug';
+export declare const log: debug.Debugger;
+export declare const SCHEMA = "legacy-data-url-base";
+export declare const legacyDataUrlBaseResolver: {
+    schema: string;
+    resolveRef(ref: string): Promise<string>;
+    offlineFunc: (ref: string, _context: import("../resolve").ResolveContextInternal) => AsyncGenerator<import("../types").LocalFile, string, void>;
+};

package/dist/esm/resolvers/legacyDataUrlBaseResolver.js

@@ -0,0 +1,15 @@
+import debug from 'debug';
+import { parseRefValue } from '../resolve';
+export const log = debug('efp:loader:resolver:legacyDataUrlBase');
+export const SCHEMA = 'legacy-data-url-base';
+export const legacyDataUrlBaseResolver = {
+    schema: SCHEMA,
+    resolveRef(ref) {
+        log('legacyDataResolver resolveRef:', ref);
+        return Promise.resolve(parseRefValue(ref));
+    },
+    offlineFunc: async function* (ref, _context) {
+        const { offlineFunc } = await import('./legacyDataUrlBaseResolver.offlineFunc');
+        return yield* offlineFunc(ref, _context);
+    },
+};

package/dist/esm/resolvers/legacyDataUrlBaseResolver.offlineFunc.d.ts

@@ -0,0 +1,2 @@
+import { OfflineFunc } from '../types';
+export declare const offlineFunc: OfflineFunc;

package/dist/esm/resolvers/legacyDataUrlBaseResolver.offlineFunc.js

@@ -0,0 +1,140 @@
+import { loadScript } from '../loadScript';
+import { makeTargetPathFromUrl, relativeUrlToFilePath } from '../offline/tools';
+import { parseRefValue } from '../resolve';
+import { log, SCHEMA } from './legacyDataUrlBaseResolver';
+export const offlineFunc = async function* (ref, context) {
+    log('legacyDataResolver offlineFunc:', ref);
+    const signal = context.signal;
+    const dataUrlBase = parseRefValue(ref);
+    const versionUrl = `${dataUrlBase}version.js`;
+    try {
+        await loadScript(versionUrl, signal);
+    }
+    catch {
+        console.warn(`Could not load version.js at ${versionUrl}, proceeding without it`);
+    }
+    const version = globalThis.__fpDataVersion || (+new Date()).toString();
+    const localDataUrlBase = makeTargetPathFromUrl(dataUrlBase) + version + '/';
+    const dataUrl = `${dataUrlBase}data.js?v=${version}`;
+    // data.js
+    await loadScript(dataUrl, signal);
+    const __data = getAndDeleteGlobal('__data');
+    yield* localizeDataJson(__data, dataUrlBase, localDataUrlBase);
+    const text = `var __data = ${JSON.stringify(__data, null, 2)};`;
+    yield { text, targetFilePath: `${localDataUrlBase}data.js` };
+    // wf.data.js
+    const wfDataUrl = `${dataUrlBase}wf.data.js?v=${version}`;
+    yield { url: wfDataUrl, targetFilePath: `${localDataUrlBase}wf.data.js` };
+    // fp.svg.js
+    const fpSvgUrl = `${dataUrlBase}fp.svg.js?v=${version}`;
+    yield { url: fpSvgUrl, targetFilePath: `${localDataUrlBase}fp.svg.js` };
+    // load fp.svg.js to get __fpLayers
+    await loadScript(fpSvgUrl, signal);
+    const __fpLayers = getAndDeleteGlobal('__fpLayers') || [];
+    const fpLayerFiles = __fpLayers.map((x) => `fp.svg.${x.name}.js`);
+    for (const layerFile of fpLayerFiles) {
+        // fp.svg.{layer}.js
+        const layerUrl = `${dataUrlBase}${layerFile}?v=${version}`;
+        yield { url: layerUrl, targetFilePath: `${localDataUrlBase}${layerFile}` };
+    }
+    return `${SCHEMA}:${localDataUrlBase}`;
+};
+function* localizeDataJson(data, dataUrlBase, localDataUrlBase) {
+    if (data.logo) {
+        const r = z(data.logo);
+        yield r.file;
+        data.logo = r.localUrl;
+    }
+    for (const exhibitor of data.exhibitors || []) {
+        if (exhibitor.logo) {
+            const r = z(exhibitor.logo);
+            yield r.file;
+            const variants = ['__small', '__tiny'];
+            for (const variant of variants) {
+                const url = addSuffix(r.file.url, variant);
+                const targetFilePath = addSuffix(r.file.targetFilePath, variant);
+                yield { url, targetFilePath };
+            }
+            exhibitor.logo = r.localUrl;
+        }
+        if (exhibitor.leadingImageUrl) {
+            const r = z(exhibitor.leadingImageUrl);
+            yield r.file;
+            exhibitor.leadingImageUrl = r.localUrl;
+        }
+        for (const url of exhibitor.gallery || []) {
+            const r = z(url);
+            yield r.file;
+        }
+        // if (exhibitor.logo) {
+        //   const logoUrl = dataUrlBase + exhibitor.logo;
+        //   const localLogoUrl = relativeUrlToFilePath(exhibitor.logo);
+        //   const targetFilePath = localDataUrlBase + localLogoUrl;
+        //   yield { url: logoUrl, targetFilePath };
+        //   const variants = ['__small', '__tiny'];
+        //   for (const variant of variants) {
+        //     const variantLogo = logoUrl.replace(/(\.[^.]*)$/, `${variant}$1`);
+        //     const variantTargetFilePath = targetFilePath.replace(/(\.[^.]*)$/, `${variant}$1`);
+        //     yield { url: variantLogo, targetFilePath: variantTargetFilePath };
+        //   }
+        //   exhibitor.logo = targetFilePath;
+        // }
+    }
+    for (const event of data.events || []) {
+        if (event.logoFile) {
+            const r = z(event.logoFile);
+            yield r.file;
+            event.logoFile = r.localUrl;
+        }
+        for (const speaker of event.speakers || []) {
+            if (speaker.photoFile) {
+                const r = z(speaker.photoFile);
+                yield r.file;
+                speaker.photoFile = r.localUrl;
+            }
+        }
+    }
+    function z(relativeUrl) {
+        const url = dataUrlBase + relativeUrl;
+        const localUrl = relativeUrlToFilePath(relativeUrl);
+        const targetFilePath = localDataUrlBase + localUrl;
+        return {
+            file: { url, targetFilePath },
+            localUrl,
+        };
+    }
+}
+function getAndDeleteGlobal(globalVar) {
+    const value = globalThis[globalVar];
+    delete globalThis[globalVar];
+    return value;
+}
+// abs and relative paths
+function addSuffix(absoluteOrRelativeUrl, suffix) {
+    let urlObj;
+    let absolute;
+    try {
+        urlObj = new URL(absoluteOrRelativeUrl);
+        absolute = true;
+    }
+    catch {
+        urlObj = new URL(absoluteOrRelativeUrl, 'http://example.com');
+        absolute = false;
+    }
+    // const urlObj = new URL(absoluteOrRelativeUrl, 'http://example.com');
+    const pathname = urlObj.pathname;
+    const dotIndex = pathname.lastIndexOf('.');
+    if (dotIndex === -1) {
+        return absoluteOrRelativeUrl; // no extension found
+    }
+    const name = pathname.substring(0, dotIndex);
+    const extension = pathname.substring(dotIndex);
+    urlObj.pathname = name + suffix + extension;
+    if (absolute) {
+        // return full absolute URL
+        return urlObj.toString();
+    }
+    else {
+        return urlObj.pathname.slice(1) + urlObj.search;
+    }
+}

package/dist/esm/shared.d.ts

@@ -1,6 +1,7 @@
 export declare function createFunction(name: string): (manifest: unknown, ...args: IArguments[]) => Promise<any>;
 export declare function deepFreeze(obj: any): any;
 export declare function deepClone<T>(obj: T): T;
+export declare function shallowClone<T>(obj: T): T;
 export declare function preloadJson(url: string): void;
 export declare function preconnectUrl(url: string): void;
 export declare function createMergedObjectWithOverridenNonRefProps(target: any, source: any): any;

package/dist/esm/shared.js

@@ -33,6 +33,14 @@ export function deepClone(obj) {
     }
     return JSON.parse(JSON.stringify(obj));
 }
+export function shallowClone(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.slice();
+    }
+    return { ...obj };
+}
 export function preloadJson(url) {
     if (typeof document === 'undefined')
         return; // SSR / Node
@@ -213,7 +221,7 @@ export function createMergedObjectWithOverridenNonRefProps(target, source) {
     }
     const nonRefKeys = Object.keys(source).filter((key) => key !== '$ref');
     if (nonRefKeys.length === 0)
-        return deepClone(target);
+        return shallowClone(target);
     // throw if any is array
     if (Array.isArray(target)) {
         throw new Error('Cannot merge into arrays');
@@ -221,7 +229,7 @@ export function createMergedObjectWithOverridenNonRefProps(target, source) {
     if (target === null || typeof target !== 'object') {
         throw new Error('Cannot merge into non-object target');
     }
-    const result = deepClone({ ...target });
+    const result = { ...target }; //deepClone({ ...target });
     for (const key of nonRefKeys) {
         result[key] = source[key];
     }