react-server-dom-webpack 19.0.0-canary-e3ebcd54b-20240405 → 19.0.0-canary-adb717393-20240411

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

@@ -244,19 +244,21 @@ function loadChunk(chunkId, filename) {
   return __webpack_chunk_load__(chunkId);
 }
 
-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;
 
 // 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;
       }
 
@@ -266,11 +268,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;
@@ -285,9 +291,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;
@@ -299,46 +309,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;
@@ -350,11 +372,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;
@@ -367,7 +393,7 @@ function refineModel(code, model) {
   return model;
 }
 
-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) {
   {
@@ -385,8 +411,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';
@@ -1503,7 +1528,8 @@ function nullRefGetter() {
   }
 }
 
-function createElement(type, key, props) {
+function createElement(type, key, props, owner) // DEV-only
+{
   var element;
 
   {
@@ -1513,7 +1539,7 @@ function createElement(type, key, props) {
       type: type,
       key: key,
       props: props,
-      _owner: null
+      _owner: owner
     };
     Object.defineProperty(element, 'ref', {
       enumerable: false,
@@ -1573,7 +1599,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) {
@@ -1590,11 +1616,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--;
@@ -1650,28 +1676,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 === '$') {
@@ -1722,8 +1800,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':
@@ -1745,8 +1822,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':
@@ -1754,9 +1830,21 @@ function parseModelString(response, parentObject, key, value) {
           // Set
           var _id5 = parseInt(value.slice(2), 16);
 
-          var _data = getOutlinedModel(response, _id5);
+          return getOutlinedModel(response, _id5, parentObject, key, createSet);
+        }
+
+      case 'B':
+        {
 
-          return new Set(_data);
+          return undefined;
+        }
+
+      case 'K':
+        {
+          // FormData
+          var _id7 = parseInt(value.slice(2), 16);
+
+          return getOutlinedModel(response, _id7, parentObject, key, createFormData);
         }
 
       case 'I':
@@ -1820,59 +1908,9 @@ function parseModelString(response, parentObject, key, value) {
       default:
         {
           // We assume that anything else is a reference ID.
-          var _id6 = parseInt(value.slice(1), 16);
-
-          var _chunk2 = getChunk(response, _id6);
-
-          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
-                  });
-                }
-              }
+          var _id8 = parseInt(value.slice(1), 16);
 
-              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);
         }
     }
   }
@@ -1886,7 +1924,7 @@ function parseModelTuple(response, value) {
   if (tuple[0] === REACT_ELEMENT_TYPE) {
     // TODO: Consider having React just directly accept these arrays as elements.
     // Or even change the ReactElement type to be an array.
-    return createElement(tuple[1], tuple[2], tuple[3]);
+    return createElement(tuple[1], tuple[2], tuple[3], tuple[4] );
   }
 
   return value;
@@ -2012,9 +2050,10 @@ function resolveConsoleEntry(response, value) {
   var payload = parseModel(response, value);
   var methodName = payload[0]; // TODO: Restore the fake stack before logging.
   // const stackTrace = payload[1];
+  // const owner = payload[2];
 
-  var env = payload[2];
-  var args = payload.slice(3);
+  var env = payload[3];
+  var args = payload.slice(4);
   printToConsole(methodName, args, env);
 }
 
@@ -2073,7 +2112,7 @@ function processFullRow(response, id, tag, buffer, chunk) {
     :
       {
         {
-          var debugInfo = JSON.parse(row);
+          var debugInfo = parseModel(response, row);
           resolveDebugInfo(response, id, debugInfo);
           return;
         } // Fallthrough to share the error with Console entries.