npm - @expofp/loader - Versions diffs - 1.0.54 → 1.0.57 - Mend

@expofp/loader 1.0.54 → 1.0.57

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/dist/esm/offline/makeOfflineBundle copy.js ADDED Viewed

@@ -0,0 +1,92 @@
+// import { gunzipSync } from 'fflate';
+// import untar from 'js-untar';
+// import { log } from '../shared';
+// import { makeOffline } from './makeOffline';
+export {};
+// export async function* makeOfflineBundle(
+//   manifest: unknown
+// ): AsyncGenerator<{ path: string; data: ArrayBuffer }> {
+//   log('makeOfflineBundle', manifest);
+//   const offlineData = await makeOffline(manifest);
+//   for await (const file of offlineData.files) {
+//     if ('data' in file) {
+//       const jsonString = JSON.stringify(file.data, null, 2);
+//       yield {
+//         path: file.targetFilePath,
+//         data: new TextEncoder().encode(jsonString).buffer,
+//       };
+//     } else if ('url' in file) {
+//       const blob = await downloadFile(file.url);
+//       yield {
+//         path: file.targetFilePath,
+//         data: await blob.arrayBuffer(),
+//       };
+//     }
+//   }
+//   yield* generateJsLoaderFiles();
+//   const html = getIndexHtml(offlineData.manifest);
+//   yield {
+//     path: 'index.html',
+//     data: new TextEncoder().encode(html).buffer,
+//   };
+// }
+// const MAX_CONCURRENT_DOWNLOADS = 10;
+// const queue = new Set<Promise<Blob>>();
+// // have a queue to limit concurrent downloads
+// async function downloadFile(url: string): Promise<Blob> {
+//   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}`);
+//     }
+//     return await response.blob();
+//   })();
+//   queue.add(downloadPromise);
+//   try {
+//     return await downloadPromise;
+//   } finally {
+//     queue.delete(downloadPromise);
+//   }
+// }
+// async function* generateJsLoaderFiles(): AsyncGenerator<{ path: string; data: ArrayBuffer }> {
+//   const packageInfo = 'https://registry.npmjs.org/@expofp/js-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 js-loader file to zip:', file.name);
+//     yield { path: 'efp-js-loader/' + file.name, data: file.buffer };
+//   }
+// }
+// function getIndexHtml(manifest: unknown) {
+//   const html = `
+//  <!DOCTYPE html>
+// <script type="module">
+//   import { load } from './efp-js-loader/dist/loader.js';
+//   await load(${JSON.stringify(manifest)});
+//   console.info('🚀 FloorPlan loaded', floorplan);
+// </script>
+// `;
+//   return html;
+// }

package/dist/esm/offline/makeOfflineBundle.js ADDED Viewed

@@ -0,0 +1,64 @@
+import { log } from '../shared';
+import { makeOffline } from './makeOffline';
+import { resolve } from '..';
+export async function* makeOfflineBundle(manifest) {
+    log('makeOfflineBundle', manifest);
+    const offlineData = await makeOffline(manifest);
+    for await (const file of offlineData.files) {
+        if ('data' in file) {
+            const jsonString = JSON.stringify(file.data, null, 2);
+            yield {
+                path: file.targetFilePath,
+                data: new TextEncoder().encode(jsonString).buffer,
+            };
+        }
+        else if ('url' in file) {
+            const blob = await downloadFile(file.url);
+            yield {
+                path: file.targetFilePath,
+                data: await blob.arrayBuffer(),
+            };
+        }
+    }
+    // yield* generateJsLoaderFiles();
+    const html = await getIndexHtml(offlineData.manifest);
+    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) {
+            throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+        }
+        return await response.blob();
+    })();
+    queue.add(downloadPromise);
+    try {
+        return await downloadPromise;
+    }
+    finally {
+        queue.delete(downloadPromise);
+    }
+}
+async function getIndexHtml(manifest) {
+    const entryPoint = await resolve(manifest, '/runtime/entry');
+    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/slugify.js ADDED Viewed

@@ -0,0 +1,61 @@
+// Module-level caches
+const inputToSlug = new Map();
+const slugToInput = new Map();
+const WINDOWS_RESERVED = new Set([
+    "con", "prn", "aux", "nul",
+    "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9",
+    "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9",
+]);
+function makeBaseSlug(input) {
+    let slug = input
+        .normalize("NFKD")
+        // All non letters/numbers → "-"
+        .replace(/[^\p{Letter}\p{Number}]+/gu, "-")
+        // Collapse multiple "-"
+        .replace(/-+/g, "-")
+        // Trim "-" from start/end
+        .replace(/^-|-$/g, "")
+        .toLowerCase();
+    // Strip forbidden Windows characters just in case
+    slug = slug.replace(/[<>:"/\\|?*]/g, "");
+    // Windows forbids trailing space/period
+    slug = slug.replace(/[. ]+$/g, "");
+    // Fallback if everything was stripped
+    if (!slug)
+        slug = "file";
+    // Avoid bare reserved device names
+    if (WINDOWS_RESERVED.has(slug)) {
+        slug += "-file";
+    }
+    return slug;
+}
+export function slugifyFsUnique(input) {
+    // If we've seen this exact input before, return the same slug
+    const existing = inputToSlug.get(input);
+    if (existing)
+        return existing;
+    const base = makeBaseSlug(input);
+    let candidate = base;
+    let counter = 2;
+    while (true) {
+        const existingInput = slugToInput.get(candidate);
+        if (!existingInput) {
+            // Free slug → claim it for this input
+            slugToInput.set(candidate, input);
+            inputToSlug.set(input, candidate);
+            return candidate;
+        }
+        if (existingInput === input) {
+            // Same input somehow (super defensive)
+            inputToSlug.set(input, candidate);
+            return candidate;
+        }
+        // Collision: same slug already used by different input → add suffix
+        candidate = `${base}-${counter++}`;
+    }
+}
+// // Optional: to reset between runs/tests
+// export function resetSlugCache() {
+//   inputToSlug.clear();
+//   slugToInput.clear();
+// }

package/dist/esm/offline/tools.js ADDED Viewed

@@ -0,0 +1,69 @@
+import { hashString } from './hashString';
+import { slugifyFsUnique } from './slugify';
+export function makeUniqueJsonTargetPathFromString(str, namespace = '') {
+    // const hash = hashString(str);
+    let result = slugifyFsUnique(str); // + '-' + hash;
+    if (namespace) {
+        result = `${slugifyFsUnique(namespace)}$${result}`;
+    }
+    if (result.endsWith('/')) {
+        result += 'index.json';
+    }
+    else if (!result.endsWith('.json')) {
+        result += '.json';
+    }
+    return './' + result;
+    // handle directory case
+}
+export function makeTargetPathFromUrl(url, prefix = '') {
+    // https://example.com/dir1/dir2/a.js => "{prefix}{origin-slug}/dir1/dir2/a.js";
+    // https://example.com/dir1/dir2/a.js?params => "{prefix}{origin-slug}/dir1/dir2/a{paramsmd5hash}.js";
+    // use slugify.ts
+    try {
+        new URL(url);
+    }
+    catch {
+        debugger;
+    }
+    const urlObj = new URL(url);
+    const origin = `${urlObj.protocol}//${urlObj.host}`;
+    const originSlug = slugifyFsUnique(origin);
+    let pathname = urlObj.pathname;
+    let search = urlObj.search;
+    // if path doesn't end with extension, throw
+    if (!pathname.match(/\.[^\/]+$/)) {
+        throw new Error(`Cannot make target path from URL without file extension: ${url}`);
+    }
+    const extension = pathname.substring(pathname.lastIndexOf('.'));
+    let pathnameWithoutExtension = pathname.substring(0, pathname.lastIndexOf('.'));
+    // check the pathname contains only valid fs characters
+    const invalidPathnameChars = pathnameWithoutExtension.match(/[^a-zA-Z0-9\-._\/]/g);
+    if (invalidPathnameChars) {
+        const fixedPathnameWithoutExtension = slugifyFsUnique(pathnameWithoutExtension);
+        console.warn(`Warning: pathname contains invalid filesystem characters (${[
+            ...new Set(invalidPathnameChars),
+        ].join(', ')}), slugifying it: ${pathnameWithoutExtension}${extension} => ${fixedPathnameWithoutExtension}${extension}`);
+        pathnameWithoutExtension = fixedPathnameWithoutExtension;
+    }
+    pathname = pathnameWithoutExtension + extension;
+    if (pathname.length > 120) {
+        console.warn(`Warning: pathname is too long (${pathname.length} characters), truncating to 150 characters: ${pathname}`);
+        pathname = pathname.substring(0, 120 - extension.length) + extension;
+    }
+    if (search) {
+        // create a hash from search params
+        const hash = hashString(search);
+        const dotIndex = pathname.lastIndexOf('.');
+        if (dotIndex !== -1) {
+            pathname = `${pathname.slice(0, dotIndex)}.${hash}${pathname.slice(dotIndex)}`;
+        }
+        else {
+            pathname = `${pathname}${hash}`;
+        }
+    }
+    // // handle directory case
+    // if (pathname.endsWith('/')) {
+    //   pathname += '__index.json';
+    // }
+    return `./${prefix}${originSlug}${pathname}`;
+}

package/dist/{resolve.d.ts → esm/resolve.d.ts} RENAMED Viewed

@@ -1,4 +1,4 @@
-import { Resolver } from './types';
+import type { Resolver } from './types';
 export interface ResolveContextInternal {
     forceFetch: boolean;
     refCache: Map<string, Promise<any>>;

package/dist/esm/resolve.js ADDED Viewed

@@ -0,0 +1,331 @@
+import { resolvers } from './resolvers';
+import { createMergedObjectWithOverridenNonRefProps, deepFreeze, log, replaceObjectFields, } from './shared';
+const globalRefCache = new Map();
+/**
+ * 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 async function resolve(object, jsonPointer, options) {
+    log('Resolving:', jsonPointer, 'of', object, options);
+    if (typeof window !== 'undefined') {
+        window['__lastResolveObject'] = object;
+    }
+    const resolveContext = {
+        importCallback: options?.importCallback,
+        refCache: options?.refCache || globalRefCache,
+        forceFetch: !!options?.forceFetch,
+        signal: options?.signal || null,
+    };
+    if (typeof jsonPointer !== 'string') {
+        throw new Error(`Invalid JSON Pointer (not a string): ${jsonPointer}`);
+    }
+    if (!jsonPointer.startsWith('/')) {
+        throw new Error(`Invalid JSON Pointer: ${jsonPointer}`);
+    }
+    if (jsonPointer.length > 1 && jsonPointer.endsWith('/')) {
+        throw new Error(`Invalid JSON Pointer: ${jsonPointer}`);
+    }
+    // if (jsonPointer === '/') {
+    //   const result = await resolveObject(object, resolveContext);
+    //   if (options?.mutate) {
+    //     replaceObjectFields(object, result);
+    //   }
+    //   return result;
+    // }
+    let parts;
+    if (jsonPointer === '/') {
+        parts = [];
+    }
+    else {
+        parts = jsonPointer.substring(1).split('/');
+    }
+    if (parts.some((part) => part.length === 0))
+        throw new Error(`Invalid JSON Pointer (empty part): ${jsonPointer}`);
+    if (options?.mutate) {
+        // prepend parts with 'root'
+        parts.unshift('root');
+        const target = { root: object };
+        await resovlePartsRecursiveMutate(target, parts, 0, resolveContext);
+        replaceObjectFields(object, target.root);
+    }
+    else {
+        return await resovlePartsRecursive(object, parts, 0, resolveContext);
+    }
+    // prepend parts with 'root'
+    // parts.unshift('root');
+    // // if (parts.some((part) => part.length === 0))
+    // //   throw new Error(`Invalid JSON Pointer (empty part): ${jsonPointer}`);
+    // const target = { root: object };
+    // const value = await resovlePartsRecursiveMutate(
+    //   target,
+    //   // 'root',
+    //   parts,
+    //   0,
+    //   resolveContext
+    // );
+    // if (options?.mutate) {
+    //   replaceObjectFields(object, target.root);
+    // }
+    // log(`Resolved ${jsonPointer}:`, value);
+    // return value;
+}
+// TODO: use library for JSON Pointer resolution
+async function resovlePartsRecursiveMutate(node,
+// key: string,
+parts, partsIndex, context) {
+    const key = parts[partsIndex];
+    // console.warn('in', key);
+    await resolveObjectMutate(node, key, context);
+    if (partsIndex == parts.length - 1)
+        return;
+    if (node[key] === null || typeof node[key] !== 'object') {
+        // console.error('Cannot resolve path, encountered non-object:', node, key);
+        throw new Error(`Cannot resolve path, encountered non-object at part '${parts.slice(1).join('/')}', index ${partsIndex - 1}'`);
+    }
+    return await resovlePartsRecursiveMutate(node[key], parts, partsIndex + 1, context);
+}
+async function resolveObjectMutate(node, key, context) {
+    log('resolveObjectMutate:', node, key);
+    let obj = node[key];
+    const result = await resolveObject(obj, context);
+    if (result !== undefined)
+        node[key] = result;
+}
+// TODO: use library for JSON Pointer resolution
+async function resovlePartsRecursive(object, parts, index, context) {
+    // should return undefined if last part not found
+    // if not last part found - throw error
+    // do not resolve object if its children are not needed (needed part exist as key)
+    if (index === parts.length) {
+        // console.warn('Resolving last part:', object);
+        return await resolveObject(object, context);
+    }
+    if (object === null || typeof object !== 'object') {
+        throw new Error(`Cannot resolve path, encountered non-object at part '${parts.join('/')}', index ${index}'`);
+    }
+    const part = parts[index];
+    let child = object[part];
+    if (child === undefined) {
+        // console.warn('Resolving, part not found during resolve:', part, object);
+        const resolvedObject = await resolveObject(object, context);
+        child = resolvedObject[part];
+    }
+    return await resovlePartsRecursive(child, parts, index + 1, context);
+}
+async function resolveObject(object, context) {
+    log('resolveObject:', object);
+    let obj = object;
+    do {
+        if (typeof obj !== 'object' || obj === null || !('$ref' in obj)) {
+            return obj;
+        }
+        const resolversToUse = resolvers.filter((r) => canResolve(r, obj.$ref));
+        if (resolversToUse.length === 0) {
+            if (obj.$ref) {
+                throw new Error(`No resolver found for ref: ${obj.$ref}`);
+            }
+            deepFreeze(obj);
+            return obj;
+        }
+        if (resolversToUse.length > 1) {
+            throw new Error(`Multiple resolvers can resolve ref: ${obj.$ref}`);
+        }
+        const data = await resolverResolve(resolversToUse[0], obj.$ref, context);
+        obj = createMergedObjectWithOverridenNonRefProps(data, obj);
+    } while (true);
+}
+export async function resolverResolve(resolver, ref, context) {
+    if (!canResolve(resolver, ref)) {
+        throw new Error(`Unexpected ref: ${ref}`);
+    }
+    return resolver.resolveRef(ref, context);
+}
+export function canResolve(resolver, ref) {
+    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');
+}
+export function canResolveRefSchema(ref, prefixBase) {
+    const prefixes = [`${prefixBase}+`, `${prefixBase}:`];
+    for (const prefix of prefixes) {
+        if (ref.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function parseRefValue(ref) {
+    // look for anything before ":" or before +https:// or before +http://
+    // https://www -> https://www
+    // so some+base+https://www -> https://www
+    // base+https://www -> https://www
+    // base:abc -> abc
+    // "some-base" can contain only non-:
+    if (ref.startsWith('http://') || ref.startsWith('https://')) {
+        return ref;
+    }
+    // if it is something+http:// or something+https://
+    const plusHttpIndex = ref.indexOf('+http://');
+    const plusHttpsIndex = ref.indexOf('+https://');
+    if (plusHttpIndex !== -1) {
+        return ref.substring(plusHttpIndex + 1);
+    }
+    if (plusHttpsIndex !== -1) {
+        return ref.substring(plusHttpsIndex + 1);
+    }
+    // if it is something:abc
+    const colonIndex = ref.indexOf(':');
+    if (colonIndex !== -1) {
+        return ref.substring(colonIndex + 1);
+    }
+    throw new Error(`Error getting URL from: ${ref}, no valid prefix found`);
+}
+// export function parseRefValue(ref: string): string {
+//   // look for anything before ":" or before +https:// or before +http://
+//   // https://www -> https://www
+//   // so some+base+https://www -> https://www
+//   // base+https://www -> https://www
+//   // base:abc -> abc
+//   // "some-base" can contain only non-:
+//   if (ref.startsWith('http://') || ref.startsWith('https://')) {
+//     return ref;
+//   }
+//   // if it is something+http:// or something+https://
+//   const plusHttpIndex = ref.indexOf('+http://');
+//   const plusHttpsIndex = ref.indexOf('+https://');
+//   if (plusHttpIndex !== -1) {
+//     return ref.substring(plusHttpIndex + 1);
+//   }
+//   if (plusHttpsIndex !== -1) {
+//     return ref.substring(plusHttpsIndex + 1);
+//   }
+//   // if it is something:abc
+//   const colonIndex = ref.indexOf(':');
+//   if (colonIndex !== -1) {
+//     return ref.substring(colonIndex + 1);
+//   }
+//   throw new Error(`Error getting URL from: ${ref}, no valid prefix found`);
+//   // const prefixBase = ref.split('+')[0].split(':')[0];
+//   // if (!prefixBase) {
+//   //   throw new Error(`Invalid ref, missing prefix: ${ref}`);
+//   // }
+//   // return ref.substring(prefixBase.length + 1);
+//   // const prefixes = [`${prefixBase}+`, `${prefixBase}:`];
+//   // for (const prefix of prefixes) {
+//   //   if (ref.startsWith(prefix)) {
+//   //     const url = ref.substring(prefix.length);
+//   //     if (!url) {
+//   //       throw new Error(`Invalid ref, missing URL after prefix "${prefix}": ${ref}`);
+//   //     }
+//   //     return url;
+//   //   }
+//   // }
+//   // throw new Error(
+//   //   `Error getting URL from: ${ref}, none of the prefixes matched: ${prefixes.join(', ')}`
+//   // );
+// }
+// export function parseRefValue(ref: string, prefixBase: string): string {
+//   const prefixes = [`${prefixBase}+`, `${prefixBase}:`];
+//   for (const prefix of prefixes) {
+//     if (ref.startsWith(prefix)) {
+//       const url = ref.substring(prefix.length);
+//       if (!url) {
+//         throw new Error(`Invalid ref, missing URL after prefix "${prefix}": ${ref}`);
+//       }
+//       return url;
+//     }
+//   }
+//   throw new Error(
+//     `Error getting URL from: ${ref}, none of the prefixes matched: ${prefixes.join(', ')}`
+//   );
+// }
+// const importJsonNative = new Function('url', 'return import(url, { with: { type: "json" } });') as (
+//   url: string
+// ) => Promise<any>;
+if (typeof window !== 'undefined') {
+    window['__debugResolve'] = async function debugResolve(objectOrRef, refOrContext, context) {
+        let object;
+        let ref;
+        let resolveContext;
+        if (typeof objectOrRef === 'string') {
+            object = window['__lastResolveObject'];
+            ref = objectOrRef;
+            resolveContext = refOrContext;
+        }
+        else {
+            object = objectOrRef;
+            ref = refOrContext;
+            resolveContext = context;
+        }
+        return await resolve(object, ref, resolveContext);
+    };
+    // (window as any)['__dd'] = async function dd() {
+    //   const url = 'https://demo.expofp.com/manifest.json';
+    //   // const imp = import;
+    //   const zz = (await importJsonNative(url)).default;
+    //   console.warn('debugResolve demo manifest:', zz);
+    //   //   let object: any;
+    //   //   let ref: string;
+    //   //   let resolveContext: ResolveOptions | undefined;
+    //   //   if (typeof objectOrRef === 'string') {
+    //   //     object = (window as any)['__lastResolveObject'];
+    //   //     ref = objectOrRef;
+    //   //     resolveContext = refOrContext;
+    //   //   } else {
+    //   //     object = objectOrRef;
+    //   //     ref = refOrContext;
+    //   //     resolveContext = context;
+    //   //   }
+    //   //   return await resolve(object, ref, resolveContext);
+    // };
+}
+// if (index === parts.length - 1) {
+//   return await resolveObject(object, context);
+// }
+// if (object === null || typeof object !== 'object') {
+//   throw new Error(
+//     `Cannot resolve path, encountered non-object at part '${parts.join('/')}', index ${index}'`
+//   );
+// }
+// if (!(parts[0] in object)) {
+//   return undefined;
+// }
+// let partIndex = 0;
+// let currentObject = await resolveObject(object, context);
+// while (partIndex < parts.length) {
+//   const part = parts[partIndex];
+//   if (typeof currentObject !== 'object' || currentObject === null) {
+//     throw new Error(
+//       `Cannot resolve path, encountered non-object at part '${parts.join(
+//         '/'
+//       )}, index ${partIndex}'`
+//     );
+//   }
+//   // console.info(
+//   //   'resolvePath currentObject:',
+//   //   part,
+//   //   JSON.stringify(currentObject, null, 2),
+//   //   currentObject[part]
+//   // );
+//   // debugger;
+//   const child = currentObject[part];
+//   currentObject = await resolveObject(child, context);
+//   partIndex++;
+// }
+// return currentObject;

package/dist/esm/resolvers/_OLD_expoResolver.js ADDED Viewed

@@ -0,0 +1,49 @@
+// import { parseRefValue } from '../resolve';
+// import { log } from '../shared';
+// import type { Resolver } from '../types';
+// import { httpResolver } from './httpResolver';
+export {};
+// // const SCHEMA = 'expo';
+// export const expoResolver: Resolver = {
+//   // canResolve(ref: string) {
+//   //   return canResolveRefSchema(ref, SCHEMA);
+//   // },
+//   schema: 'expo',
+//   async resolveRef(ref: string) {
+//     log('expoResolver resolveRef:', ref);
+//     // if (!this.canResolve(ref)) throw new Error(`Unexpected ref in httpResolver: ${ref}`);
+//     const expo = parseRefValue(ref);
+//     // try to resolve {$ref: `https://${expo}.expofp.com/manifest.json`}
+//     try {
+//       return await httpResolver.resolveRef(`https://${expo}.expofp.com/manifest.json`);
+//     } catch (error) {
+//       log(`Falling back to legacyDataUrlBase (no manifest for '${expo}')`);
+//     }
+//     // ET: fallback, remove in the future, when all expos support manifest.json
+//     // and throw instead
+//     const data = {
+//       expo,
+//       runtime: { $ref: `expo-runtime-get-branch:${expo}` },
+//       legacyData: { $ref: `legacy-data:https://${expo}.expofp.com/data/` },
+//     };
+//     return data;
+//   },
+//   // async *makeOfflineRef(ref: string) {
+//   //   log('expoRuntimeBranchResolver makeOfflineRef:', ref);
+//   //   if (!this.canResolve(ref)) throw new Error(`Unexpected ref: ${ref}`);
+//   //   const value = parseRefValue(ref);
+//   //   const refData = deepClone(await this.resolveRef(ref));
+//   //   const targetFilePath = makeUniqueJsonTargetPathFromString(value, 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',
+// };