react-server-dom-webpack 19.0.0-canary-96c584661-20240412 → 19.0.0-canary-657428a9e-20240416

package/cjs/react-server-dom-webpack-server.node.development.js

@@ -972,7 +972,14 @@ function trackUsedThenable(thenableState, thenable, index) {
 
     default:
       {
-        if (typeof thenable.status === 'string') ; else {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          // Attach a dummy listener, to ensure that any lazy initialization can
+          // happen. Flight lazily parses JSON when the value is actually awaited.
+          thenable.then(noop, noop);
+        } else {
           var pendingThenable = thenable;
           pendingThenable.status = 'pending';
           pendingThenable.then(function (fulfilledValue) {
@@ -987,21 +994,22 @@ function trackUsedThenable(thenableState, thenable, index) {
               rejectedThenable.status = 'rejected';
               rejectedThenable.reason = error;
             }
-          }); // Check one more time in case the thenable resolved synchronously
+          });
+        } // Check one more time in case the thenable resolved synchronously
 
-          switch (thenable.status) {
-            case 'fulfilled':
-              {
-                var fulfilledThenable = thenable;
-                return fulfilledThenable.value;
-              }
 
-            case 'rejected':
-              {
-                var rejectedThenable = thenable;
-                throw rejectedThenable.reason;
-              }
-          }
+        switch (thenable.status) {
+          case 'fulfilled':
+            {
+              var fulfilledThenable = thenable;
+              return fulfilledThenable.value;
+            }
+
+          case 'rejected':
+            {
+              var rejectedThenable = thenable;
+              throw rejectedThenable.reason;
+            }
         } // Suspend.
         //
         // Throwing here is an implementation detail that allows us to unwind the
@@ -1568,6 +1576,7 @@ function createRequest(model, bundlerConfig, onError, identifierPrefix, onPostpo
     nextChunkId: 0,
     pendingChunks: 0,
     hints: hints,
+    abortListeners: new Set(),
     abortableTasks: abortSet,
     pingedTasks: pingedTasks,
     completedImportChunks: [],
@@ -1680,10 +1689,7 @@ function serializeThenable(request, task, thenable) {
     }
 
     request.abortableTasks.delete(newTask);
-
-    if (request.destination !== null) {
-      flushCompletedChunks(request, request.destination);
-    }
+    enqueueFlush(request);
   });
   return newTask.id;
 }
@@ -1849,24 +1855,6 @@ function renderFunctionComponent(request, task, key, Component, props, owner) {
 }
 
 function renderFragment(request, task, children) {
-  {
-    var debugInfo = children._debugInfo;
-
-    if (debugInfo) {
-      // If this came from Flight, forward any debug info into this new row.
-      if (debugID === null) {
-        // We don't have a chunk to assign debug info. We need to outline this
-        // component to assign it an ID.
-        return outlineTask(request, task);
-      } else {
-        // Forward any debug info we have the first time we see it.
-        // We do this after init so that we have received all the debug info
-        // from the server by the time we emit it.
-        forwardDebugInfo(request, debugID, debugInfo);
-      }
-    }
-  }
-
   if (task.keyPath !== null) {
     // We have a Server Component that specifies a key but we're now splitting
     // the tree using a fragment.
@@ -1898,6 +1886,28 @@ function renderFragment(request, task, children) {
   // before recursing here.
 
 
+  {
+    var debugInfo = children._debugInfo;
+
+    if (debugInfo) {
+      // If this came from Flight, forward any debug info into this new row.
+      if (debugID === null) {
+        // We don't have a chunk to assign debug info. We need to outline this
+        // component to assign it an ID.
+        return outlineTask(request, task);
+      } else {
+        // Forward any debug info we have the first time we see it.
+        // We do this after init so that we have received all the debug info
+        // from the server by the time we emit it.
+        forwardDebugInfo(request, debugID, debugInfo);
+      } // Since we're rendering this array again, create a copy that doesn't
+      // have the debug info so we avoid outlining or emitting debug info again.
+
+
+      children = Array.from(children);
+    }
+  }
+
   return children;
 }
 
@@ -2239,13 +2249,9 @@ function serializeTemporaryReference(request, temporaryReference) {
 }
 
 function serializeLargeTextString(request, text) {
-  request.pendingChunks += 2;
+  request.pendingChunks++;
   var textId = request.nextChunkId++;
-  var textChunk = stringToChunk(text);
-  var binaryLength = byteLengthOfChunk(textChunk);
-  var row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
-  var headerChunk = stringToChunk(row);
-  request.completedRegularChunks.push(headerChunk, textChunk);
+  emitTextChunk(request, textId, text);
   return serializeByValueID(textId);
 }
 
@@ -2560,7 +2566,7 @@ function renderModelDestructive(request, task, parent, parentPropertyName, value
 
     if (iteratorFn) {
       return renderFragment(request, task, Array.from(value));
-    } // Verify that this is a simple plain object.
+    }
 
 
     var proto = getPrototypeOf(value);
@@ -2835,6 +2841,16 @@ function emitDebugChunk(request, id, debugInfo) {
   request.completedRegularChunks.push(processedChunk);
 }
 
+function emitTextChunk(request, id, text) {
+  request.pendingChunks++; // Extra chunk for the header.
+
+  var textChunk = stringToChunk(text);
+  var binaryLength = byteLengthOfChunk(textChunk);
+  var row = id.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  var headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+}
+
 function serializeEval(source) {
 
   return '$E' + source;
@@ -3034,6 +3050,22 @@ function forwardDebugInfo(request, id, debugInfo) {
   }
 }
 
+function emitChunk(request, task, value) {
+  var id = task.id; // For certain types we have special types, we typically outlined them but
+  // we can emit them directly for this row instead of through an indirection.
+
+  if (typeof value === 'string') {
+
+    emitTextChunk(request, id, value);
+    return;
+  }
+  // $FlowFixMe[incompatible-type] stringify can return null for undefined but we never do
+
+
+  var json = stringify(value, task.toJSON);
+  emitModelChunk(request, task.id, json);
+}
+
 var emptyRoot = {};
 
 function retryTask(request, task) {
@@ -3070,21 +3102,19 @@ function retryTask(request, task) {
 
     task.keyPath = null;
     task.implicitSlot = false;
-    var json;
 
     if (typeof resolvedModel === 'object' && resolvedModel !== null) {
       // Object might contain unresolved values like additional elements.
       // This is simulating what the JSON loop would do if this was part of it.
-      // $FlowFixMe[incompatible-type] stringify can return null for undefined but we never do
-      json = stringify(resolvedModel, task.toJSON);
+      emitChunk(request, task, resolvedModel);
     } else {
       // If the value is a string, it means it's a terminal value and we already escaped it
       // We don't need to escape it again so it's not passed the toJSON replacer.
       // $FlowFixMe[incompatible-type] stringify can return null for undefined but we never do
-      json = stringify(resolvedModel);
+      var json = stringify(resolvedModel);
+      emitModelChunk(request, task.id, json);
     }
 
-    emitModelChunk(request, task.id, json);
     request.abortableTasks.delete(task);
     task.status = COMPLETED;
   } catch (thrownValue) {
@@ -3242,6 +3272,7 @@ function flushCompletedChunks(request, destination) {
   if (request.pendingChunks === 0) {
 
     close$1(destination);
+    request.destination = null;
   }
 }
 
@@ -3299,11 +3330,10 @@ function stopFlowing(request) {
 
 function abort(request, reason) {
   try {
-    var abortableTasks = request.abortableTasks;
+    var abortableTasks = request.abortableTasks; // We have tasks to abort. We'll emit one error row and then emit a reference
+    // to that row from every row that's still remaining.
 
     if (abortableTasks.size > 0) {
-      // We have tasks to abort. We'll emit one error row and then emit a reference
-      // to that row from every row that's still remaining.
       request.pendingChunks++;
       var errorId = request.nextChunkId++;
 
@@ -3319,6 +3349,21 @@ function abort(request, reason) {
       abortableTasks.clear();
     }
 
+    var abortListeners = request.abortListeners;
+
+    if (abortListeners.size > 0) {
+      var _error;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        _error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      }
+
+      abortListeners.forEach(function (callback) {
+        return callback(_error);
+      });
+      abortListeners.clear();
+    }
+
     if (request.destination !== null) {
       flushCompletedChunks(request, request.destination);
     }
@@ -3774,7 +3819,7 @@ function getOutlinedModel(response, id) {
   return chunk.value;
 }
 
-function parseModelString(response, parentObject, key, value) {
+function parseModelString(response, obj, key, value) {
   if (value[0] === '$') {
     switch (value[1]) {
       case '$':
@@ -3786,19 +3831,21 @@ function parseModelString(response, parentObject, key, value) {
       case '@':
         {
           // Promise
-          var id = parseInt(value.slice(2), 16);
-          var chunk = getChunk(response, id);
-          return chunk;
+          var _id = parseInt(value.slice(2), 16);
+
+          var _chunk = getChunk(response, _id);
+
+          return _chunk;
         }
 
       case 'F':
         {
           // Server Reference
-          var _id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
+          var _id2 = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
 
 
-          var metaData = getOutlinedModel(response, _id);
-          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+          var metaData = getOutlinedModel(response, _id2);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, obj, key);
         }
 
       case 'T':
@@ -3810,18 +3857,18 @@ function parseModelString(response, parentObject, key, value) {
       case 'Q':
         {
           // Map
-          var _id2 = parseInt(value.slice(2), 16);
+          var _id3 = parseInt(value.slice(2), 16);
 
-          var data = getOutlinedModel(response, _id2);
+          var data = getOutlinedModel(response, _id3);
           return new Map(data);
         }
 
       case 'W':
         {
           // Set
-          var _id3 = parseInt(value.slice(2), 16);
+          var _id4 = parseInt(value.slice(2), 16);
 
-          var _data = getOutlinedModel(response, _id3);
+          var _data = getOutlinedModel(response, _id4);
 
           return new Set(_data);
         }
@@ -3887,37 +3934,31 @@ function parseModelString(response, parentObject, key, value) {
           // BigInt
           return BigInt(value.slice(2));
         }
+    }
 
-      default:
-        {
-          // We assume that anything else is a reference ID.
-          var _id4 = parseInt(value.slice(1), 16);
-
-          var _chunk = getChunk(response, _id4);
-
-          switch (_chunk.status) {
-            case RESOLVED_MODEL:
-              initializeModelChunk(_chunk);
-              break;
-          } // The status might have changed after initialization.
 
+    var id = parseInt(value.slice(1), 16);
+    var chunk = getChunk(response, id);
 
-          switch (_chunk.status) {
-            case INITIALIZED:
-              return _chunk.value;
+    switch (chunk.status) {
+      case RESOLVED_MODEL:
+        initializeModelChunk(chunk);
+        break;
+    } // The status might have changed after initialization.
 
-            case PENDING:
-            case BLOCKED:
-              var parentChunk = initializingChunk;
 
-              _chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
+    switch (chunk.status) {
+      case INITIALIZED:
+        return chunk.value;
 
-              return null;
+      case PENDING:
+      case BLOCKED:
+        var parentChunk = initializingChunk;
+        chunk.then(createModelResolver(parentChunk, obj, key), createModelReject(parentChunk));
+        return null;
 
-            default:
-              throw _chunk.reason;
-          }
-        }
+      default:
+        throw chunk.reason;
     }
   }
 

package/cjs/react-server-dom-webpack-server.node.production.js

@@ -920,7 +920,14 @@ function trackUsedThenable(thenableState, thenable, index) {
 
     default:
       {
-        if (typeof thenable.status === 'string') ; else {
+        if (typeof thenable.status === 'string') {
+          // Only instrument the thenable if the status if not defined. If
+          // it's defined, but an unknown value, assume it's been instrumented by
+          // some custom userspace implementation. We treat it as "pending".
+          // Attach a dummy listener, to ensure that any lazy initialization can
+          // happen. Flight lazily parses JSON when the value is actually awaited.
+          thenable.then(noop, noop);
+        } else {
           const pendingThenable = thenable;
           pendingThenable.status = 'pending';
           pendingThenable.then(fulfilledValue => {
@@ -935,21 +942,22 @@ function trackUsedThenable(thenableState, thenable, index) {
               rejectedThenable.status = 'rejected';
               rejectedThenable.reason = error;
             }
-          }); // Check one more time in case the thenable resolved synchronously
-
-          switch (thenable.status) {
-            case 'fulfilled':
-              {
-                const fulfilledThenable = thenable;
-                return fulfilledThenable.value;
-              }
-
-            case 'rejected':
-              {
-                const rejectedThenable = thenable;
-                throw rejectedThenable.reason;
-              }
-          }
+          });
+        } // Check one more time in case the thenable resolved synchronously
+
+
+        switch (thenable.status) {
+          case 'fulfilled':
+            {
+              const fulfilledThenable = thenable;
+              return fulfilledThenable.value;
+            }
+
+          case 'rejected':
+            {
+              const rejectedThenable = thenable;
+              throw rejectedThenable.reason;
+            }
         } // Suspend.
         //
         // Throwing here is an implementation detail that allows us to unwind the
@@ -1385,6 +1393,7 @@ function createRequest(model, bundlerConfig, onError, identifierPrefix, onPostpo
     nextChunkId: 0,
     pendingChunks: 0,
     hints,
+    abortListeners: new Set(),
     abortableTasks: abortSet,
     pingedTasks: pingedTasks,
     completedImportChunks: [],
@@ -1482,10 +1491,7 @@ function serializeThenable(request, task, thenable) {
     }
 
     request.abortableTasks.delete(newTask);
-
-    if (request.destination !== null) {
-      flushCompletedChunks(request, request.destination);
-    }
+    enqueueFlush(request);
   });
   return newTask.id;
 }
@@ -1611,7 +1617,6 @@ function renderFunctionComponent(request, task, key, Component, props, owner) {
 }
 
 function renderFragment(request, task, children) {
-
   if (task.keyPath !== null) {
     // We have a Server Component that specifies a key but we're now splitting
     // the tree using a fragment.
@@ -1638,10 +1643,6 @@ function renderFragment(request, task, children) {
 
     return [fragment];
   } // Since we're yielding here, that implicitly resets the keyPath context on the
-  // way up. Which is what we want since we've consumed it. If this changes to
-  // be recursive serialization, we need to reset the keyPath and implicitSlot,
-  // before recursing here.
-
 
   return children;
 }
@@ -1932,13 +1933,9 @@ function serializeTemporaryReference(request, temporaryReference) {
 }
 
 function serializeLargeTextString(request, text) {
-  request.pendingChunks += 2;
+  request.pendingChunks++;
   const textId = request.nextChunkId++;
-  const textChunk = stringToChunk(text);
-  const binaryLength = byteLengthOfChunk(textChunk);
-  const row = textId.toString(16) + ':T' + binaryLength.toString(16) + ',';
-  const headerChunk = stringToChunk(row);
-  request.completedRegularChunks.push(headerChunk, textChunk);
+  emitTextChunk(request, textId, text);
   return serializeByValueID(textId);
 }
 
@@ -2215,7 +2212,7 @@ function renderModelDestructive(request, task, parent, parentPropertyName, value
 
     if (iteratorFn) {
       return renderFragment(request, task, Array.from(value));
-    } // Verify that this is a simple plain object.
+    }
 
 
     const proto = getPrototypeOf(value);
@@ -2420,6 +2417,32 @@ function emitModelChunk(request, id, json) {
   request.completedRegularChunks.push(processedChunk);
 }
 
+function emitTextChunk(request, id, text) {
+  request.pendingChunks++; // Extra chunk for the header.
+
+  const textChunk = stringToChunk(text);
+  const binaryLength = byteLengthOfChunk(textChunk);
+  const row = id.toString(16) + ':T' + binaryLength.toString(16) + ',';
+  const headerChunk = stringToChunk(row);
+  request.completedRegularChunks.push(headerChunk, textChunk);
+}
+
+function emitChunk(request, task, value) {
+  const id = task.id; // For certain types we have special types, we typically outlined them but
+  // we can emit them directly for this row instead of through an indirection.
+
+  if (typeof value === 'string') {
+
+    emitTextChunk(request, id, value);
+    return;
+  }
+  // $FlowFixMe[incompatible-type] stringify can return null for undefined but we never do
+
+
+  const json = stringify(value, task.toJSON);
+  emitModelChunk(request, task.id, json);
+}
+
 const emptyRoot = {};
 
 function retryTask(request, task) {
@@ -2447,21 +2470,19 @@ function retryTask(request, task) {
 
     task.keyPath = null;
     task.implicitSlot = false;
-    let json;
 
     if (typeof resolvedModel === 'object' && resolvedModel !== null) {
       // Object might contain unresolved values like additional elements.
       // This is simulating what the JSON loop would do if this was part of it.
-      // $FlowFixMe[incompatible-type] stringify can return null for undefined but we never do
-      json = stringify(resolvedModel, task.toJSON);
+      emitChunk(request, task, resolvedModel);
     } else {
       // If the value is a string, it means it's a terminal value and we already escaped it
       // We don't need to escape it again so it's not passed the toJSON replacer.
       // $FlowFixMe[incompatible-type] stringify can return null for undefined but we never do
-      json = stringify(resolvedModel);
+      const json = stringify(resolvedModel);
+      emitModelChunk(request, task.id, json);
     }
 
-    emitModelChunk(request, task.id, json);
     request.abortableTasks.delete(task);
     task.status = COMPLETED;
   } catch (thrownValue) {
@@ -2613,6 +2634,7 @@ function flushCompletedChunks(request, destination) {
   if (request.pendingChunks === 0) {
 
     close$1(destination);
+    request.destination = null;
   }
 }
 
@@ -2666,11 +2688,10 @@ function stopFlowing(request) {
 
 function abort(request, reason) {
   try {
-    const abortableTasks = request.abortableTasks;
+    const abortableTasks = request.abortableTasks; // We have tasks to abort. We'll emit one error row and then emit a reference
+    // to that row from every row that's still remaining.
 
     if (abortableTasks.size > 0) {
-      // We have tasks to abort. We'll emit one error row and then emit a reference
-      // to that row from every row that's still remaining.
       request.pendingChunks++;
       const errorId = request.nextChunkId++;
 
@@ -2684,6 +2705,19 @@ function abort(request, reason) {
       abortableTasks.clear();
     }
 
+    const abortListeners = request.abortListeners;
+
+    if (abortListeners.size > 0) {
+      let error;
+
+      if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
+        error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
+      }
+
+      abortListeners.forEach(callback => callback(error));
+      abortListeners.clear();
+    }
+
     if (request.destination !== null) {
       flushCompletedChunks(request, request.destination);
     }
@@ -3135,7 +3169,7 @@ function getOutlinedModel(response, id) {
   return chunk.value;
 }
 
-function parseModelString(response, parentObject, key, value) {
+function parseModelString(response, obj, key, value) {
   if (value[0] === '$') {
     switch (value[1]) {
       case '$':
@@ -3158,7 +3192,7 @@ function parseModelString(response, parentObject, key, value) {
           const id = parseInt(value.slice(2), 16); // TODO: Just encode this in the reference inline instead of as a model.
 
           const metaData = getOutlinedModel(response, id);
-          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, parentObject, key);
+          return loadServerReference$1(response, metaData.id, metaData.bound, initializingChunk, obj, key);
         }
 
       case 'T':
@@ -3242,34 +3276,31 @@ function parseModelString(response, parentObject, key, value) {
           // BigInt
           return BigInt(value.slice(2));
         }
+    }
 
-      default:
-        {
-          // We assume that anything else is a reference ID.
-          const id = parseInt(value.slice(1), 16);
-          const chunk = getChunk(response, id);
 
-          switch (chunk.status) {
-            case RESOLVED_MODEL:
-              initializeModelChunk(chunk);
-              break;
-          } // The status might have changed after initialization.
+    const id = parseInt(value.slice(1), 16);
+    const chunk = getChunk(response, id);
 
+    switch (chunk.status) {
+      case RESOLVED_MODEL:
+        initializeModelChunk(chunk);
+        break;
+    } // The status might have changed after initialization.
 
-          switch (chunk.status) {
-            case INITIALIZED:
-              return chunk.value;
 
-            case PENDING:
-            case BLOCKED:
-              const parentChunk = initializingChunk;
-              chunk.then(createModelResolver(parentChunk, parentObject, key), createModelReject(parentChunk));
-              return null;
+    switch (chunk.status) {
+      case INITIALIZED:
+        return chunk.value;
 
-            default:
-              throw chunk.reason;
-          }
-        }
+      case PENDING:
+      case BLOCKED:
+        const parentChunk = initializingChunk;
+        chunk.then(createModelResolver(parentChunk, obj, key), createModelReject(parentChunk));
+        return null;
+
+      default:
+        throw chunk.reason;
     }
   }