@expofp/loader 1.0.54 → 1.0.57

package/dist/bundle/makeOffline-CBs7cwrM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeOffline-CBs7cwrM.js","sources":["../../src/offline/hashString.ts","../../src/offline/slugify.ts","../../src/offline/tools.ts","../../src/offline/makeOffline.ts"],"sourcesContent":["// 32-bit murmur-ish hash with configurable seed\nfunction murmur32WithSeed(str: string, seed: number): string {\n  let h = seed >>> 0;\n\n  for (let i = 0; i < str.length; i++) {\n    h ^= str.charCodeAt(i);\n    h = Math.imul(h, 0x01000193); // FNV-ish prime, good mixer\n  }\n\n  return (h >>> 0).toString(16).padStart(8, '0'); // 8 hex chars\n}\n\n// 128-bit (MD5-width) hash: 4 × 32-bit parts concatenated\nexport function hashString(str: string): string {\n  return (\n    murmur32WithSeed(str, 0x811c9dc5) + // your original seed\n    murmur32WithSeed(str, 0x21f0aaad) +\n    murmur32WithSeed(str, 0x1b873593) +\n    murmur32WithSeed(str, 0x85ebca6b)\n  );\n}\n","// Module-level caches\nconst inputToSlug = new Map<string, string>();\nconst slugToInput = new Map<string, string>();\n\nconst WINDOWS_RESERVED = new Set([\n  \"con\", \"prn\", \"aux\", \"nul\",\n  \"com1\", \"com2\", \"com3\", \"com4\", \"com5\", \"com6\", \"com7\", \"com8\", \"com9\",\n  \"lpt1\", \"lpt2\", \"lpt3\", \"lpt4\", \"lpt5\", \"lpt6\", \"lpt7\", \"lpt8\", \"lpt9\",\n]);\n\nfunction makeBaseSlug(input: string): string {\n  let slug = input\n    .normalize(\"NFKD\")\n    // All non letters/numbers → \"-\"\n    .replace(/[^\\p{Letter}\\p{Number}]+/gu, \"-\")\n    // Collapse multiple \"-\"\n    .replace(/-+/g, \"-\")\n    // Trim \"-\" from start/end\n    .replace(/^-|-$/g, \"\")\n    .toLowerCase();\n\n  // Strip forbidden Windows characters just in case\n  slug = slug.replace(/[<>:\"/\\\\|?*]/g, \"\");\n\n  // Windows forbids trailing space/period\n  slug = slug.replace(/[. ]+$/g, \"\");\n\n  // Fallback if everything was stripped\n  if (!slug) slug = \"file\";\n\n  // Avoid bare reserved device names\n  if (WINDOWS_RESERVED.has(slug)) {\n    slug += \"-file\";\n  }\n\n  return slug;\n}\n\nexport function slugifyFsUnique(input: string): string {\n  // If we've seen this exact input before, return the same slug\n  const existing = inputToSlug.get(input);\n  if (existing) return existing;\n\n  const base = makeBaseSlug(input);\n  let candidate = base;\n  let counter = 2;\n\n  while (true) {\n    const existingInput = slugToInput.get(candidate);\n\n    if (!existingInput) {\n      // Free slug → claim it for this input\n      slugToInput.set(candidate, input);\n      inputToSlug.set(input, candidate);\n      return candidate;\n    }\n\n    if (existingInput === input) {\n      // Same input somehow (super defensive)\n      inputToSlug.set(input, candidate);\n      return candidate;\n    }\n\n    // Collision: same slug already used by different input → add suffix\n    candidate = `${base}-${counter++}`;\n  }\n}\n\n// // Optional: to reset between runs/tests\n// export function resetSlugCache() {\n//   inputToSlug.clear();\n//   slugToInput.clear();\n// }","import { hashString } from './hashString';\nimport { slugifyFsUnique } from './slugify';\n\nexport function makeUniqueJsonTargetPathFromString(str: string, namespace: string = ''): string {\n  // const hash = hashString(str);\n  let result = slugifyFsUnique(str); // + '-' + hash;\n  if (namespace) {\n    result = `${slugifyFsUnique(namespace)}$${result}`;\n  }\n\n  if (result.endsWith('/')) {\n    result += 'index.json';\n  } else if (!result.endsWith('.json')) {\n    result += '.json';\n  }\n  return './' + result;\n  // handle directory case\n}\n\nexport function makeTargetPathFromUrl(url: string, prefix: string = ''): string {\n  // https://example.com/dir1/dir2/a.js => \"{prefix}{origin-slug}/dir1/dir2/a.js\";\n  // https://example.com/dir1/dir2/a.js?params => \"{prefix}{origin-slug}/dir1/dir2/a{paramsmd5hash}.js\";\n  // use slugify.ts\n\n  try {\n    new URL(url);\n  } catch {\n    debugger;\n  }\n  const urlObj = new URL(url);\n  const origin = `${urlObj.protocol}//${urlObj.host}`;\n  const originSlug = slugifyFsUnique(origin);\n\n  let pathname = urlObj.pathname;\n  let search = urlObj.search;\n\n  // if path doesn't end with extension, throw\n  if (!pathname.match(/\\.[^\\/]+$/)) {\n    throw new Error(`Cannot make target path from URL without file extension: ${url}`);\n  }\n\n  const extension = pathname.substring(pathname.lastIndexOf('.'));\n  let pathnameWithoutExtension = pathname.substring(0, pathname.lastIndexOf('.'));\n\n  // check the pathname contains only valid fs characters\n  const invalidPathnameChars = pathnameWithoutExtension.match(/[^a-zA-Z0-9\\-._\\/]/g);\n  if (invalidPathnameChars) {\n    const fixedPathnameWithoutExtension = slugifyFsUnique(pathnameWithoutExtension);\n    console.warn(\n      `Warning: pathname contains invalid filesystem characters (${[\n        ...new Set(invalidPathnameChars),\n      ].join(\n        ', '\n      )}), slugifying it: ${pathnameWithoutExtension}${extension} => ${fixedPathnameWithoutExtension}${extension}`\n    );\n    pathnameWithoutExtension = fixedPathnameWithoutExtension;\n  }\n\n  pathname = pathnameWithoutExtension + extension;\n\n  if (pathname.length > 120) {\n    console.warn(\n      `Warning: pathname is too long (${pathname.length} characters), truncating to 150 characters: ${pathname}`\n    );\n    pathname = pathname.substring(0, 120 - extension.length) + extension;\n  }\n\n  if (search) {\n    // create a hash from search params\n    const hash = hashString(search);\n    const dotIndex = pathname.lastIndexOf('.');\n    if (dotIndex !== -1) {\n      pathname = `${pathname.slice(0, dotIndex)}.${hash}${pathname.slice(dotIndex)}`;\n    } else {\n      pathname = `${pathname}${hash}`;\n    }\n  }\n\n  // // handle directory case\n  // if (pathname.endsWith('/')) {\n  //   pathname += '__index.json';\n  // }\n\n  return `./${prefix}${originSlug}${pathname}`;\n}\n","import {\n  canResolve,\n  parseRefValue,\n  resolverResolve,\n  type ResolveContextInternal,\n} from '../resolve';\nimport { resolvers } from '../resolvers';\nimport { createMergedObjectWithOverridenNonRefProps, deepClone, log } from '../shared';\nimport type { LocalFile, MakeOfflineResult, ManifestData, Resolver } from '../types';\nimport { makeTargetPathFromUrl, makeUniqueJsonTargetPathFromString } from './tools';\n\nexport async function makeOffline(manifest: any): Promise<MakeOfflineResult> {\n  log('makeOffline', manifest);\n  // if (typeof manifest !== 'object' || manifest === null) {\n  //   throw new Error('Manifest must be an object');\n  // }\n\n  const res = await makeOfflineInternal(manifest);\n  let done = false;\n  let resultManifest: any;\n  async function* files() {\n    resultManifest = yield* res;\n    done = true;\n  }\n\n  return {\n    get manifest(): ManifestData {\n      if (!done) throw new Error('Iterate over files before getting manifest');\n      return resultManifest;\n    },\n    files: files() as AsyncGenerator<LocalFile, void, void>,\n  };\n}\n\nasync function* makeOfflineInternal(manifest: any): AsyncGenerator<LocalFile, ManifestData, void> {\n  log('makeOfflineInternal', manifest);\n  const resolveContext: ResolveContextInternal = {\n    refCache: new Map<string, Promise<any>>(),\n    forceFetch: true,\n    signal: null,\n  };\n  const parent = { manifest };\n  yield* walk(parent, 'manifest');\n  return parent.manifest;\n\n  async function* walk(node: any, key: string | number): AsyncGenerator<LocalFile> {\n    // console.log('walk', node, key, node[key]);\n    // let node[key] = node[key];\n    if (typeof node[key] !== 'object' || node[key] === null) {\n      return;\n    }\n    // let resolversToUse1 = resolvers.filter((r) => r.canResolve(node[key].$ref));\n    // const usedResolvers = new Set<Resolver>();\n    // do {\n    if ('$ref' in node[key]) {\n      const resolversToUse = resolvers.filter((r) => canResolve(r, node[key].$ref));\n      if (resolversToUse.length === 0) {\n        throw new Error(`No resolver found for ref: ${node[key].$ref}`);\n      }\n      if (resolversToUse.length > 1) {\n        throw new Error(`Multiple resolvers can make offline ref: ${node[key].$ref}`);\n      }\n\n      const resolver = resolversToUse[0];\n\n      let func: typeof offlineLocalizeRef;\n      switch (resolver.offlineMethod) {\n        case 'localizeRef':\n          func = offlineLocalizeRef;\n          break;\n        case 'resolveRef':\n          func = offlineResolveRef;\n          break;\n        default:\n          throw new Error(`Unknown offlineMethod: ${resolver.offlineMethod}`);\n      }\n\n      const mergeRef = yield* func(resolver, node[key].$ref, resolveContext);\n\n      if (Object.isFrozen(node[key])) throw new Error('Unexpected frozen node during makeOffline');\n\n      node[key] = createMergedObjectWithOverridenNonRefProps({ $ref: mergeRef }, node[key]);\n    }\n\n    // recurse\n    if (Array.isArray(node[key])) {\n      for (const [index] of node[key].entries()) {\n        yield* walk(node[key], index);\n      }\n    } else if (typeof node[key] === 'object' && node[key] !== null) {\n      for (const key1 of Object.keys(node[key])) {\n        // debugger;\n        yield* walk(node[key], key1);\n      }\n    }\n  }\n}\n\n// function canResolve(resolver: Resolver, ref: string): boolean {\n//   if (resolver.canResolve) {\n//     return resolver.canResolve(ref);\n//   }\n//   if (resolver.schema) {\n//     return canResolveRefSchema(ref, resolver.schema);\n//   }\n//   throw new Error('Resolver is missing canResolve method and schema property');\n// }\n\nasync function* offlineLocalizeRef(\n  resolver: Resolver,\n  ref: string,\n  context: ResolveContextInternal\n): AsyncGenerator<LocalFile, string, void> {\n  const refData = deepClone(await resolverResolve(resolver, ref, context));\n  // emit assets\n  yield* makeOfflineInternal(refData);\n  const url = parseRefValue(ref);\n  const targetFilePath = makeTargetPathFromUrl(url);\n  // TODO: handle CSS and other text files that may reference other assets\n  yield { url, targetFilePath };\n  const schema = ref.substring(0, ref.length - url.length - 1);\n  return `${schema}:${targetFilePath}`;\n}\n\nasync function* offlineResolveRef(\n  resolver: Resolver,\n  ref: string,\n  context: ResolveContextInternal\n): AsyncGenerator<LocalFile, string, void> {\n  const refData = deepClone(await resolverResolve(resolver, ref, context));\n  const targetFilePath = makeUniqueJsonTargetPathFromString(ref);\n  const data = yield* makeOfflineInternal(refData);\n  yield { data, targetFilePath };\n  return targetFilePath;\n}\n\n// export function createMakeOfflineResult(\n//   manifest: any,\n//   walk: (node: any, key: string | number) => AsyncGenerator<LocalFile>\n// ): MakeOfflineResult {\n//   log('createMakeOfflineResult', manifest);\n//   if (typeof manifest !== 'object' || manifest === null) {\n//     throw new Error('Manifest must be an object');\n//   }\n//   const parent = { manifest };\n//   let done = false;\n//   async function* files() {\n//     yield* walk(parent, 'manifest');\n//     done = true;\n//   }\n\n//   return {\n//     get manifest() {\n//       if (!done) {\n//         throw new Error('Cannot access manifest before all files are generated');\n//       }\n//       return parent.manifest;\n//     },\n//     files: files(),\n//   };\n// }\n"],"names":["murmur32WithSeed","str","seed","h","i","hashString","inputToSlug","slugToInput","WINDOWS_RESERVED","makeBaseSlug","input","slug","slugifyFsUnique","existing","base","candidate","counter","existingInput","makeUniqueJsonTargetPathFromString","namespace","result","makeTargetPathFromUrl","url","prefix","urlObj","origin","originSlug","pathname","search","extension","pathnameWithoutExtension","invalidPathnameChars","fixedPathnameWithoutExtension","hash","dotIndex","makeOffline","manifest","log","res","makeOfflineInternal","done","resultManifest","files","resolveContext","parent","walk","node","key","resolversToUse","resolvers","r","canResolve","resolver","func","offlineLocalizeRef","offlineResolveRef","mergeRef","createMergedObjectWithOverridenNonRefProps","index","key1","ref","context","refData","deepClone","resolverResolve","parseRefValue","targetFilePath"],"mappings":"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"}

package/dist/{makeOfflineBundle-CdE5LdlF.js → bundle/makeOfflineBundle-BpFIeDmK.js}

@@ -1,5 +1,5 @@
-import { l as r, resolve as l } from "./index.js";
-import { makeOffline as f } from "./makeOffline-DdJq2uGI.js";
+import { l as r, resolve as l } from "./bundle.js";
+import { makeOffline as f } from "./makeOffline-CBs7cwrM.js";
 async function* u(t) {
   r("makeOfflineBundle", t);
   const e = await f(t);
@@ -55,4 +55,4 @@ async function d(t) {
 export {
   u as makeOfflineBundle
 };
-//# sourceMappingURL=makeOfflineBundle-CdE5LdlF.js.map
+//# sourceMappingURL=makeOfflineBundle-BpFIeDmK.js.map

package/dist/bundle/makeOfflineBundle-BpFIeDmK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeOfflineBundle-BpFIeDmK.js","sources":["../../src/offline/makeOfflineBundle.ts"],"sourcesContent":["import { log } from '../shared';\nimport { makeOffline } from './makeOffline';\nimport { resolve } from '..';\n\nexport async function* makeOfflineBundle(\n  manifest: unknown\n): AsyncGenerator<{ path: string; data: ArrayBuffer }> {\n  log('makeOfflineBundle', manifest);\n  const offlineData = await makeOffline(manifest);\n  for await (const file of offlineData.files) {\n    if ('data' in file) {\n      const jsonString = JSON.stringify(file.data, null, 2);\n      yield {\n        path: file.targetFilePath,\n        data: new TextEncoder().encode(jsonString).buffer,\n      };\n    } else if ('url' in file) {\n      const blob = await downloadFile(file.url);\n      yield {\n        path: file.targetFilePath,\n        data: await blob.arrayBuffer(),\n      };\n    }\n  }\n  // yield* generateJsLoaderFiles();\n  const html = await getIndexHtml(offlineData.manifest);\n  yield {\n    path: 'index.html',\n    data: new TextEncoder().encode(html).buffer,\n  };\n}\n\nconst MAX_CONCURRENT_DOWNLOADS = 10;\nconst queue = new Set<Promise<Blob>>();\n// have a queue to limit concurrent downloads\nasync function downloadFile(url: string): Promise<Blob> {\n  while (queue.size >= MAX_CONCURRENT_DOWNLOADS) {\n    await Promise.race(queue);\n  }\n  const downloadPromise = (async () => {\n    log('Fetching file for zip:', url);\n    const response = await fetch(url);\n    if (!response.ok) {\n      throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);\n    }\n    return await response.blob();\n  })();\n  queue.add(downloadPromise);\n  try {\n    return await downloadPromise;\n  } finally {\n    queue.delete(downloadPromise);\n  }\n}\n\nasync function getIndexHtml(manifest: unknown) {\n  const entryPoint = await resolve(manifest, '/runtime/entry');\n  const html = `\n<!DOCTYPE html>\n<script type=\"module\">\n  import { load } from ${JSON.stringify(entryPoint)};\n  await load(${JSON.stringify(manifest)});\n  console.info('🚀 loaded');\n</script> \n`;\n  return html;\n}\n"],"names":["makeOfflineBundle","manifest","log","offlineData","makeOffline","file","jsonString","blob","downloadFile","html","getIndexHtml","MAX_CONCURRENT_DOWNLOADS","queue","url","downloadPromise","response","entryPoint","resolve"],"mappings":";;AAIA,gBAAuBA,EACrBC,GACqD;AACrD,EAAAC,EAAI,qBAAqBD,CAAQ;AACjC,QAAME,IAAc,MAAMC,EAAYH,CAAQ;AAC9C,mBAAiBI,KAAQF,EAAY;AACnC,QAAI,UAAUE,GAAM;AAClB,YAAMC,IAAa,KAAK,UAAUD,EAAK,MAAM,MAAM,CAAC;AACpD,YAAM;AAAA,QACJ,MAAMA,EAAK;AAAA,QACX,MAAM,IAAI,YAAA,EAAc,OAAOC,CAAU,EAAE;AAAA,MAAA;AAAA,IAE/C,WAAW,SAASD,GAAM;AACxB,YAAME,IAAO,MAAMC,EAAaH,EAAK,GAAG;AACxC,YAAM;AAAA,QACJ,MAAMA,EAAK;AAAA,QACX,MAAM,MAAME,EAAK,YAAA;AAAA,MAAY;AAAA,IAEjC;AAGF,QAAME,IAAO,MAAMC,EAAaP,EAAY,QAAQ;AACpD,QAAM;AAAA,IACJ,MAAM;AAAA,IACN,MAAM,IAAI,YAAA,EAAc,OAAOM,CAAI,EAAE;AAAA,EAAA;AAEzC;AAEA,MAAME,IAA2B,IAC3BC,wBAAY,IAAA;AAElB,eAAeJ,EAAaK,GAA4B;AACtD,SAAOD,EAAM,QAAQD;AACnB,UAAM,QAAQ,KAAKC,CAAK;AAE1B,QAAME,KAAmB,YAAY;AACnC,IAAAZ,EAAI,0BAA0BW,CAAG;AACjC,UAAME,IAAW,MAAM,MAAMF,CAAG;AAChC,QAAI,CAACE,EAAS;AACZ,YAAM,IAAI,MAAM,mBAAmBF,CAAG,KAAKE,EAAS,MAAM,IAAIA,EAAS,UAAU,EAAE;AAErF,WAAO,MAAMA,EAAS,KAAA;AAAA,EACxB,GAAA;AACA,EAAAH,EAAM,IAAIE,CAAe;AACzB,MAAI;AACF,WAAO,MAAMA;AAAA,EACf,UAAA;AACE,IAAAF,EAAM,OAAOE,CAAe;AAAA,EAC9B;AACF;AAEA,eAAeJ,EAAaT,GAAmB;AAC7C,QAAMe,IAAa,MAAMC,EAAQhB,GAAU,gBAAgB;AAS3D,SARa;AAAA;AAAA;AAAA,yBAGU,KAAK,UAAUe,CAAU,CAAC;AAAA,eACpC,KAAK,UAAUf,CAAQ,CAAC;AAAA;AAAA;AAAA;AAKvC;"}

package/dist/{importJson.d.ts → esm/importJson.d.ts}

@@ -1,2 +1,2 @@
-import { ResolveContextInternal } from './resolve';
+import type { ResolveContextInternal } from './resolve';
 export declare function importJson<T = any>(url: string, resolveContext: ResolveContextInternal): Promise<T>;

package/dist/esm/importJson.js

@@ -0,0 +1,52 @@
+import { deepFreeze, log } from './shared';
+let importJsonNotAvailable;
+const jsonFrozen = new WeakSet();
+// ET: this is a workaround for Vite that analyzes dynamic imports and removes 'with' option
+// to be removed when Vite supports it properly
+// Cons: can have CSP issues in some environments
+const importJsonNative = new Function('url', 'return import(url, { with: { type: "json" } });');
+export async function importJson(url, resolveContext) {
+    // console.warn('importJson:', resolveContext.forceFetch);
+    if (importJsonNotAvailable === undefined && !resolveContext.forceFetch) {
+        try {
+            await importJsonNative(url);
+            importJsonNotAvailable = false;
+        }
+        catch {
+            log('importJson: dynamic import not available, falling back to fetch');
+            importJsonNotAvailable = true;
+        }
+    }
+    let result = undefined;
+    if (!importJsonNotAvailable && !resolveContext.forceFetch) {
+        const module = await importJsonNative(url);
+        result = module.default;
+        resolveContext.importCallback?.(url, 'json');
+    }
+    else {
+        log('importJson: fetch', url);
+        result = await loadJson(url, resolveContext.refCache, resolveContext.signal || null);
+        resolveContext.importCallback?.(url, 'json');
+    }
+    if (!jsonFrozen.has(result)) {
+        deepFreeze(result);
+        // jsonFrozen.add(result);
+    }
+    return result;
+}
+// const fetchCache = new Map<string, Promise<any>>();
+async function loadJson(url, fetchCache, signal) {
+    const key = '__loadJson__' + url;
+    if (fetchCache.has(key)) {
+        return fetchCache.get(key);
+    }
+    const dataPromise = (async function loadJsonInner() {
+        const response = await fetch(url, { signal });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch JSON from ${url}`);
+        }
+        return await response.json();
+    })();
+    fetchCache.set(key, dataPromise);
+    return dataPromise;
+}

package/dist/esm/index.js

@@ -0,0 +1,16 @@
+import { createFunction } from './shared';
+export const mount = createFunction('mount');
+export const load = createFunction('load');
+export const initialize = createFunction('initialize');
+// extra
+// export const createFloorPlan = createFunction('createFloorPlan');
+// export const rewriteManifestToLocalFiles = createFunction('rewriteManifestToLocalFiles');
+export async function callFunction_Experimental(name, manifest, ...args) {
+    const fn = createFunction(name);
+    return await fn(manifest, ...args);
+}
+export { mutateManifest } from './mutateManifest';
+export { downloadZip, makeOfflineBundle } from './offline';
+export { resolve } from './resolve';
+// preloadJson('https://efp-runtime.expofp.com/branches/main.json');
+// preconnectUrl('https://efp-runtime.expofp.com/');

package/dist/esm/loadAndWaitGlobal.js

@@ -0,0 +1,157 @@
+//import { log } from './shared';
+/**
+ * Load a script from `scriptUrl` and optionally wait until `globalVar` appears.
+ * Works in both browser (via <script>) and Node 18+ (via fetch + eval).
+ */
+export async function loadAndWaitGlobal(scriptUrl, options) {
+    const { globalVar, timeoutMs = 10_000, pollIntervalMs = 10 } = options;
+    if (isBrowser()) {
+        if (globalVar && window[globalVar] !== undefined) {
+            delete window[globalVar];
+        }
+        await loadInBrowser(scriptUrl, options.signal);
+        if (globalVar) {
+            await waitForGlobal(() => window[globalVar], globalVar, timeoutMs, pollIntervalMs, options.signal);
+        }
+    }
+    else {
+        if (globalVar && globalThis[globalVar] !== undefined) {
+            delete globalThis[globalVar];
+        }
+        await loadInNode(scriptUrl, options.signal);
+        if (globalVar) {
+            await waitForGlobal(() => globalThis[globalVar], globalVar, timeoutMs, pollIntervalMs, options.signal);
+        }
+    }
+}
+function isBrowser() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+/* -------------------- Browser implementation -------------------- */
+export function loadInBrowser(scriptUrl, signal) {
+    return new Promise((resolve, reject) => {
+        const script = document.createElement('script');
+        script.src = scriptUrl;
+        script.async = true;
+        const cleanup = () => {
+            script.onload = null;
+            script.onerror = null;
+            script.remove();
+        };
+        const onAbort = () => {
+            cleanup();
+            reject(new Error('Script load aborted'));
+        };
+        if (signal?.aborted) {
+            cleanup();
+            reject(new Error('Script load aborted'));
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+        script.onload = () => {
+            signal?.removeEventListener('abort', onAbort);
+            cleanup();
+            resolve();
+        };
+        script.onerror = () => {
+            signal?.removeEventListener('abort', onAbort);
+            cleanup();
+            reject(new Error(`Failed to load script: ${scriptUrl}`));
+        };
+        document.head.appendChild(script);
+    });
+}
+/* -------------------- Node implementation -------------------- */
+async function loadInNode(scriptUrl, signal) {
+    if (typeof fetch !== 'function') {
+        throw new Error('loadInNode: fetch is not available. Use Node 18+ or provide a global fetch.');
+    }
+    if (signal?.aborted) {
+        throw new Error('Script load aborted');
+    }
+    let res;
+    try {
+        res = await fetch(scriptUrl, { signal });
+    }
+    catch (err) {
+        // Node / WHATWG fetch uses AbortError on abort
+        if (err && err.name === 'AbortError') {
+            throw new Error('Script load aborted');
+        }
+        throw err;
+    }
+    if (!res.ok) {
+        throw new Error(`Failed to load script in Node (HTTP ${res.status}): ${scriptUrl}`);
+    }
+    // If it was aborted between headers and body:
+    if (signal?.aborted) {
+        throw new Error('Script load aborted');
+    }
+    let code;
+    try {
+        code = await res.text();
+    }
+    catch (err) {
+        if (err && err.name === 'AbortError') {
+            throw new Error('Script load aborted');
+        }
+        throw err;
+    }
+    if (signal?.aborted) {
+        throw new Error('Script load aborted');
+    }
+    // TEMPORARILY expose window for browser-style UMDs that expect it
+    const g = globalThis;
+    const prevWindow = g.window;
+    g.window = g;
+    try {
+        // Indirect eval -> global scope in Node
+        // Assumes the loaded script attaches itself to globalThis/window/global.
+        (0, eval)(code);
+    }
+    finally {
+        // Restore previous window (if any)
+        if (prevWindow === undefined) {
+            delete g.window;
+        }
+        else {
+            g.window = prevWindow;
+        }
+    }
+}
+/* -------------------- Shared helper -------------------- */
+function waitForGlobal(getter, name, timeoutMs, pollIntervalMs, abortSignal) {
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        const onAbort = () => {
+            reject(new Error('Wait for global aborted'));
+        };
+        if (abortSignal?.aborted) {
+            reject(new Error('Wait for global aborted'));
+            return;
+        }
+        abortSignal?.addEventListener('abort', onAbort, { once: true });
+        const check = () => {
+            if (abortSignal?.aborted) {
+                return reject(new Error('Wait for global aborted'));
+            }
+            try {
+                if (getter() !== undefined) {
+                    abortSignal?.removeEventListener('abort', onAbort);
+                    // log(`loadAndWaitGlobal: global "${name}" is now available`);
+                    return resolve();
+                }
+            }
+            catch {
+                // ignore access errors and keep polling
+            }
+            if (Date.now() - start >= timeoutMs) {
+                abortSignal?.removeEventListener('abort', onAbort);
+                // console.error(`loadAndWaitGlobal: timed out waiting for global "${name}"`);
+                return reject(new Error(`Timed out after ${timeoutMs} ms waiting for global "${name}"`));
+            }
+            setTimeout(check, pollIntervalMs);
+        };
+        check();
+    });
+}

package/dist/{mutateManifest.d.ts → esm/mutateManifest.d.ts}

@@ -1,2 +1,2 @@
-import { ResolveOptions } from './resolve';
+import type { ResolveOptions } from './resolve';
 export declare function mutateManifest(manifest: any, paths: string[], resolveContext?: Omit<ResolveOptions, 'mutate'>): Promise<void>;

package/dist/esm/mutateManifest.js

@@ -0,0 +1,10 @@
+import { resolve } from './resolve';
+export async function mutateManifest(manifest, paths, resolveContext) {
+    resolveContext = resolveContext || {};
+    for (const path of paths) {
+        await resolve(manifest, path, { ...resolveContext, mutate: true });
+    }
+}
+if (typeof window !== 'undefined') {
+    window['__debugMutateManifest'] = mutateManifest;
+}

package/dist/esm/offline/downloadZip copy.js

@@ -0,0 +1,89 @@
+// import { gunzipSync } from 'fflate';
+// import untar from 'js-untar';
+// import JSZip from 'jszip';
+// import { makeOffline } from './makeOffline';
+// import { log } from '../shared';
+export {};
+// export async function downloadZip(manifest: unknown) {
+//   const zip = new JSZip();
+//   const offlineData = await makeOffline(manifest);
+//   for await (const file of offlineData.files) {
+//     if ('data' in file) {
+//       zip.file(file.targetFilePath, JSON.stringify(file.data, null, 2));
+//     } else if ('url' in file) {
+//       await scheduleFileForZip(zip, file.targetFilePath, file.url);
+//     }
+//   }
+//   await addJsLoader(zip);
+//   addIndexHtml(zip, offlineData.manifest);
+//   // Generate archive
+//   const blob = await zip.generateAsync({ type: 'blob' });
+//   // console.info('Manifest for HTML:', offlineData.manifest);
+//   // Create link & trigger download
+//   const a = document.createElement('a');
+//   a.href = URL.createObjectURL(blob);
+//   a.download = 'offline.zip';
+//   a.click();
+//   URL.revokeObjectURL(a.href);
+// }
+// const MAX_CONCURRENT_DOWNLOADS = 10;
+// const queue = new Set<Promise<void>>();
+// // have a queue to limit concurrent downloads
+// async function scheduleFileForZip(zip: JSZip, targetFilePath: string, url: string) {
+//   while (queue.size >= MAX_CONCURRENT_DOWNLOADS) {
+//     await Promise.race(queue);
+//   }
+//   const downloadPromise = (async () => {
+//     log('Fetching file for zip:', url);
+//     const response = await fetch(url);
+//     if (!response.ok) {
+//       throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+//     }
+//     const blob = await response.blob();
+//     zip.file(targetFilePath, blob);
+//   })();
+//   queue.add(downloadPromise);
+//   try {
+//     await downloadPromise;
+//   } finally {
+//     queue.delete(downloadPromise);
+//   }
+// }
+// async function addJsLoader(zip: JSZip) {
+//   const packageInfo = 'https://registry.npmjs.org/@expofp/loader';
+//   const response = await fetch(packageInfo);
+//   if (!response.ok) {
+//     throw new Error(`Failed to fetch ${packageInfo}: ${response.status} ${response.statusText}`);
+//   }
+//   const data = await response.json();
+//   const latestVersion = data['dist-tags'].latest;
+//   const tarballUrl = data.versions[latestVersion].dist.tarball;
+//   const tgzResponse = await fetch(tarballUrl);
+//   if (!tgzResponse.ok) {
+//     throw new Error(
+//       `Failed to fetch ${tarballUrl}: ${tgzResponse.status} ${tgzResponse.statusText}`
+//     );
+//   }
+//   const tgzArrayBuffer = await tgzResponse.arrayBuffer();
+//   // use fflate to convert tgz to tar
+//   const tarFile = gunzipSync(new Uint8Array(tgzArrayBuffer));
+//   const files = await untar(tarFile.buffer as ArrayBuffer);
+//   console.info('Extracted tar file from tgz, size:', files);
+//   // const arrayBuffer = await tgzResponse.arrayBuffer();
+//   // const files = await untar(arrayBuffer);
+//   for (const file of files) {
+//     console.info('Adding loader file to zip:', file.name);
+//     zip.file('efp-loader/' + file.name, file.buffer);
+//   }
+// }
+// function addIndexHtml(zip: JSZip, manifest: unknown) {
+//   const html = `
+//  <!DOCTYPE html>
+// <script type="module">
+//   import { load } from './efp-loader/dist/loader.js';
+//   await load(${JSON.stringify(manifest)});
+//   console.info('🚀 FloorPlan loaded', floorplan);
+// </script> 
+// `;
+//   zip.file('index.html', html);
+// }

package/dist/esm/offline/downloadZip.js

@@ -0,0 +1,18 @@
+import JSZip from 'jszip';
+import { makeOfflineBundle } from './makeOfflineBundle';
+export async function downloadZip(manifest) {
+    const zip = new JSZip();
+    const bundle = await makeOfflineBundle(manifest);
+    for await (const file of bundle) {
+        zip.file(file.path, file.data);
+    }
+    // Generate archive
+    const blob = await zip.generateAsync({ type: 'blob' });
+    // console.info('Manifest for HTML:', offlineData.manifest);
+    // Create link & trigger download
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(blob);
+    a.download = 'offline.zip';
+    a.click();
+    URL.revokeObjectURL(a.href);
+}

package/dist/esm/offline/hashString.js

@@ -0,0 +1,16 @@
+// 32-bit murmur-ish hash with configurable seed
+function murmur32WithSeed(str, seed) {
+    let h = seed >>> 0;
+    for (let i = 0; i < str.length; i++) {
+        h ^= str.charCodeAt(i);
+        h = Math.imul(h, 0x01000193); // FNV-ish prime, good mixer
+    }
+    return (h >>> 0).toString(16).padStart(8, '0'); // 8 hex chars
+}
+// 128-bit (MD5-width) hash: 4 × 32-bit parts concatenated
+export function hashString(str) {
+    return (murmur32WithSeed(str, 0x811c9dc5) + // your original seed
+        murmur32WithSeed(str, 0x21f0aaad) +
+        murmur32WithSeed(str, 0x1b873593) +
+        murmur32WithSeed(str, 0x85ebca6b));
+}

package/dist/esm/offline/index.js

@@ -0,0 +1,29 @@
+export async function makeOfflineBundle(manifest) {
+    const { makeOfflineBundle } = await import('./makeOfflineBundle');
+    return await makeOfflineBundle(manifest);
+}
+export async function downloadZip(manifest) {
+    const { downloadZip } = await import('./downloadZip');
+    return await downloadZip(manifest);
+}
+async function debugLogOfflineManifestFiles(manifest) {
+    // console.log('Offline files:');
+    const { makeOffline } = await import('./makeOffline');
+    const result = await makeOffline(manifest);
+    // const allFiles = [];
+    for await (const file of (await result).files) {
+        if ('data' in file) {
+            console.info(`🗳️ Put ${file.targetFilePath} <=`, file.data);
+        }
+        else if ('url' in file) {
+            console.info(`🗳️ Download ${file.targetFilePath} <= ${file.url}`);
+        }
+        // allFiles.push(file);
+    }
+    console.info('Offline data: ', result.manifest);
+}
+if (typeof window !== 'undefined') {
+    window['__debugDownloadZip'] = downloadZip;
+    window['__debugMakeOfflineBundle'] = makeOfflineBundle;
+    window['__debugLogOfflineManifestFiles'] = debugLogOfflineManifestFiles;
+}

package/dist/{offline → esm/offline}/makeOffline.d.ts

@@ -1,2 +1,2 @@
-import { MakeOfflineResult } from '../types';
+import type { MakeOfflineResult } from '../types';
 export declare function makeOffline(manifest: any): Promise<MakeOfflineResult>;

package/dist/esm/offline/makeOffline.js

@@ -0,0 +1,134 @@
+import { canResolve, parseRefValue, resolverResolve, } from '../resolve';
+import { resolvers } from '../resolvers';
+import { createMergedObjectWithOverridenNonRefProps, deepClone, log } from '../shared';
+import { makeTargetPathFromUrl, makeUniqueJsonTargetPathFromString } from './tools';
+export async function makeOffline(manifest) {
+    log('makeOffline', manifest);
+    // if (typeof manifest !== 'object' || manifest === null) {
+    //   throw new Error('Manifest must be an object');
+    // }
+    const res = await makeOfflineInternal(manifest);
+    let done = false;
+    let resultManifest;
+    async function* files() {
+        resultManifest = yield* res;
+        done = true;
+    }
+    return {
+        get manifest() {
+            if (!done)
+                throw new Error('Iterate over files before getting manifest');
+            return resultManifest;
+        },
+        files: files(),
+    };
+}
+async function* makeOfflineInternal(manifest) {
+    log('makeOfflineInternal', manifest);
+    const resolveContext = {
+        refCache: new Map(),
+        forceFetch: true,
+        signal: null,
+    };
+    const parent = { manifest };
+    yield* walk(parent, 'manifest');
+    return parent.manifest;
+    async function* walk(node, key) {
+        // console.log('walk', node, key, node[key]);
+        // let node[key] = node[key];
+        if (typeof node[key] !== 'object' || node[key] === null) {
+            return;
+        }
+        // let resolversToUse1 = resolvers.filter((r) => r.canResolve(node[key].$ref));
+        // const usedResolvers = new Set<Resolver>();
+        // do {
+        if ('$ref' in node[key]) {
+            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}`);
+            }
+            if (resolversToUse.length > 1) {
+                throw new Error(`Multiple resolvers can make offline ref: ${node[key].$ref}`);
+            }
+            const resolver = resolversToUse[0];
+            let func;
+            switch (resolver.offlineMethod) {
+                case 'localizeRef':
+                    func = offlineLocalizeRef;
+                    break;
+                case 'resolveRef':
+                    func = offlineResolveRef;
+                    break;
+                default:
+                    throw new Error(`Unknown offlineMethod: ${resolver.offlineMethod}`);
+            }
+            const mergeRef = yield* func(resolver, node[key].$ref, resolveContext);
+            if (Object.isFrozen(node[key]))
+                throw new Error('Unexpected frozen node during makeOffline');
+            node[key] = createMergedObjectWithOverridenNonRefProps({ $ref: mergeRef }, node[key]);
+        }
+        // recurse
+        if (Array.isArray(node[key])) {
+            for (const [index] of node[key].entries()) {
+                yield* walk(node[key], index);
+            }
+        }
+        else if (typeof node[key] === 'object' && node[key] !== null) {
+            for (const key1 of Object.keys(node[key])) {
+                // debugger;
+                yield* walk(node[key], key1);
+            }
+        }
+    }
+}
+// function canResolve(resolver: Resolver, ref: string): boolean {
+//   if (resolver.canResolve) {
+//     return resolver.canResolve(ref);
+//   }
+//   if (resolver.schema) {
+//     return canResolveRefSchema(ref, resolver.schema);
+//   }
+//   throw new Error('Resolver is missing canResolve method and schema property');
+// }
+async function* offlineLocalizeRef(resolver, ref, context) {
+    const refData = deepClone(await resolverResolve(resolver, ref, context));
+    // emit assets
+    yield* makeOfflineInternal(refData);
+    const url = parseRefValue(ref);
+    const targetFilePath = makeTargetPathFromUrl(url);
+    // TODO: handle CSS and other text files that may reference other assets
+    yield { url, targetFilePath };
+    const schema = ref.substring(0, ref.length - url.length - 1);
+    return `${schema}:${targetFilePath}`;
+}
+async function* offlineResolveRef(resolver, ref, context) {
+    const refData = deepClone(await resolverResolve(resolver, ref, context));
+    const targetFilePath = makeUniqueJsonTargetPathFromString(ref);
+    const data = yield* makeOfflineInternal(refData);
+    yield { data, targetFilePath };
+    return targetFilePath;
+}
+// export function createMakeOfflineResult(
+//   manifest: any,
+//   walk: (node: any, key: string | number) => AsyncGenerator<LocalFile>
+// ): MakeOfflineResult {
+//   log('createMakeOfflineResult', manifest);
+//   if (typeof manifest !== 'object' || manifest === null) {
+//     throw new Error('Manifest must be an object');
+//   }
+//   const parent = { manifest };
+//   let done = false;
+//   async function* files() {
+//     yield* walk(parent, 'manifest');
+//     done = true;
+//   }
+//   return {
+//     get manifest() {
+//       if (!done) {
+//         throw new Error('Cannot access manifest before all files are generated');
+//       }
+//       return parent.manifest;
+//     },
+//     files: files(),
+//   };
+// }