@expofp/loader 1.0.78 → 1.0.91

package/dist/esm/ImportHttpRuntime.node.js

@@ -0,0 +1,139 @@
+import debug from 'debug';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import url from 'node:url';
+const log = debug('efp:loader:nodeImportHttpRuntime');
+const runtimeDirCache = new Map();
+function sha256Hex(input) {
+    return crypto.createHash('sha256').update(input).digest('hex');
+}
+function toRuntimeDirUrl(runtime) {
+    const u = new URL(runtime);
+    // Ensure we treat runtime as a file URL and strip the last segment
+    const pathname = u.pathname;
+    const idx = pathname.lastIndexOf('/');
+    u.pathname = idx >= 0 ? pathname.slice(0, idx + 1) : '/';
+    // Keep search/fragment off for directory identity
+    u.search = '';
+    u.hash = '';
+    return u;
+}
+function isSafeRelative(p) {
+    // Reject absolute paths, Windows drive paths, and parent traversal.
+    if (!p || p.startsWith('/') || p.startsWith('\\'))
+        return false;
+    if (/^[a-zA-Z]:[\\/]/.test(p))
+        return false;
+    const norm = path.posix.normalize(p.replace(/\\/g, '/'));
+    if (norm.startsWith('..') || norm.includes('/../'))
+        return false;
+    return true;
+}
+async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+async function fileExists(fp) {
+    try {
+        await fs.stat(fp);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function fetchJson(fetchImpl, url) {
+    const res = await fetchImpl(url);
+    if (!res.ok)
+        throw new Error(`Failed to fetch JSON ${url}: ${res.status} ${res.statusText}`);
+    return await res.json();
+}
+async function fetchToFile(fetchImpl, url, outPath) {
+    const res = await fetchImpl(url);
+    if (!res.ok)
+        throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+    const ab = await res.arrayBuffer();
+    await ensureDir(path.dirname(outPath));
+    await fs.writeFile(outPath, Buffer.from(ab));
+}
+function extractFileList(bundle) {
+    return bundle.files.map((f) => f.file);
+    // if (Array.isArray(bundle)) return bundle.slice();
+    // const fromKnown = bundle.files ?? bundle.assets ?? bundle.entries ?? undefined;
+    // if (Array.isArray(fromKnown)) return fromKnown.slice();
+    // // As a last resort, look for the first string[] field
+    // for (const v of Object.values(bundle)) {
+    //   if (Array.isArray(v) && v.every((x) => typeof x === 'string')) {
+    //     return (v as string[]).slice();
+    //   }
+    // }
+    // throw new Error(
+    //   'bundle.json has no recognizable file list (expected array or {files/assets/entries})'
+    // );
+}
+async function runWithConcurrency(items, concurrency, worker) {
+    const queue = items.slice();
+    const workers = Array.from({ length: Math.max(1, concurrency) }, async () => {
+        while (queue.length) {
+            const item = queue.shift();
+            await worker(item);
+        }
+    });
+    await Promise.all(workers);
+}
+/**
+ * Downloads an HTTP runtime bundle (bundle.json + all referenced files)
+ * into a stable temp folder hashed by the runtime directory URL,
+ * then imports expofp.js locally via file://.
+ */
+export async function nodeImportHttpRuntime(runtime, opts = {}) {
+    const { cacheRootDir = path.join(os.tmpdir(), 'efp-loader'), concurrency = 8, forceRedownload = false, fetchImpl = globalThis.fetch, } = opts;
+    log("Cache root dir: '%s'", cacheRootDir);
+    if (typeof fetchImpl !== 'function') {
+        throw new Error('No fetch() available. Use Node 18+ or pass fetchImpl (e.g. undici fetch).');
+    }
+    const runtimeDir = toRuntimeDirUrl(runtime);
+    const runtimeDirKey = runtimeDir.toString();
+    // One in-flight download/import per runtime dir
+    if (!forceRedownload && runtimeDirCache.has(runtimeDirKey)) {
+        return runtimeDirCache.get(runtimeDirKey);
+    }
+    const task = (async () => {
+        const hash = sha256Hex(runtimeDirKey).slice(0, 16);
+        const localRoot = path.join(cacheRootDir, hash);
+        await ensureDir(localRoot);
+        const bundleUrl = new URL('bundle.json', runtimeDir).toString();
+        log('Fetching bundle.json:', bundleUrl);
+        const bundle = (await fetchJson(fetchImpl, bundleUrl));
+        const files = extractFileList(bundle);
+        // Always include the entry file (from runtime) even if bundle.json forgot it
+        const entryName = path.posix.basename(new URL(runtime).pathname);
+        if (!files.includes(entryName))
+            files.unshift(entryName);
+        // Sanitize + normalize
+        const safeFiles = files.map((f) => f.replace(/\\/g, '/')).filter((f) => isSafeRelative(f));
+        if (safeFiles.length === 0) {
+            throw new Error(`bundle.json from ${bundleUrl} produced 0 safe files to download`);
+        }
+        log('Downloading files:', safeFiles.length, '->', localRoot);
+        await runWithConcurrency(safeFiles, concurrency, async (rel) => {
+            const outPath = path.join(localRoot, rel.split('/').join(path.sep));
+            if (!forceRedownload && (await fileExists(outPath)))
+                return;
+            const fileUrl = new URL(rel, runtimeDir).toString();
+            await fetchToFile(fetchImpl, fileUrl, outPath);
+        });
+        const localEntryPath = path.join(localRoot, entryName.split('/').join(path.sep));
+        if (!(await fileExists(localEntryPath))) {
+            throw new Error(`Entry file missing after download: ${localEntryPath} (from ${runtime})`);
+        }
+        const entryFileUrl = url.pathToFileURL(localEntryPath).toString();
+        log('Importing local runtime entry:', entryFileUrl);
+        // @ts-ignore - dynamic import URL string is fine in Node
+        const mod = (await import(entryFileUrl));
+        return mod;
+    })();
+    runtimeDirCache.set(runtimeDirKey, task);
+    return task;
+}

package/dist/esm/_OLD_resolveRuntimeUrl.d.ts

@@ -0,0 +1 @@
+export declare function resolveRuntimeUrl(manifest: any): Promise<string>;

package/dist/esm/_OLD_resolveRuntimeUrl.js

@@ -0,0 +1,10 @@
+// import $RefParser from '@apidevtools/json-schema-ref-parser';
+// import { log } from 'debug';
+import { resolve } from './resolve';
+export async function resolveRuntimeUrl(manifest) {
+    manifest = await resolve(manifest);
+    if (!manifest.runtime) {
+        throw new Error('Manifest is missing runtime');
+    }
+    return await resolve(manifest.runtime);
+}

package/dist/esm/fetch.d.ts

@@ -0,0 +1 @@
+export declare const fetch: (...args: Parameters<typeof window.fetch>) => ReturnType<typeof window.fetch>;

package/dist/esm/fetch.js

@@ -0,0 +1,14 @@
+let fn;
+export const fetch = async function fetch(...args) {
+    if (!fn) {
+        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+            fn = window.fetch.bind(window);
+        }
+        else {
+            const fr = await import('fetch-retry');
+            const fetchWithRetry = fr.default(globalThis.fetch);
+            fn = fetchWithRetry;
+        }
+    }
+    return fn.apply(null, args);
+};

package/dist/esm/importHttpRuntime.d.ts

@@ -0,0 +1 @@
+export declare function importHttpRuntime<TModule = any>(runtime: string): Promise<TModule>;

package/dist/esm/importHttpRuntime.js

@@ -0,0 +1,12 @@
+import { fetch } from './fetch';
+export async function importHttpRuntime(runtime) {
+    // if browser, use dynamic import
+    if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+        const module = await import(/* @vite-ignore */ runtime);
+        return module;
+    }
+    else {
+        const { nodeImportHttpRuntime } = await import('./ImportHttpRuntime.node');
+        return nodeImportHttpRuntime(runtime, { fetchImpl: fetch });
+    }
+}

package/dist/esm/index.d.ts

@@ -1,7 +1,10 @@
-export declare const mount: (manifest: unknown, ...args: IArguments[]) => Promise<any>;
-export declare const load: (manifest: unknown, ...args: IArguments[]) => Promise<any>;
-export declare const initialize: (manifest: unknown, ...args: IArguments[]) => Promise<any>;
-export declare function callFunction_Experimental(name: string, manifest: unknown, ...args: IArguments[]): Promise<any>;
-export { mutateManifest } from './mutateManifest';
-export { downloadOfflineZip, makeOfflineBundle, saveOfflineZip, makeOffline } from './offline';
-export { resolve } from './resolve';
+import { LoaderApi, Manifest, Ref } from './types';
+declare global {
+    const __efpLoaderBuildInfo: [version: string, builtAt: string] | undefined;
+}
+export declare function loadApi(manifest: Manifest | Ref | string, options?: {
+    fetchCallback?: (ref: string) => void;
+}): Promise<LoaderApi>;
+declare const api: LoaderApi;
+export declare function load(manifest: Manifest | Ref | string, ...args: unknown[]): Promise<unknown>;
+export default api;

package/dist/esm/index.js

@@ -1,24 +1,45 @@
-import { log } from './logger';
-import { createFunction } from './shared';
-const info = globalThis.__efpLoaderBuildInfo;
-if (info) {
-    log('Initialized', { version: info[0], builtAt: info[1] });
+import debug from 'debug';
+import { importHttpRuntime } from './importHttpRuntime';
+import { resolve } from './resolve';
+const log = debug('efp:loader');
+if (typeof __efpLoaderBuildInfo !== 'undefined') {
+    log('Initialized', { version: __efpLoaderBuildInfo[0], builtAt: __efpLoaderBuildInfo[1] });
 }
 else {
     log('Initialized');
 }
-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 async function loadApi(manifest, options) {
+    log('Loading manifest:', manifest);
+    if (typeof manifest === 'string') {
+        manifest = { $ref: manifest };
+    }
+    manifest = await resolve(manifest, { fetchCallback: options?.fetchCallback });
+    const runtime = await resolve(manifest.runtime, {
+        fetchCallback: options?.fetchCallback,
+    });
+    log('Resolved runtime URL:', runtime);
+    if (typeof runtime !== 'string') {
+        throw new Error('Resolved runtime is not a string ');
+    }
+    const api = await importHttpRuntime(runtime);
+    api.meta = { runtime };
+    return api; //{ ...api, runtime } as LoaderApi;
 }
-export { mutateManifest } from './mutateManifest';
-export { downloadOfflineZip, makeOfflineBundle, saveOfflineZip, makeOffline } from './offline';
-export { resolve } from './resolve';
-// preloadJson('https://efp-runtime.expofp.com/branches/main.json');
-// preconnectUrl('https://efp-runtime.expofp.com/');
+// allow calling api functions directly from here
+const api = new Proxy({}, {
+    get: (_, prop) => {
+        return async (...args) => {
+            const manifest = args[0];
+            const runtimeApi = await loadApi(manifest);
+            const fn = runtimeApi[prop];
+            if (typeof fn !== 'function') {
+                throw new Error(`API has no function named '${prop}'`);
+            }
+            return fn.apply(runtimeApi, args);
+        };
+    },
+});
+export async function load(manifest, ...args) {
+    return api.load(manifest, ...args);
+}
+export default api;

package/dist/esm/resolve.d.ts

@@ -1,45 +1,11 @@
-import type { Resolver } from './types';
-export interface ResolveContextInternal {
-    forceFetch: boolean;
-    refCache: Map<string, Promise<any>>;
-    /**
-     * Callback invoked when a URL is fetched or imported.
-     */
-    importCallback?: (url: string, type: 'json' | 'script') => void;
-    signal: AbortSignal | null;
-    preResolvedRefs?: Map<string, any>;
-}
-interface ResolveOptionsNotMutate extends Partial<ResolveContextInternal> {
-    mutate?: false;
+export type ResolveOptions = {
+    maxHops?: number;
     signal?: AbortSignal;
-}
-interface ResolveOptionMutate extends Omit<ResolveOptionsNotMutate, 'mutate'> {
-    /**
-     * Mutate original object during resolution.
-     */
-    mutate: true;
-}
-export type ResolveOptions = ResolveOptionsNotMutate | ResolveOptionMutate;
-/**
- * Resolves a value from an object using a JSON Pointer RFC 6901.
- *
- * @param object - The object to resolve the value from
- * @param jsonPointer - A JSON Pointer string that must start with '/'
- * @param options - Optional context for resolution, including cache and fetch callback
- * @returns A promise that resolves to the value at the specified JSON Pointer path
- * @throws {Error} If the JSON Pointer is not valid or if a $ref cannot be resolved
- *
- * @example
- * ```typescript
- * const obj = { foo: { bar: 'baz' } };
- * const result = await resolve(obj, '/foo/bar');
- * // result === 'baz'
- * ```
- */
-export declare function resolve(object: any, jsonPointer: string, options: ResolveOptionMutate): Promise<void>;
-export declare function resolve<T = any>(object: any, jsonPointer: string, options?: ResolveOptionsNotMutate): Promise<T>;
-export declare function resolverResolve(resolver: Resolver, ref: string, context: ResolveContextInternal): Promise<any>;
-export declare function canResolve(resolver: Resolver, ref: string): boolean;
-export declare function canResolveRefSchema(ref: string, prefixBase: string): boolean;
-export declare function parseRefValue(ref: string): string;
-export {};
+    onHop?: (info: {
+        hop: number;
+        ref: string;
+        via: 'import' | 'fetch';
+    }) => void;
+    fetchCallback?: (ref: string) => void;
+};
+export declare function resolve<T>(input: unknown, options?: ResolveOptions): Promise<T>;