react-server-dom-webpack 19.0.0-canary-4c12339ce-20240408 → 19.0.0-canary-adb717393-20240411

package/cjs/react-server-dom-webpack-client.edge.development.js

@@ -245,7 +245,7 @@ chunks, nonce) {
   }
 }
 
-var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+var ReactDOMSharedInternals = ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
 
 function getCrossOriginString(input) {
   if (typeof input === 'string') {
@@ -256,16 +256,18 @@ function getCrossOriginString(input) {
 }
 
 // This client file is in the shared folder because it applies to both SSR and browser contexts.
-var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.ReactDOMCurrentDispatcher;
 function dispatchHint(code, model) {
-  var dispatcher = ReactDOMCurrentDispatcher.current;
+  var dispatcher = ReactDOMSharedInternals.d;
+  /* ReactDOMCurrentDispatcher */
 
   switch (code) {
     case 'D':
       {
         var refined = refineModel(code, model);
         var href = refined;
-        dispatcher.prefetchDNS(href);
+        dispatcher.D(
+        /* prefetchDNS */
+        href);
         return;
       }
 
@@ -275,11 +277,15 @@ function dispatchHint(code, model) {
 
         if (typeof _refined === 'string') {
           var _href = _refined;
-          dispatcher.preconnect(_href);
+          dispatcher.C(
+          /* preconnect */
+          _href);
         } else {
           var _href2 = _refined[0];
           var crossOrigin = _refined[1];
-          dispatcher.preconnect(_href2, crossOrigin);
+          dispatcher.C(
+          /* preconnect */
+          _href2, crossOrigin);
         }
 
         return;
@@ -294,9 +300,13 @@ function dispatchHint(code, model) {
 
         if (_refined2.length === 3) {
           var options = _refined2[2];
-          dispatcher.preload(_href3, as, options);
+          dispatcher.L(
+          /* preload */
+          _href3, as, options);
         } else {
-          dispatcher.preload(_href3, as);
+          dispatcher.L(
+          /* preload */
+          _href3, as);
         }
 
         return;
@@ -308,46 +318,58 @@ function dispatchHint(code, model) {
 
         if (typeof _refined3 === 'string') {
           var _href4 = _refined3;
-          dispatcher.preloadModule(_href4);
+          dispatcher.m(
+          /* preloadModule */
+          _href4);
         } else {
           var _href5 = _refined3[0];
           var _options = _refined3[1];
-          dispatcher.preloadModule(_href5, _options);
+          dispatcher.m(
+          /* preloadModule */
+          _href5, _options);
         }
 
         return;
       }
 
-    case 'S':
+    case 'X':
       {
         var _refined4 = refineModel(code, model);
 
         if (typeof _refined4 === 'string') {
           var _href6 = _refined4;
-          dispatcher.preinitStyle(_href6);
+          dispatcher.X(
+          /* preinitScript */
+          _href6);
         } else {
           var _href7 = _refined4[0];
-          var precedence = _refined4[1] === 0 ? undefined : _refined4[1];
-
-          var _options2 = _refined4.length === 3 ? _refined4[2] : undefined;
-
-          dispatcher.preinitStyle(_href7, precedence, _options2);
+          var _options2 = _refined4[1];
+          dispatcher.X(
+          /* preinitScript */
+          _href7, _options2);
         }
 
         return;
       }
 
-    case 'X':
+    case 'S':
       {
         var _refined5 = refineModel(code, model);
 
         if (typeof _refined5 === 'string') {
           var _href8 = _refined5;
-          dispatcher.preinitScript(_href8);
+          dispatcher.S(
+          /* preinitStyle */
+          _href8);
         } else {
           var _href9 = _refined5[0];
-          var _options3 = _refined5[1];
-          dispatcher.preinitScript(_href9, _options3);
+          var precedence = _refined5[1] === 0 ? undefined : _refined5[1];
+
+          var _options3 = _refined5.length === 3 ? _refined5[2] : undefined;
+
+          dispatcher.S(
+          /* preinitStyle */
+          _href9, precedence, _options3);
         }
 
         return;
@@ -359,11 +381,15 @@ function dispatchHint(code, model) {
 
         if (typeof _refined6 === 'string') {
           var _href10 = _refined6;
-          dispatcher.preinitModuleScript(_href10);
+          dispatcher.M(
+          /* preinitModuleScript */
+          _href10);
         } else {
           var _href11 = _refined6[0];
           var _options4 = _refined6[1];
-          dispatcher.preinitModuleScript(_href11, _options4);
+          dispatcher.M(
+          /* preinitModuleScript */
+          _href11, _options4);
         }
 
         return;
@@ -376,17 +402,17 @@ function refineModel(code, model) {
   return model;
 }
 function preinitScriptForSSR(href, nonce, crossOrigin) {
-  var dispatcher = ReactDOMCurrentDispatcher.current;
-
-  if (dispatcher) {
-    dispatcher.preinitScript(href, {
-      crossOrigin: getCrossOriginString(crossOrigin),
-      nonce: nonce
-    });
-  }
+  ReactDOMSharedInternals.d
+  /* ReactDOMCurrentDispatcher */
+  .X(
+  /* preinitScript */
+  href, {
+    crossOrigin: getCrossOriginString(crossOrigin),
+    nonce: nonce
+  });
 }
 
-var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+var ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
 
 function error(format) {
   {
@@ -404,8 +430,7 @@ function printWarning(level, format, args) {
   // When changing this logic, you might want to also
   // update consoleWithStackDev.www.js as well.
   {
-    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-    var stack = ReactDebugCurrentFrame.getStackAddendum();
+    var stack = ReactSharedInternals.getStackAddendum();
 
     if (stack !== '') {
       format += '%s';
@@ -1827,7 +1852,7 @@ function getChunk(response, id) {
   return chunk;
 }
 
-function createModelResolver(chunk, parentObject, key, cyclic) {
+function createModelResolver(chunk, parentObject, key, cyclic, response, map) {
   var blocked;
 
   if (initializingChunkBlockedModel) {
@@ -1844,11 +1869,11 @@ function createModelResolver(chunk, parentObject, key, cyclic) {
   }
 
   return function (value) {
-    parentObject[key] = value; // If this is the root object for a model reference, where `blocked.value`
+    parentObject[key] = map(response, value); // If this is the root object for a model reference, where `blocked.value`
     // is a stale `null`, the resolved value can be used directly.
 
     if (key === '' && blocked.value === null) {
-      blocked.value = value;
+      blocked.value = parentObject[key];
     }
 
     blocked.deps--;
@@ -1904,28 +1929,80 @@ function createServerReferenceProxy(response, metaData) {
   return proxy;
 }
 
-function getOutlinedModel(response, id) {
+function getOutlinedModel(response, id, parentObject, key, map) {
   var chunk = getChunk(response, id);
 
   switch (chunk.status) {
     case RESOLVED_MODEL:
       initializeModelChunk(chunk);
       break;
+
+    case RESOLVED_MODULE:
+      initializeModuleChunk(chunk);
+      break;
   } // The status might have changed after initialization.
 
 
   switch (chunk.status) {
     case INITIALIZED:
-      {
-        return chunk.value;
+      var chunkValue = map(response, chunk.value);
+
+      if (chunk._debugInfo) {
+        // If we have a direct reference to an object that was rendered by a synchronous
+        // server component, it might have some debug info about how it was rendered.
+        // We forward this to the underlying object. This might be a React Element or
+        // an Array fragment.
+        // If this was a string / number return value we lose the debug info. We choose
+        // that tradeoff to allow sync server components to return plain values and not
+        // use them as React Nodes necessarily. We could otherwise wrap them in a Lazy.
+        if (typeof chunkValue === 'object' && chunkValue !== null && (Array.isArray(chunkValue) || chunkValue.$$typeof === REACT_ELEMENT_TYPE) && !chunkValue._debugInfo) {
+          // We should maybe use a unique symbol for arrays but this is a React owned array.
+          // $FlowFixMe[prop-missing]: This should be added to elements.
+          Object.defineProperty(chunkValue, '_debugInfo', {
+            configurable: false,
+            enumerable: false,
+            writable: true,
+            value: chunk._debugInfo
+          });
+        }
       }
-    // We always encode it first in the stream so it won't be pending.
+
+      return chunkValue;
+
+    case PENDING:
+    case BLOCKED:
+    case CYCLIC:
+      var parentChunk = initializingChunk;
+      chunk.then(createModelResolver(parentChunk, parentObject, key, chunk.status === CYCLIC, response, map), createModelReject(parentChunk));
+      return null;
 
     default:
       throw chunk.reason;
   }
 }
 
+function createMap(response, model) {
+  return new Map(model);
+}
+
+function createSet(response, model) {
+  return new Set(model);
+}
+
+function createFormData(response, model) {
+  var formData = new FormData();
+
+  for (var i = 0; i < model.length; i++) {
+    formData.append(model[i][0], model[i][1]);
+  }
+
+  return formData;
+}
+
+function createModel(response, model) {
+  return model;
+}
+
 function parseModelString(response, parentObject, key, value) {
   if (value[0] === '$') {
     if (value === '$') {
@@ -1976,8 +2053,7 @@ function parseModelString(response, parentObject, key, value) {
           // Server Reference
           var _id2 = parseInt(value.slice(2), 16);
 
-          var metadata = getOutlinedModel(response, _id2);
-          return createServerReferenceProxy(response, metadata);
+          return getOutlinedModel(response, _id2, parentObject, key, createServerReferenceProxy);
         }
 
       case 'T':
@@ -1999,8 +2075,7 @@ function parseModelString(response, parentObject, key, value) {
           // Map
           var _id4 = parseInt(value.slice(2), 16);
 
-          var data = getOutlinedModel(response, _id4);
-          return new Map(data);
+          return getOutlinedModel(response, _id4, parentObject, key, createMap);
         }
 
       case 'W':
@@ -2008,9 +2083,7 @@ function parseModelString(response, parentObject, key, value) {
           // Set
           var _id5 = parseInt(value.slice(2), 16);
 
-          var _data = getOutlinedModel(response, _id5);
-
-          return new Set(_data);
+          return getOutlinedModel(response, _id5, parentObject, key, createSet);
         }
 
       case 'B':
@@ -2024,15 +2097,7 @@ function parseModelString(response, parentObject, key, value) {
           // FormData
           var _id7 = parseInt(value.slice(2), 16);
 
-          var _data3 = getOutlinedModel(response, _id7);
-
-          var formData = new FormData();
-
-          for (var i = 0; i < _data3.length; i++) {
-            formData.append(_data3[i][0], _data3[i][1]);
-          }
-
-          return formData;
+          return getOutlinedModel(response, _id7, parentObject, key, createFormData);
         }
 
       case 'I':
@@ -2098,57 +2163,7 @@ function parseModelString(response, parentObject, key, value) {
           // We assume that anything else is a reference ID.
           var _id8 = parseInt(value.slice(1), 16);
 
-          var _chunk2 = getChunk(response, _id8);
-
-          switch (_chunk2.status) {
-            case RESOLVED_MODEL:
-              initializeModelChunk(_chunk2);
-              break;
-
-            case RESOLVED_MODULE:
-              initializeModuleChunk(_chunk2);
-              break;
-          } // The status might have changed after initialization.
-
-
-          switch (_chunk2.status) {
-            case INITIALIZED:
-              var chunkValue = _chunk2.value;
-
-              if (_chunk2._debugInfo) {
-                // If we have a direct reference to an object that was rendered by a synchronous
-                // server component, it might have some debug info about how it was rendered.
-                // We forward this to the underlying object. This might be a React Element or
-                // an Array fragment.
-                // If this was a string / number return value we lose the debug info. We choose
-                // that tradeoff to allow sync server components to return plain values and not
-                // use them as React Nodes necessarily. We could otherwise wrap them in a Lazy.
-                if (typeof chunkValue === 'object' && chunkValue !== null && (Array.isArray(chunkValue) || chunkValue.$$typeof === REACT_ELEMENT_TYPE) && !chunkValue._debugInfo) {
-                  // We should maybe use a unique symbol for arrays but this is a React owned array.
-                  // $FlowFixMe[prop-missing]: This should be added to elements.
-                  Object.defineProperty(chunkValue, '_debugInfo', {
-                    configurable: false,
-                    enumerable: false,
-                    writable: true,
-                    value: _chunk2._debugInfo
-                  });
-                }
-              }
-
-              return chunkValue;
-
-            case PENDING:
-            case BLOCKED:
-            case CYCLIC:
-              var parentChunk = initializingChunk;
-
-              _chunk2.then(createModelResolver(parentChunk, parentObject, key, _chunk2.status === CYCLIC), createModelReject(parentChunk));
-
-              return null;
-
-            default:
-              throw _chunk2.reason;
-          }
+          return getOutlinedModel(response, _id8, parentObject, key, createModel);
         }
     }
   }