remote-components 0.0.50 → 0.0.51

package/dist/internal/shared/client/protected-rc-fallback.cjs

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var protected_rc_fallback_exports = {};
+__export(protected_rc_fallback_exports, {
+  generateProtectedRcFallbackSrc: () => generateProtectedRcFallbackSrc
+});
+module.exports = __toCommonJS(protected_rc_fallback_exports);
+var import_constants = require("#internal/shared/constants");
+function generateProtectedRcFallbackSrc(url) {
+  return `${import_constants.RC_PROTECTED_REMOTE_FETCH_PATHNAME}?url=${encodeURIComponent(url)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateProtectedRcFallbackSrc
+});
+//# sourceMappingURL=protected-rc-fallback.cjs.map

package/dist/internal/shared/client/protected-rc-fallback.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/client/protected-rc-fallback.ts"],"sourcesContent":["import { RC_PROTECTED_REMOTE_FETCH_PATHNAME } from '#internal/shared/constants';\n\n/**\n * Generates a fallback URL that proxies the request through the host's protected remote fetch endpoint\n */\nexport function generateProtectedRcFallbackSrc(url: string): string {\n  return `${RC_PROTECTED_REMOTE_FETCH_PATHNAME}?url=${encodeURIComponent(url)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAmD;AAK5C,SAAS,+BAA+B,KAAqB;AAClE,SAAO,GAAG,2DAA0C,mBAAmB,GAAG;AAC5E;","names":[]}

package/dist/internal/shared/client/protected-rc-fallback.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a fallback URL that proxies the request through the host's protected remote fetch endpoint
+ */
+declare function generateProtectedRcFallbackSrc(url: string): string;
+
+export { generateProtectedRcFallbackSrc };

package/dist/internal/shared/client/protected-rc-fallback.js

@@ -0,0 +1,8 @@
+import { RC_PROTECTED_REMOTE_FETCH_PATHNAME } from "#internal/shared/constants";
+function generateProtectedRcFallbackSrc(url) {
+  return `${RC_PROTECTED_REMOTE_FETCH_PATHNAME}?url=${encodeURIComponent(url)}`;
+}
+export {
+  generateProtectedRcFallbackSrc
+};
+//# sourceMappingURL=protected-rc-fallback.js.map

package/dist/internal/shared/client/protected-rc-fallback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/shared/client/protected-rc-fallback.ts"],"sourcesContent":["import { RC_PROTECTED_REMOTE_FETCH_PATHNAME } from '#internal/shared/constants';\n\n/**\n * Generates a fallback URL that proxies the request through the host's protected remote fetch endpoint\n */\nexport function generateProtectedRcFallbackSrc(url: string): string {\n  return `${RC_PROTECTED_REMOTE_FETCH_PATHNAME}?url=${encodeURIComponent(url)}`;\n}\n"],"mappings":"AAAA,SAAS,0CAA0C;AAK5C,SAAS,+BAA+B,KAAqB;AAClE,SAAO,GAAG,0CAA0C,mBAAmB,GAAG;AAC5E;","names":[]}

package/dist/internal/shared/client/remote-component.cjs

@@ -324,6 +324,17 @@ function createRSCStream(rscName, data) {
   });
 }
 
+// src/shared/constants.ts
+var RC_PROTECTED_REMOTE_FETCH_PATHNAME = "/rc-fetch-protected-remote";
+
+// src/shared/client/protected-rc-fallback.ts
+function generateProtectedRcFallbackSrc(url) {
+  return `${RC_PROTECTED_REMOTE_FETCH_PATHNAME}?url=${encodeURIComponent(url)}`;
+}
+
+// src/shared/client/webpack-patterns.ts
+var NEXT_BUNDLE_PATH_RE = /\/_next\/\[.+\](?:%20| )/;
+
 // src/shared/client/script-loader.ts
 async function loadScripts(scripts) {
   await Promise.all(
@@ -331,28 +342,65 @@ async function loadScripts(scripts) {
       return new Promise((resolve, reject) => {
         const newSrc = new URL(
           // remove the remote component bundle name identifier from the script src
-          script.src.replace(/\/_next\/\[.+\](?<whitespace>%20| )/, "/_next/"),
+          script.src.replace(NEXT_BUNDLE_PATH_RE, "/_next/"),
           location.origin
         ).href;
-        const newScript = document.createElement("script");
-        newScript.onload = () => {
-          resolve();
-        };
-        newScript.onerror = () => {
-          reject(
-            new RemoteComponentsError(
-              `Failed to load <script src="${script.src}"> for Remote Component. Check the URL is correct.`
-            )
-          );
+        const loadScriptWithProtectedRcFallback = (src, isFallback = false) => {
+          const newScript = document.createElement("script");
+          newScript.onload = () => {
+            if (isFallback) {
+              logInfo(
+                "ScriptLoader",
+                `Successfully loaded <script src="${newSrc}"> using fallback.`
+              );
+            }
+            resolve();
+          };
+          newScript.onerror = () => {
+            if (!isFallback) {
+              const fallbackSrc = generateProtectedRcFallbackSrc(newSrc);
+              logWarn(
+                "ScriptLoader",
+                `Failed to load <script src="${newSrc}"> for Remote Component. Trying fallback with ${RC_PROTECTED_REMOTE_FETCH_PATHNAME} (withRemoteComponentsHost)...`
+              );
+              loadScriptWithProtectedRcFallback(fallbackSrc, true);
+            } else {
+              logError(
+                "ScriptLoader",
+                `Failed to load fallback for <script src="${newSrc}"> for Remote Component.`
+              );
+              reject(
+                new RemoteComponentsError(
+                  `Failed to load <script src="${newSrc}"> for Remote Component. Check the URL is correct.`
+                )
+              );
+            }
+          };
+          newScript.src = src;
+          newScript.async = true;
+          document.head.appendChild(newScript);
         };
-        newScript.src = newSrc;
-        newScript.async = true;
-        document.head.appendChild(newScript);
+        loadScriptWithProtectedRcFallback(newSrc);
       });
     })
   );
 }
 
+// src/shared/utils/index.ts
+function escapeString(str) {
+  return str.replace(/[^a-z0-9]/g, "_");
+}
+
+// src/shared/client/const.ts
+var DEFAULT_ROUTE = "/";
+var RUNTIME_WEBPACK = "webpack";
+var RUNTIME_TURBOPACK = "turbopack";
+var RUNTIME_SCRIPT = "script";
+var REMOTE_COMPONENT_REGEX = /(?<prefix>.*?)\[(?<bundle>[^\]]+)\](?:%20| )(?<id>.+)/;
+function getBundleKey(bundle) {
+  return escapeString(bundle);
+}
+
 // src/shared/utils/abort.ts
 function isAbortError(error) {
   if (error instanceof DOMException && error.name === "AbortError") {
@@ -365,8 +413,7 @@ function isAbortError(error) {
   return false;
 }
 
-// src/shared/ssr/fetch-with-protected-rc-fallback.ts
-var RC_PROTECTED_REMOTE_FETCH_PATHNAME = "/rc-fetch-protected-remote";
+// src/shared/client/fetch-with-protected-rc-fallback.ts
 async function fetchWithProtectedRcFallback(url, init) {
   try {
     const res = await fetch(url, init);
@@ -375,16 +422,21 @@ async function fetchWithProtectedRcFallback(url, init) {
     if (isAbortError(error)) {
       throw error;
     }
-    if (typeof document === "object" && typeof document.location === "object" && document.location.origin !== new URL(url).origin) {
-      logInfo(
+    const parsedUrl = new URL(url);
+    if (typeof document === "object" && typeof document.location === "object" && document.location.origin !== parsedUrl.origin) {
+      logWarn(
         "FetchRemoteComponent",
         "Request failed due to CORS, attempting to fetch it via the withRemoteComponentsHost proxy."
       );
       const proxiedRes = await fetch(
-        `${RC_PROTECTED_REMOTE_FETCH_PATHNAME}?url=${url}`,
+        generateProtectedRcFallbackSrc(parsedUrl.href),
         init?.signal ? { signal: init.signal } : void 0
       );
       if (proxiedRes.status === 200) {
+        logInfo(
+          "FetchRemoteComponent",
+          `Successfully fetched ${parsedUrl.href} with fallback withRemoteComponentsHost proxy`
+        );
         return proxiedRes;
       } else {
         logError(
@@ -397,28 +449,12 @@ async function fetchWithProtectedRcFallback(url, init) {
   }
 }
 
-// src/shared/utils/index.ts
-function escapeString(str) {
-  return str.replace(/[^a-z0-9]/g, "_");
-}
-
-// src/shared/client/const.ts
-var DEFAULT_ROUTE = "/";
-var RUNTIME_WEBPACK = "webpack";
-var RUNTIME_TURBOPACK = "turbopack";
-var RUNTIME_SCRIPT = "script";
-var REMOTE_COMPONENT_REGEX = /(?<prefix>.*?)\[(?<bundle>[^\]]+)\](?:%20| )(?<id>.+)/;
-function getBundleKey(bundle) {
-  return escapeString(bundle);
-}
-
 // src/shared/client/turbopack-patterns.ts
 var REMOTE_SHARED_MARKER_RE = /(?:self|[a-z])\.TURBOPACK_REMOTE_SHARED/;
 var REMOTE_SHARED_ASSIGNMENT_RE = /\.TURBOPACK_REMOTE_SHARED=await (?:__turbopack_context__|e)\.A\((?<sharedModuleId>[0-9]+)\)/;
 var ASYNC_MODULE_LOADER_RE = /(?:__turbopack_context__|e)\.A\((?<asyncSharedModuleId>[0-9]+)\)/;
 var ASYNC_MODULE_RESOLVE_RE = /(?<ctx>__turbopack_context__|e)=>\{\k<ctx>\.v\((?<inner>parentImport|e)=>Promise\.resolve\(\)\.then\(\(\)=>\k<inner>\((?<sharedModuleId>[0-9]+)\)\)\)\}/;
 var ASYNC_MODULE_ALL_RE = /(?<ctx>__turbopack_context__|e)=>\{\k<ctx>\.v\((?<vCb>parentImport|t)=>Promise\.all\(\["[^"]+"\]\.map\((?<mapCb>chunk|t)=>\k<ctx>\.l\(\k<mapCb>\)\)\)\.then\(\(\)=>\k<vCb>\((?<sharedModuleId>[0-9]+)\)\)\)\}/;
-var NUMERIC_MODULE_ID_RE = /^[0-9]+$/;
 var TURBOPACK_GLOBAL_RE = /(?:globalThis|self)\s*(?:\.TURBOPACK|\[\s*["']TURBOPACK["']\s*\])/;
 
 // src/shared/client/chunk-loader.ts
@@ -624,10 +660,14 @@ async function handleTurbopackChunk(code, bundle, url) {
 function handleTurbopackModule(bundle, moduleId, id) {
   const self = globalThis;
   const bundleKey = getBundleKey(bundle);
-  let modules = self[`TURBOPACK_${bundleKey}`];
-  if (modules && typeof modules === "object" && "__chunks__" in modules) {
-    const chunks = modules.__chunks__;
-    modules = chunks.flat();
+  const raw = self[`TURBOPACK_${bundleKey}`];
+  let modules;
+  if (raw && typeof raw === "object" && "__chunks__" in raw) {
+    modules = raw.__chunks__.flat();
+  } else if (Array.isArray(raw)) {
+    modules = raw.flat();
+  } else {
+    modules = raw;
   }
   if (!self.__remote_components_turbopack_modules__) {
     self.__remote_components_turbopack_modules__ = {};
@@ -656,13 +696,12 @@ function handleTurbopackModule(bundle, moduleId, id) {
   if (!self.__remote_components_turbopack_global__[bundle]) {
     self.__remote_components_turbopack_global__[bundle] = {};
   }
-  const allModules = Array.isArray(modules) ? modules.flat() : modules ? Object.values(modules) : [];
   moduleInit(
     createTurbopackContext(
       bundle,
       exports,
       moduleExports,
-      allModules,
+      modules,
       moduleInit,
       id,
       self
@@ -676,46 +715,27 @@ function handleTurbopackModule(bundle, moduleId, id) {
   return moduleExports.exports;
 }
 function findModuleInit(modules, moduleId) {
-  if (modules && !Array.isArray(modules) && typeof modules === "object") {
-    const normalizedId = NUMERIC_MODULE_ID_RE.test(moduleId) ? Number(moduleId) : moduleId;
-    if (normalizedId in modules) {
-      return modules[normalizedId];
-    }
-    if (typeof normalizedId === "number" && String(normalizedId) in modules) {
-      return modules[String(normalizedId)];
-    }
-    const matchingKey = Object.keys(modules).find(
-      (key) => typeof key === "string" && key.includes(String(moduleId))
+  if (!modules || typeof modules !== "object")
+    return;
+  if (!Array.isArray(modules)) {
+    const key = moduleId in modules ? moduleId : Object.keys(modules).find((k) => k.startsWith(moduleId));
+    return key !== void 0 ? modules[key] : void 0;
+  }
+  const flat = modules.flat();
+  let idx = flat.findIndex((e) => String(e) === String(moduleId));
+  if (idx < 0) {
+    idx = flat.findIndex(
+      (e) => typeof e === "string" && e.startsWith(moduleId)
     );
-    if (matchingKey) {
-      return modules[matchingKey];
-    }
-    logError("TurbopackModule", `No match found for module ID: ${moduleId}`);
-    return void 0;
   }
-  const allModules = modules?.flat() ?? [];
-  if (typeof allModules[1] === "string" || typeof allModules[1] === "number") {
-    const normalizedId = NUMERIC_MODULE_ID_RE.test(moduleId) ? Number(moduleId) : moduleId;
-    let moduleIdIndex = allModules.indexOf(normalizedId);
-    if (moduleIdIndex === -1) {
-      moduleIdIndex = allModules.findIndex(
-        (bundleEntry) => typeof bundleEntry === "string" && bundleEntry.startsWith(moduleId) || bundleEntry === normalizedId
-      );
-    }
-    if (moduleIdIndex !== -1) {
-      while (typeof allModules[moduleIdIndex] !== "function" && moduleIdIndex < allModules.length) {
-        moduleIdIndex++;
-      }
-      return allModules[moduleIdIndex];
-    }
-  } else {
-    return allModules.find(
-      (bundleEntry) => typeof bundleEntry === "object" && bundleEntry !== null && moduleId in bundleEntry
-    )?.[moduleId];
+  if (idx >= 0) {
+    return flat.slice(idx + 1).find((e) => typeof e === "function");
   }
-  return void 0;
+  return flat.find(
+    (e) => Boolean(e && typeof e === "object" && moduleId in e)
+  )?.[moduleId];
 }
-function createTurbopackContext(bundle, exports, moduleExports, allModules, moduleInit, id, self) {
+function createTurbopackContext(bundle, exports, moduleExports, modules, moduleInit, id, self) {
   return {
     // HMR not implemented for Remote Components
     k: {
@@ -836,13 +856,17 @@ function createTurbopackContext(bundle, exports, moduleExports, allModules, modu
         (parentId) => self.__webpack_require__?.(`[${bundle}] ${parentId}`)
       );
     },
+    // dynamic import tracking — no-op for remote components
+    j() {
+    },
     // chunk loader
     l(url) {
-      const moduleInitIndex = allModules.indexOf(moduleInit);
+      const flatModules = Array.isArray(modules) ? modules : [];
+      const moduleInitIndex = flatModules.indexOf(moduleInit);
       if (moduleInitIndex !== -1) {
-        const scriptIndex = allModules.slice(0, moduleInitIndex).findLastIndex((bundleEntry) => bundleEntry instanceof Element);
+        const scriptIndex = flatModules.slice(0, moduleInitIndex).findLastIndex((bundleEntry) => bundleEntry instanceof Element);
         if (scriptIndex !== -1) {
-          const script = allModules[scriptIndex];
+          const script = flatModules[scriptIndex];
           const scriptSrc = script.getAttribute("data-turbopack-src") || "";
           const nextIndex = scriptSrc.indexOf("/_next");
           const baseUrl = nextIndex !== -1 ? scriptSrc.slice(0, nextIndex) : "";
@@ -1251,6 +1275,89 @@ function setAttributesFromProps(el, props) {
 }
 
 // src/shared/client/static-loader.ts
+async function importViaProxy(absoluteSrc) {
+  const proxyUrl = new URL(
+    generateProtectedRcFallbackSrc(absoluteSrc),
+    location.href
+  ).href;
+  const response = await fetch(proxyUrl);
+  if (!response.ok)
+    throw new Error(`Proxy fetch failed: ${response.status}`);
+  logInfo(
+    "StaticLoader",
+    `Successfully loaded ${absoluteSrc} via protected RC proxy fallback.`
+  );
+  const content = (await response.text()).replace(/import\.meta\.url/g, JSON.stringify(absoluteSrc)).replace(
+    /\b(from|import)\s*(["'])(\.\.?\/[^"']+)\2/g,
+    (_, keyword, quote, relativePath) => {
+      const absoluteImportUrl = new URL(relativePath, absoluteSrc).href;
+      const absoluteProxyUrl = new URL(
+        generateProtectedRcFallbackSrc(absoluteImportUrl),
+        location.href
+      ).href;
+      return `${keyword} ${quote}${absoluteProxyUrl}${quote}`;
+    }
+  );
+  const moduleBlobUrl = URL.createObjectURL(
+    new Blob([content], { type: "text/javascript" })
+  );
+  const wrapperContent = [
+    `import*as m from${JSON.stringify(moduleBlobUrl)};`,
+    `globalThis.__rc_module_registry__=globalThis.__rc_module_registry__||{};`,
+    `globalThis.__rc_module_registry__[${JSON.stringify(absoluteSrc)}]=m;`
+  ].join("");
+  const wrapperBlobUrl = URL.createObjectURL(
+    new Blob([wrapperContent], { type: "text/javascript" })
+  );
+  const scriptEl = document.createElement("script");
+  scriptEl.type = "module";
+  scriptEl.src = wrapperBlobUrl;
+  try {
+    await new Promise((resolve, reject) => {
+      scriptEl.onload = () => resolve();
+      scriptEl.onerror = () => reject(new Error(`Failed to load module for ${absoluteSrc}`));
+      document.head.appendChild(scriptEl);
+    });
+  } finally {
+    scriptEl.remove();
+    URL.revokeObjectURL(moduleBlobUrl);
+    URL.revokeObjectURL(wrapperBlobUrl);
+  }
+  const registry = globalThis.__rc_module_registry__;
+  const mod = registry?.[absoluteSrc] ?? {};
+  if (registry)
+    delete registry[absoluteSrc];
+  return mod;
+}
+function resolveScriptSrc(script, url) {
+  const rawSrc = typeof script.getAttribute === "function" ? script.getAttribute("src") ?? script.src : script.src;
+  if (!rawSrc && script.textContent) {
+    return URL.createObjectURL(
+      new Blob(
+        [script.textContent.replace(/import\.meta\.url/g, JSON.stringify(url))],
+        { type: "text/javascript" }
+      )
+    );
+  }
+  return rawSrc;
+}
+async function importScriptMod(absoluteSrc) {
+  try {
+    return await import(
+      /* @vite-ignore */
+      /* webpackIgnore: true */
+      absoluteSrc
+    );
+  } catch (importError) {
+    if (absoluteSrc.startsWith("blob:"))
+      throw importError;
+    logWarn(
+      "StaticLoader",
+      `Direct import of ${absoluteSrc} failed, attempting via protected RC proxy fallback.`
+    );
+    return importViaProxy(absoluteSrc);
+  }
+}
 async function loadStaticRemoteComponent(scripts, url) {
   const self = globalThis;
   if (self.__remote_script_entrypoint_mount__?.[url.href]) {
@@ -1262,26 +1369,9 @@ async function loadStaticRemoteComponent(scripts, url) {
   const mountUnmountSets = await Promise.all(
     scripts.map(async (script) => {
       try {
-        let src = typeof script.getAttribute === "function" ? script.getAttribute("src") ?? script.src : script.src;
-        if (!src && script.textContent) {
-          const blob = new Blob(
-            [
-              script.textContent.replace(
-                /import\.meta\.url/g,
-                JSON.stringify(url)
-              )
-            ],
-            {
-              type: "text/javascript"
-            }
-          );
-          src = URL.createObjectURL(blob);
-        }
-        const mod = await import(
-          /* @vite-ignore */
-          /* webpackIgnore: true */
-          new URL(src, url).href
-        );
+        const src = resolveScriptSrc(script, url);
+        const absoluteSrc = new URL(src, url).href;
+        const mod = await importScriptMod(absoluteSrc);
         if (src.startsWith("blob:")) {
           URL.revokeObjectURL(src);
         }