@expofp/utils 3.1.15 → 3.2.0

package/dist/lib/import-json.js

@@ -3,62 +3,67 @@ import { deepFreeze } from './deep-freeze.js';
 import { fetchWithRetry } from './fetch-with-retry.js';
 import { importFsPromises } from './import-fs-promises.js';
 const log = debug('efp:utils:importJson');
-let importJsonNotAvailable;
 const jsonFrozen = new WeakSet();
+// undefined = untried, function = works, null = known broken (Safari 14, CSP, etc.)
+let importJsonNative;
 // 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, options) {
-    const opts = {
-        forceFetch: options?.forceFetch || false,
-        fetchCache: options?.fetchCache || new Map(),
-        importCallback: options?.importCallback,
-        signal: options?.signal || null,
-    };
-    // console.warn('importJson:', resolveContext.forceFetch);
-    if (importJsonNotAvailable === undefined && !opts.forceFetch) {
+// Cons: can have CSP issues in some environments.
+// Lazy + try/caught: Safari 14's parser rejects the two-argument import() form at
+// new Function() construction time, before any feature-detect call site can run.
+function getImportJsonNative() {
+    if (importJsonNative === undefined) {
         try {
-            await importJsonNative(url);
-            importJsonNotAvailable = false;
+            importJsonNative = new Function('url', 'return import(url, { with: { type: "json" } });');
         }
         catch {
             log('Dynamic import not available');
-            importJsonNotAvailable = true;
+            importJsonNative = null;
         }
     }
-    let result = undefined;
-    if (!importJsonNotAvailable && !opts.forceFetch) {
-        log('Dynamic import', url);
-        const module = await importJsonNative(url);
-        result = module.default;
-    }
-    else if (url.startsWith('file:') && !opts.forceFetch) {
-        log('Read from file system', url);
-        result = await readJsonFromFs(new URL(url));
+    return importJsonNative ?? undefined;
+}
+export async function importJson(url, options) {
+    const forceFetch = options?.forceFetch ?? false;
+    const fetchCache = options?.fetchCache ?? new Map();
+    const signal = options?.signal ?? null;
+    let result;
+    const native = !forceFetch ? getImportJsonNative() : undefined;
+    if (native) {
+        try {
+            log('Dynamic import', url);
+            const module = await native(url);
+            result = module.default;
+        }
+        catch {
+            log('Dynamic import not available');
+            importJsonNative = null;
+        }
     }
-    else {
-        log('Fetch', url);
-        result = await loadJson(url, opts.fetchCache, opts.signal || null);
+    if (result === undefined) {
+        if (url.startsWith('file:') && !forceFetch) {
+            log('Read from file system', url);
+            result = await readJsonFromFs(new URL(url));
+        }
+        else {
+            log('Fetch', url);
+            result = await loadJson(url, fetchCache, signal);
+        }
     }
-    // log('Callback for imported JSON URL:', url, !!opts.importCallback);
-    opts.importCallback?.(url);
-    // Freeze the imported JSON to make it immutable
-    // This is rather a guard against accidental mutations
+    options?.importCallback?.(url);
+    // Guard against accidental mutations of the imported JSON
     if (typeof result === 'object' && result !== null && !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() {
-        // in browser just use fetch, for node - fetch-retry
+    const dataPromise = (async () => {
         const response = await fetchWithRetry(url, { signal });
         if (!response.ok) {
             throw new Error(`Failed to fetch JSON from ${url}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/utils",
-  "version": "3.1.15",
+  "version": "3.2.0",
   "type": "module",
   "description": "ExpoFP SDK internal: shared utilities",
   "homepage": "https://developer.expofp.com/",