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

package/umd/react-server-dom-webpack-server.browser.development.js

@@ -902,7 +902,14 @@
 
       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) {
@@ -917,21 +924,22 @@
                 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
@@ -1498,6 +1506,7 @@
       nextChunkId: 0,
       pendingChunks: 0,
       hints: hints,
+      abortListeners: new Set(),
       abortableTasks: abortSet,
       pingedTasks: pingedTasks,
       completedImportChunks: [],
@@ -1605,10 +1614,7 @@
       }
 
       request.abortableTasks.delete(newTask);
-
-      if (request.destination !== null) {
-        flushCompletedChunks(request, request.destination);
-      }
+      enqueueFlush(request);
     });
     return newTask.id;
   }
@@ -1774,24 +1780,6 @@
   }
 
   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.
@@ -1823,6 +1811,28 @@
     // 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;
   }
 
@@ -2164,13 +2174,9 @@
   }
 
   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);
   }
 
@@ -2485,7 +2491,7 @@
 
       if (iteratorFn) {
         return renderFragment(request, task, Array.from(value));
-      } // Verify that this is a simple plain object.
+      }
 
 
       var proto = getPrototypeOf(value);
@@ -2758,6 +2764,16 @@
     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;
@@ -2957,6 +2973,22 @@
     }
   }
 
+  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) {
@@ -2993,21 +3025,19 @@
 
       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) {
@@ -3163,6 +3193,7 @@
     if (request.pendingChunks === 0) {
 
       close$1(destination);
+      request.destination = null;
     }
   }
 
@@ -3220,11 +3251,10 @@
 
   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++;
 
@@ -3240,6 +3270,21 @@
         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);
       }
@@ -3671,7 +3716,7 @@
     return chunk.value;
   }
 
-  function parseModelString(response, parentObject, key, value) {
+  function parseModelString(response, obj, key, value) {
     if (value[0] === '$') {
       switch (value[1]) {
         case '$':
@@ -3683,19 +3728,21 @@
         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':
@@ -3707,18 +3754,18 @@
         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);
           }
@@ -3784,37 +3831,31 @@
             // 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;
       }
     }