@expofp/loader 1.0.79 → 1.0.92

package/dist/esm/loadScript.js

@@ -1,166 +0,0 @@
-import debug from 'debug';
-import { fetch } from './fetch';
-const log = debug('efp:loader:loadScript');
-/**
- * @deprecated Use loadScript directly instead.
- * 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';
-}
-export async function loadScript(scriptUrl, signal) {
-    log('Loading', scriptUrl);
-    if (isBrowser()) {
-        await loadInBrowser(scriptUrl, signal);
-    }
-    else {
-        await loadInNode(scriptUrl, signal);
-    }
-}
-/* -------------------- Browser implementation -------------------- */
-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 (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/esm/logger.d.ts

@@ -1 +0,0 @@
-export declare function log(...args: any[]): void;

package/dist/esm/logger.js

@@ -1,5 +0,0 @@
-import debug from 'debug';
-const logger = debug('efp:loader');
-export function log(...args) {
-    logger(...args);
-}

package/dist/esm/mutateManifest.d.ts

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

package/dist/esm/mutateManifest.js

@@ -1,10 +0,0 @@
-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/downloadOfflineZip.d.ts

@@ -1,4 +0,0 @@
-export declare function downloadOfflineZip(manifest: unknown, extraFiles?: Array<{
-    path: string;
-    data: Uint8Array;
-}>): Promise<void>;

package/dist/esm/offline/downloadOfflineZip.js

@@ -1,15 +0,0 @@
-import { generateZip } from './generateZip';
-export async function downloadOfflineZip(manifest, extraFiles) {
-    // check browser only
-    if (typeof window === 'undefined' || typeof document === 'undefined') {
-        throw new Error('downloadOfflineZip can only be used in a browser environment');
-    }
-    // Generate archive
-    const blob = await generateZip(manifest, extraFiles);
-    // 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/generateZip.d.ts

@@ -1,4 +0,0 @@
-export declare function generateZip(manifest: unknown, extraFiles?: Array<{
-    path: string;
-    data: Uint8Array;
-}>): Promise<Blob>;

package/dist/esm/offline/generateZip.js

@@ -1,41 +0,0 @@
-import debug from 'debug';
-import JSZip from 'jszip';
-import { makeOfflineBundle } from './makeOfflineBundle';
-const log = debug('efp:loader:generateZip');
-const MAX_CONCURRENT_DOWNLOADS = 10;
-async function processConcurrently(iterator, concurrency, processor) {
-    const activePromises = new Set();
-    for await (const item of iterator) {
-        const promise = Promise.resolve(processor(item)).then(() => {
-            activePromises.delete(promise);
-        });
-        activePromises.add(promise);
-        if (activePromises.size >= concurrency) {
-            await Promise.race(activePromises);
-        }
-    }
-    await Promise.all(activePromises);
-}
-export async function generateZip(manifest, extraFiles) {
-    const zip = new JSZip();
-    const bundle = await makeOfflineBundle(manifest);
-    let hasFiles = false;
-    await processConcurrently(bundle, MAX_CONCURRENT_DOWNLOADS, (file) => {
-        log('Adding file to zip:', file.path, 'size:', file.data.byteLength);
-        zip.file(file.path, file.data);
-        hasFiles = true;
-    });
-    for (const extraFile of extraFiles ?? []) {
-        log('Adding extra file to zip:', extraFile.path, 'size:', extraFile.data.byteLength);
-        zip.file(extraFile.path, extraFile.data);
-        hasFiles = true;
-    }
-    if (!hasFiles) {
-        throw new Error('No files were added to the ZIP archive');
-    }
-    // Generate archive
-    const blob = await zip.generateAsync({ type: 'blob' });
-    // console.info('Manifest for HTML:', offlineData.manifest);
-    log('Generated offline ZIP bundle, size:', blob.size);
-    return blob;
-}

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

@@ -1 +0,0 @@
-export declare function hashString(str: string): string;

package/dist/esm/offline/hashString.js

@@ -1,16 +0,0 @@
-// 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.d.ts

@@ -1,14 +0,0 @@
-export declare function makeOffline(manifest: unknown): Promise<import("../types").MakeOfflineResult>;
-export declare function makeOfflineBundle(manifest: unknown): Promise<AsyncGenerator<{
-    path: string;
-    data: ArrayBuffer;
-}, any, any>>;
-export declare function generateZip(manifest: unknown, extraFiles?: Array<{
-    path: string;
-    data: Uint8Array;
-}>): Promise<Blob>;
-export declare function downloadOfflineZip(manifest: unknown, extraFiles?: Array<{
-    path: string;
-    data: Uint8Array;
-}>): Promise<void>;
-export declare function saveOfflineZip(manifest: unknown, path: string): Promise<void>;

package/dist/esm/offline/index.js

@@ -1,41 +0,0 @@
-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);
-}
-export async function generateZip(manifest, extraFiles) {
-    const { generateZip } = await import('./generateZip');
-    return await generateZip(manifest, extraFiles);
-}
-export async function downloadOfflineZip(manifest, extraFiles) {
-    const { downloadOfflineZip } = await import('./downloadOfflineZip');
-    return await downloadOfflineZip(manifest, extraFiles);
-}
-export async function saveOfflineZip(manifest, path) {
-    const { saveOfflineZip } = await import('./saveOfflineZip');
-    return await saveOfflineZip(manifest, path);
-}
-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['__debugDownloadOfflineZip'] = downloadOfflineZip;
-    window['__debugMakeOfflineBundle'] = makeOfflineBundle;
-    window['__debugLogOfflineManifestFiles'] = debugLogOfflineManifestFiles;
-}

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

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

package/dist/esm/offline/makeOffline.js

@@ -1,144 +0,0 @@
-import debug from 'debug';
-import { canResolve, parseRefValue, resolverResolve, } from '../resolve';
-import { resolvers } from '../resolvers';
-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) {
-    //   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]);
-        logWalk(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]) {
-            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}`);
-            }
-            if (resolversToUse.length > 1) {
-                throw new Error(`Multiple resolvers can make offline ref: ${node[key].$ref}`);
-            }
-            const resolver = resolversToUse[0];
-            let func;
-            switch (resolver.offlineFunc) {
-                case 'localizeRef':
-                    func = offlineLocalizeRef;
-                    break;
-                case 'resolveRef':
-                    func = offlineResolveRef;
-                    break;
-                default:
-                    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()) {
-                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(),
-//   };
-// }

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

@@ -1,4 +0,0 @@
-export declare function makeOfflineBundle(manifest: unknown): AsyncGenerator<{
-    path: string;
-    data: ArrayBuffer;
-}>;

package/dist/esm/offline/makeOfflineBundle.js

@@ -1,92 +0,0 @@
-import debug from 'debug';
-import { resolve } from '..';
-import { makeOffline } from './makeOffline';
-import { deepFreeze } from '../shared';
-const log = debug('efp:loader:makeOfflineBundle');
-export async function* makeOfflineBundle(manifest) {
-    log('Bundling', manifest);
-    deepFreeze(manifest);
-    const offlineData = await makeOffline(manifest);
-    const preResolvedRefs = new Map();
-    for await (const file of offlineData.files) {
-        if ('data' in file) {
-            preResolvedRefs.set(file.targetFilePath, file.data);
-            const jsonString = JSON.stringify(file.data, null, 2);
-            log('Bundling file with data', file.targetFilePath, jsonString);
-            yield {
-                path: file.targetFilePath,
-                data: new TextEncoder().encode(jsonString).buffer,
-            };
-        }
-        else if ('url' in file) {
-            const blob = await downloadFile(file.url);
-            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: 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,
-        };
-    }
-}
-const MAX_CONCURRENT_DOWNLOADS = 10;
-const queue = new Set();
-// have a queue to limit concurrent downloads
-async function downloadFile(url) {
-    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) {
-            // Rodion's bug. May be missing file.
-            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}`);
-            return;
-        }
-        return await response.blob();
-    })();
-    queue.add(downloadPromise);
-    try {
-        return await downloadPromise;
-    }
-    finally {
-        queue.delete(downloadPromise);
-    }
-}
-async function getIndexHtml(manifest, preResolvedRefs) {
-    const entryPoint = await resolve(manifest, '/runtime/entry', { preResolvedRefs });
-    const html = `
-<!DOCTYPE html>
-<script type="module">
-  import { load } from ${JSON.stringify(entryPoint)};
-  await load(${JSON.stringify(manifest)});
-  console.info('🚀 loaded');
-</script> 
-`;
-    return html;
-}

package/dist/esm/offline/saveOfflineZip.browser.d.ts

@@ -1 +0,0 @@
-export declare function saveOfflineZip(): void;

package/dist/esm/offline/saveOfflineZip.browser.js

@@ -1,3 +0,0 @@
-export function saveOfflineZip() {
-    throw new Error('saveOfflineZip is not available in the browser');
-}

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

@@ -1 +0,0 @@
-export declare function saveOfflineZip(manifest: unknown, path: string): Promise<void>;

package/dist/esm/offline/saveOfflineZip.js

@@ -1,16 +0,0 @@
-import { generateZip } from './generateZip';
-import fs from 'fs/promises';
-export async function saveOfflineZip(manifest, path) {
-    if (!path) {
-        throw new Error('Path is required to save the ZIP file');
-    }
-    // should be zip path
-    if (!path.endsWith('.zip')) {
-        throw new Error('The specified path must end with .zip');
-    }
-    // Generate archive
-    const blob = await generateZip(manifest);
-    const arrayBuffer = await blob.arrayBuffer();
-    await fs.writeFile(path, Buffer.from(arrayBuffer));
-    console.log('Generated offline ZIP bundle at', path);
-}

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

@@ -1 +0,0 @@
-export declare function slugifyFsUnique(input: string): string;