@expofp/loader 1.0.56 → 1.0.58

package/dist/esm/resolvers/assetResolver.js

@@ -0,0 +1,26 @@
+import { parseRefValue } from '../resolve';
+import { log } from '../shared';
+export function resolveAssetRefSync(ref) {
+    log('assetResolver resolveRef:', ref);
+    // if (!assetResolver.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
+    return parseRefValue(ref);
+}
+export const assetResolver = {
+    schema: 'asset',
+    resolveRef: async (ref) => resolveAssetRefSync(ref),
+    offlineMethod: 'localizeRef',
+};
+// async *makeOfflineRef(ref: string) {
+//   log('assetResolver makeOfflineRef:', ref);
+//   if (!this.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
+//   const url = parseRefValue(ref);
+//   const targetFilePath = makeTargetPathFromUrl(url);
+//   yield { url, targetFilePath };
+//   return { $ref: `asset:${targetFilePath}`, [STOP_RESOLVING]: true };
+// },
+// async *makeOfflineRef2(ref: string) {
+//   const url = parseRefValue(ref);
+//   const targetFilePath = makeTargetPathFromUrl(url);
+//   yield { url, targetFilePath };
+//   return `asset:${targetFilePath}`;
+// },

package/dist/{resolvers → esm/resolvers}/bundleAssetsResolver.d.ts

@@ -1,2 +1,2 @@
-import { Resolver } from '../types';
+import type { Resolver } from '../types';
 export declare const bundleAssetsResolver: Resolver;

package/dist/esm/resolvers/bundleAssetsResolver.js

@@ -0,0 +1,20 @@
+import { importJson } from '../importJson';
+import { parseRefValue } from '../resolve';
+import { returnCachedRef } from '../returnCachedRef';
+import { log } from '../shared';
+export const bundleAssetsResolver = {
+    schema: 'bundle-assets',
+    async resolveRef(ref, context) {
+        log('bundleAssetsResolver resolveRef:', ref);
+        const url = parseRefValue(ref);
+        return returnCachedRef(ref, context.refCache, async () => {
+            const files = await importJson(url, context);
+            const baseUrl = url.substring(0, url.lastIndexOf('/') + 1);
+            const assets = files.map((file) => ({
+                $ref: `asset+${baseUrl}${file}`,
+            }));
+            return assets;
+        });
+    },
+    offlineMethod: 'localizeRef',
+};

package/dist/{resolvers → esm/resolvers}/expoRuntimeBranchResolver.d.ts

@@ -1,2 +1,2 @@
-import { Resolver } from '../types';
+import type { Resolver } from '../types';
 export declare const expoRuntimeBranchResolver: Resolver;

package/dist/esm/resolvers/expoRuntimeBranchResolver.js

@@ -0,0 +1,20 @@
+import { importJson } from '../importJson';
+import { parseRefValue } from '../resolve';
+import { returnCachedRef } from '../returnCachedRef';
+import { log } from '../shared';
+const BASE_URL = 'https://efp-runtime.expofp.com/';
+export const expoRuntimeBranchResolver = {
+    schema: 'expo-runtime-branch',
+    async resolveRef(ref, context) {
+        log('expoRuntimeBranchResolver resolveRef:', ref);
+        const branch = parseRefValue(ref);
+        const branchUrl = `${BASE_URL}branches/${branch}.json`;
+        return returnCachedRef(ref, context.refCache, async () => {
+            const release = await importJson(branchUrl, context);
+            return {
+                $ref: `expo-runtime+https://efp-runtime.expofp.com/releases/${release}/`,
+            };
+        });
+    },
+    offlineMethod: 'resolveRef',
+};

package/dist/{resolvers → esm/resolvers}/expoRuntimeGetBranchResolver.d.ts

@@ -1,2 +1,2 @@
-import { Resolver } from '../types';
+import type { Resolver } from '../types';
 export declare const expoRuntimeGetBranchResolver: Resolver;

package/dist/esm/resolvers/expoRuntimeGetBranchResolver.js

@@ -0,0 +1,14 @@
+import { importJson } from '../importJson';
+import { parseRefValue } from '../resolve';
+import { log } from '../shared';
+// const SCHEMA = 'expo-runtime-get-branch';
+export const expoRuntimeGetBranchResolver = {
+    schema: 'expo-runtime-get-branch',
+    async resolveRef(ref, context) {
+        log('expoRuntimeGetBranchResolver resolveRef:', ref);
+        const expo = parseRefValue(ref);
+        const url = `https://${expo}.expofp.com/get-branch`;
+        return importJson(url, context);
+    },
+    offlineMethod: 'resolveRef',
+};

package/dist/{resolvers → esm/resolvers}/expoRuntimeResolver.d.ts

@@ -1,2 +1,2 @@
-import { Resolver } from '../types';
+import type { Resolver } from '../types';
 export declare const expoRuntimeResolver: Resolver;

package/dist/esm/resolvers/expoRuntimeResolver.js

@@ -0,0 +1,38 @@
+import { parseRefValue } from '../resolve';
+import { deepFreeze, log } from '../shared';
+// const SCHEMA = 'expo-runtime';
+export const expoRuntimeResolver = {
+    schema: 'expo-runtime',
+    // canResolve(ref: string) {
+    //   return canResolveRefSchema(ref, SCHEMA);
+    // },
+    async resolveRef(ref) {
+        log('expoRuntimeResolver resolveRef:', ref);
+        // if (!this.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
+        const url = parseRefValue(ref);
+        const data = {
+            entry: { $ref: `asset+${url}expofp.js` },
+            assets: { $ref: `bundle-assets+${url}bundle.json` },
+        };
+        deepFreeze(data);
+        return data;
+    },
+    //   async *makeOfflineRef(ref: string) {
+    //     log('expoRuntimeResolver makeOfflineRef:', ref);
+    //     if (!this.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
+    //     const url = parseRefValue(ref);
+    //     const refData = deepClone(await this.resolveRef(ref));
+    //     const targetFilePath = makeUniqueJsonTargetPathFromString(url, SCHEMA_PREFIX_BASE);
+    //     const data = yield* makeOfflineInternal(refData);
+    //     yield { data: data, targetFilePath };
+    //     return { $ref: targetFilePath, [STOP_RESOLVING]: true };
+    //   },
+    //   async *makeOfflineRef2(ref: string) {
+    //     const refData = deepClone(await this.resolveRef(ref));
+    //     const targetFilePath = makeUniqueJsonTargetPathFromString(ref);
+    //     const data = yield* makeOfflineInternal(refData);
+    //     yield { data, targetFilePath };
+    //     return targetFilePath;
+    //   },
+    offlineMethod: 'resolveRef',
+};

package/dist/{resolvers → 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>;
+    resolveRef(ref: string, context: import("../resolve").ResolveContextInternal): Promise<any>;
     offlineMethod: "resolveRef";
 };

package/dist/esm/resolvers/httpResolver.js

@@ -0,0 +1,14 @@
+import { importJson } from '../importJson';
+import { log } from '../shared';
+export const httpResolver = {
+    canResolve(ref) {
+        return ref.startsWith('http://') || ref.startsWith('https://') || ref.startsWith('./');
+    },
+    resolveRef(ref, context) {
+        log('httpResolver resolveRef:', ref);
+        if (!this.canResolve(ref))
+            throw new Error(`Unexpected ref in httpResolver: ${ref}`);
+        return importJson(ref, context);
+    },
+    offlineMethod: 'resolveRef',
+};

package/dist/{resolvers → esm/resolvers}/index.d.ts

@@ -1,2 +1,2 @@
-import { Resolver } from '../types';
+import type { Resolver } from '../types';
 export declare const resolvers: Resolver[];

package/dist/esm/resolvers/index.js

@@ -0,0 +1,18 @@
+import { assetResolver } from './assetResolver';
+import { bundleAssetsResolver } from './bundleAssetsResolver';
+import { expoRuntimeBranchResolver } from './expoRuntimeBranchResolver';
+import { expoRuntimeGetBranchResolver } from './expoRuntimeGetBranchResolver';
+import { expoRuntimeResolver } from './expoRuntimeResolver';
+import { httpResolver } from './httpResolver';
+import { legacyAssetUrlsResolver } from './legacyAssetUrlsResolver';
+import { legacyDataResolver } from './legacyDataResolver';
+export const resolvers = [
+    httpResolver,
+    bundleAssetsResolver,
+    assetResolver,
+    expoRuntimeResolver,
+    expoRuntimeBranchResolver,
+    expoRuntimeGetBranchResolver,
+    legacyDataResolver,
+    legacyAssetUrlsResolver,
+];

package/dist/{resolvers → esm/resolvers}/legacyAssetUrlsResolver.d.ts

@@ -1,4 +1,4 @@
-import { ResolveContextInternal } from '../resolve';
+import { type ResolveContextInternal } from '../resolve';
 export declare const legacyAssetUrlsResolver: {
     schema: string;
     resolveRef(ref: string, context: ResolveContextInternal): Promise<any>;

package/dist/esm/resolvers/legacyAssetUrlsResolver.js

@@ -0,0 +1,103 @@
+import { importJson } from '../importJson';
+import { loadAndWaitGlobal } from '../loadAndWaitGlobal';
+import { parseRefValue } from '../resolve';
+import { returnCachedRef } from '../returnCachedRef';
+import { log } from '../shared';
+export const legacyAssetUrlsResolver = {
+    schema: 'legacy-asset-urls',
+    resolveRef(ref, context) {
+        log('legacyAssetUrlsResolver resolveRef:', ref);
+        const signal = context.signal;
+        return returnCachedRef(ref, context.refCache, async () => {
+            const dataUrlBase = parseRefValue(ref);
+            // load version.js - it will contain "window.__fpDataVersion = "20251129003330106";"
+            const versionUrl = `${dataUrlBase}version.js`;
+            try {
+                await loadAndWaitGlobal(versionUrl, {
+                    globalVar: '__fpDataVersion',
+                    timeoutMs: 30_000,
+                    signal,
+                });
+                context.importCallback?.(versionUrl, 'script');
+            }
+            catch {
+                console.warn(`Could not load version.js at ${versionUrl}, proceeding without it`);
+            }
+            const version = globalThis.__fpDataVersion || (+new Date()).toString();
+            const filesUrl = `${dataUrlBase}files.json?v=${version}`;
+            const dataUrl = `${dataUrlBase}data.js?v=${version}`;
+            const filesPromise = importJson(filesUrl, context).catch(() => {
+                console.warn(`Could not load files.json at ${filesUrl}, proceeding without it`);
+                return [];
+            });
+            // data.js
+            const dataLoadPromise = loadAndWaitGlobal(dataUrl, {
+                globalVar: '__data',
+                signal,
+            });
+            context.importCallback?.(dataUrl, 'script');
+            // wf.data.js
+            const wfDataUrl = `${dataUrlBase}wf.data.js?v=${version}`;
+            const wfDataLoadPromise = loadAndWaitGlobal(wfDataUrl, {
+                globalVar: '__wfData',
+                signal,
+            })
+                .then(() => {
+                context.importCallback?.(wfDataUrl, 'script');
+            })
+                .catch(() => {
+                console.warn(`Could not load wf.data.js at ${wfDataUrl}, proceeding without it`);
+            });
+            // fp.svg.js
+            delete globalThis.__fpLayers;
+            const fpSvgUrl = `${dataUrlBase}fp.svg.js?v=${version}`;
+            const fpSvgLoadPromise = loadAndWaitGlobal(fpSvgUrl, {
+                globalVar: '__fp',
+                signal,
+            });
+            context.importCallback?.(fpSvgUrl, 'script');
+            await Promise.all([filesPromise, dataLoadPromise, wfDataLoadPromise, fpSvgLoadPromise]);
+            const __fpLayers = (globalThis.__fpLayers ?? []);
+            const fpLayerFiles = __fpLayers.map((x) => `fp.svg.${x.name}.js`);
+            for (const layerFile of fpLayerFiles) {
+                const layerUrl = `${dataUrlBase}${layerFile}?v=${version}`;
+                context.importCallback?.(layerUrl, 'script');
+            }
+            const files = await filesPromise;
+            const data = globalThis.__data || {};
+            const dataFiles = [...files, 'data.js', 'wf.data.js', 'fp.svg.js', ...fpLayerFiles];
+            const dataFilesAssets = dataFiles.reduce((map, file) => {
+                map[file] = { $ref: `asset+${dataUrlBase}${file}?v=${version}` };
+                return map;
+            }, {});
+            return { ...dataFilesAssets, ...populateDataJsAssetsMap(dataUrlBase, data) };
+        });
+    },
+    offlineMethod: 'resolveRef',
+};
+function populateDataJsAssetsMap(dataUrlBase, data) {
+    const links = new Set();
+    function addLink(link) {
+        if (typeof link === 'string' && link.length > 0) {
+            // if (!link.startsWith('http://') && !link.startsWith('https://')) {
+            //   link = dataUrlBase + link;
+            // }
+            links.add(link);
+        }
+    }
+    addLink(data.logo);
+    data.exhibitors?.forEach((e) => {
+        addLink(e.logo);
+        e.gallery?.forEach((img) => addLink(img));
+    });
+    data.events?.forEach((e) => {
+        addLink(e.logoFile);
+        e.speakers?.forEach((s) => {
+            addLink(s.photoFile);
+        });
+    });
+    return Array.from(links).reduce((map, link) => {
+        map[link] = { $ref: `asset+${dataUrlBase}${link}` };
+        return map;
+    }, {});
+}

package/dist/{resolvers → esm/resolvers}/legacyDataResolver.d.ts

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

package/dist/esm/resolvers/legacyDataResolver.js

@@ -0,0 +1,17 @@
+import { parseRefValue } from '../resolve';
+import { returnCachedRef } from '../returnCachedRef';
+import { log } from '../shared';
+export const legacyDataResolver = {
+    schema: 'legacy-data',
+    resolveRef(ref, context) {
+        log('legacyDataResolver resolveRef:', ref);
+        return returnCachedRef(ref, context.refCache, async () => {
+            const dataUrlBase = parseRefValue(ref);
+            return {
+                _to_remove_for_offline_to_work_dataUrlBase: dataUrlBase,
+                legacyAssetUrls: { $ref: `legacy-asset-urls+${dataUrlBase}` },
+            };
+        });
+    },
+    offlineMethod: 'resolveRef',
+};

package/dist/esm/returnCachedRef.js

@@ -0,0 +1,12 @@
+import { deepFreeze } from './shared';
+export async function returnCachedRef(ref, refCache, factory) {
+    if (refCache.has(ref)) {
+        return refCache.get(ref);
+    }
+    const promise = factory().then((data) => {
+        deepFreeze(data);
+        return data;
+    });
+    refCache.set(ref, promise);
+    return promise;
+}

package/dist/esm/shared.js

@@ -0,0 +1,271 @@
+import { logger } from './logger';
+import { resolve } from './resolve';
+// export const NOT_APPLICABLE = Symbol('not-applicable');
+// export const STOP_RESOLVING = Symbol('STOP_RESOLVING');
+export function createFunction(name) {
+    return async (manifest, ...args) => {
+        try {
+            const runtimeEntryPoint = await resolve(manifest, '/runtime/entry');
+            const moduleExports = await import(/* @vite-ignore */ runtimeEntryPoint);
+            const functionToCall = moduleExports[name];
+            return functionToCall(manifest, ...args);
+        }
+        catch (error) {
+            console.error('efp-loader', `Error when trying to import and call "${name}":`, error);
+            throw error;
+        }
+    };
+}
+export function log(...args) {
+    // if (!(globalThis as any).__EFP_LOADER_DEBUG__ && !import.meta.env.DEV) return;
+    // console.debug('efp-loader', ...args);
+    logger(...args);
+}
+export function deepFreeze(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    Object.freeze(obj);
+    for (const key of Object.keys(obj)) {
+        const val = obj[key];
+        if (typeof val === 'object' && val !== null && !Object.isFrozen(val)) {
+            deepFreeze(val);
+        }
+    }
+    return obj;
+}
+export function deepClone(obj) {
+    if ('structuredClone' in globalThis) {
+        return globalThis.structuredClone(obj);
+    }
+    return JSON.parse(JSON.stringify(obj));
+}
+export function preloadJson(url) {
+    if (typeof document === 'undefined')
+        return; // SSR / Node
+    const link = document.createElement('link');
+    link.rel = 'preload';
+    link.as = 'fetch';
+    link.href = url;
+    link.crossOrigin = 'anonymous';
+    document.head.appendChild(link);
+}
+export function preconnectUrl(url) {
+    if (typeof document === 'undefined')
+        return; // SSR / Node
+    const link = document.createElement('link');
+    link.rel = 'preconnect';
+    link.href = url;
+    link.crossOrigin = 'anonymous';
+    document.head.appendChild(link);
+}
+// export function hashString(str: string): string {
+//   let hash = 0;
+//   for (let i = 0; i < str.length; i++) {
+//     const chr = str.charCodeAt(i);
+//     hash = (hash << 5) - hash + chr;
+//     hash |= 0; // force 32-bit int
+//   }
+//   // >>> 0 makes it unsigned (no '-' in front)
+//   return (hash >>> 0).toString(16); // hex, [0-9a-f]
+// }
+// Deterministic ID
+// export async function hashString(str: string): Promise<string> {
+//   const encoder = new TextEncoder();
+//   const data = encoder.encode(str);
+//   const digest = await crypto.subtle.digest('SHA-1', data);
+//   return bufferToHex(digest);
+// }
+// murmur32
+// export function hashString(str: string): string {
+//   let h = 0x811c9dc5;
+//   for (let i = 0; i < str.length; i++) {
+//     h ^= str.charCodeAt(i);
+//     h = Math.imul(h, 0x01000193);
+//   }
+//   return (h >>> 0).toString(16).padStart(24, '0');
+// }
+// function bufferToHex(buffer: ArrayBuffer): string {
+//   const bytes = new Uint8Array(buffer);
+//   let hex = '';
+//   for (let i = 0; i < bytes.length; i++) {
+//     const byteHex = bytes[i].toString(16).padStart(2, '0');
+//     hex += byteHex;
+//   }
+//   return hex;
+// }
+// export function mergeNonRefFields(target: any, source: any) {
+//   if (target === source) throw new Error('Cannot merge object with itself');
+//   // if source is primitive, throw
+//   if (source === null || typeof source !== 'object')
+//     throw new Error('Cannot merge non-object source');
+//   if (Array.isArray(source)) {
+//     throw new Error('mergeNonRefFields does not support merging arrays');
+//   }
+//   const nonRefKeys = Object.keys(source).filter((key) => key !== '$ref');
+//   if (nonRefKeys.length === 0) return;
+//   // throw if any is array
+//   if (Array.isArray(target)) {
+//     throw new Error('mergeNonRefFields does not support merging into arrays');
+//   }
+//   for (const key of nonRefKeys) {
+//     // if target is primitive, throw
+//     if (target === null || typeof target !== 'object')
+//       throw new Error('Cannot merge into non-object target');
+//     target[key] = source[key];
+//   }
+// }
+// export function mergeNonExitingFields(target: any, source: any) {
+//   if (target === source) throw new Error('Cannot merge object with itself');
+//   // if source is primitive, throw
+//   if (source === null || typeof source !== 'object')
+//     throw new Error('Cannot merge non-object source');
+//   if (Array.isArray(source)) {
+//     throw new Error('mergeNonExitingFields does not support merging arrays');
+//   }
+//   const keys = Object.keys(source);
+//   if (keys.length === 0) return;
+//   // throw if any is array
+//   if (Array.isArray(target)) {
+//     throw new Error('mergeNonExitingFields does not support merging into arrays');
+//   }
+//   for (const key of Object.keys(source)) {
+//     // if target is primitive, throw
+//     if (target === null || typeof target !== 'object')
+//       throw new Error('Cannot merge into non-object target');
+//     if (!(key in target)) {
+//       target[key] = source[key];
+//     }
+//   }
+// }
+// export function replaceObjectFields(target: any, source: any) {
+//   if (target === source) {
+//     throw new Error('Cannot replace object with itself');
+//   }
+//   // if source is primitive, throw
+//   if (source === null || typeof source !== 'object') {
+//     throw new Error('Cannot replace with non-object source');
+//   }
+//   // throw if any is array
+//   if (Array.isArray(target) || Array.isArray(source)) {
+//     throw new Error('replaceObjectFields does not support arrays');
+//   }
+//   // delete keys in target that are not in source
+//   for (const key of Object.keys(target)) {
+//     if (!(key in source)) {
+//       delete target[key];
+//     }
+//   }
+//   // copy keys from source to target
+//   for (const key of Object.keys(source)) {
+//     target[key] = source[key];
+//   }
+// }
+// export function isObject(v: any): boolean {
+//   return v !== null && typeof v === 'object' && !Array.isArray(v);
+// }
+// export function mergeOriginalFieldsIntoResolvedObject(target: any, source: any) {
+//   if (target === source) throw new Error('Cannot merge object with itself');
+//   // if source is primitive, throw
+//   if (source === null || typeof source !== 'object')
+//     throw new Error('Cannot merge non-object source');
+//   if (Array.isArray(source)) {
+//     throw new Error('Cannot merge arrays');
+//   }
+//   const nonRefKeys = Object.keys(source).filter((key) => key !== '$ref');
+//   if (nonRefKeys.length === 0) return;
+//   // throw if any is array
+//   if (Array.isArray(target)) {
+//     throw new Error('Cannot merge into arrays');
+//   }
+//   for (const key of nonRefKeys) {
+//     // if target is primitive, throw
+//     if (target === null || typeof target !== 'object')
+//       throw new Error('Cannot merge into non-object target');
+//     target[key] = source[key];
+//   }
+// }
+// export function createMergedObject(target: any, source: any) {
+//   if (target === source) return; //throw new Error('Cannot merge object with itself');
+//   // if source is primitive, throw
+//   if (source === null || typeof source !== 'object')
+//     throw new Error('Cannot merge non-object source');
+//   if (Array.isArray(source)) {
+//     throw new Error('Cannot merge arrays');
+//   }
+//   const nonRefKeys = Object.keys(source).filter((key) => key !== '$ref');
+//   if (nonRefKeys.length === 0) return target;
+//   // throw if any is array
+//   if (Array.isArray(target)) {
+//     throw new Error('Cannot merge into arrays');
+//   }
+//   if (target === null || typeof target !== 'object') {
+//     throw new Error('Cannot merge into non-object target');
+//   }
+//   const result = { ...target };
+//   for (const key of nonRefKeys) {
+//     result[key] = source[key];
+//   }
+//   deepFreeze(result);
+//   return result;
+// }
+export function createMergedObjectWithOverridenNonRefProps(target, source) {
+    if (target === source)
+        return; //throw new Error('Cannot merge object with itself');
+    // if source is primitive, throw
+    if (source === null || typeof source !== 'object')
+        throw new Error('Cannot merge non-object source');
+    if (Array.isArray(source)) {
+        throw new Error('Cannot merge arrays');
+    }
+    const nonRefKeys = Object.keys(source).filter((key) => key !== '$ref');
+    if (nonRefKeys.length === 0)
+        return deepClone(target);
+    // throw if any is array
+    if (Array.isArray(target)) {
+        throw new Error('Cannot merge into arrays');
+    }
+    if (target === null || typeof target !== 'object') {
+        throw new Error('Cannot merge into non-object target');
+    }
+    const result = deepClone({ ...target });
+    for (const key of nonRefKeys) {
+        result[key] = source[key];
+    }
+    // deepFreeze(result);
+    return result;
+}
+export function replaceObjectFields(target, source) {
+    if (target === source) {
+        return;
+        // throw new Error('Cannot replace object with itself');
+    }
+    // if source is primitive, throw
+    if (source === null || typeof source !== 'object') {
+        throw new Error('Cannot replace with non-object source');
+    }
+    // if target is primitive, throw
+    if (target === null || typeof target !== 'object') {
+        throw new Error('Cannot replace non-object target');
+    }
+    if (Array.isArray(target)) {
+        if (!Array.isArray(source)) {
+            throw new Error('replaceObjectFields does not support mixing arrays and objects');
+        }
+        // both are arrays - replace contents
+        target.length = 0;
+        for (const item of source) {
+            target.push(item);
+        }
+        return;
+    }
+    // delete keys in target that are not in source
+    for (const key of Object.keys(target)) {
+        if (!(key in source)) {
+            delete target[key];
+        }
+    }
+    // copy keys from source to target
+    for (const key of Object.keys(source)) {
+        target[key] = source[key];
+    }
+}

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

@@ -1,4 +1,4 @@
-import { ResolveContextInternal } from './resolve';
+import type { ResolveContextInternal } from './resolve';
 export interface Resolver {
     schema?: string;
     canResolve?(ref: string): boolean;

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};