react-server-dom-webpack 19.0.0-rc-20b6f4c0e8-20240607 → 19.0.0-rc-34d0c5e357-20240607

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

@@ -42,9 +42,6 @@ if (!ReactSharedInternalsServer) {
   throw new Error('The "react" package in this environment is not configured correctly. ' + 'The "react-server" condition must be enabled in any environment that ' + 'runs React Server Components.');
 }
 
-// -----------------------------------------------------------------------------
-var enablePostpone = false;
-
 function error(format) {
   {
     {
@@ -52,55 +49,41 @@ function error(format) {
         args[_key2 - 1] = arguments[_key2];
       }
 
-      printWarning('error', format, args, new Error('react-stack-top-frame'));
+      printWarning('error', format, args);
     }
   }
-} // eslint-disable-next-line react-internal/no-production-logging
+}
 
-function printWarning(level, format, args, currentStack) {
+function printWarning(level, format, args) {
   // When changing this logic, you might want to also
   // update consoleWithStackDev.www.js as well.
   {
-    var isErrorLogger = format === '%s\n\n%s\n' || format === '%o\n\n%s\n\n%s\n';
+    var stack = ReactSharedInternalsServer.getStackAddendum();
 
-    if (ReactSharedInternalsServer.getCurrentStack) {
-      // We only add the current stack to the console when createTask is not supported.
-      // Since createTask requires DevTools to be open to work, this means that stacks
-      // can be lost while DevTools isn't open but we can't detect this.
-      var stack = ReactSharedInternalsServer.getCurrentStack(currentStack);
+    if (stack !== '') {
+      format += '%s';
+      args = args.concat([stack]);
+    } // eslint-disable-next-line react-internal/safe-string-coercion
 
-      if (stack !== '') {
-        format += '%s';
-        args = args.concat([stack]);
-      }
-    }
 
-    if (isErrorLogger) {
-      // Don't prefix our default logging formatting in ReactFiberErrorLoggger.
-      // Don't toString the arguments.
-      args.unshift(format);
-    } else {
-      // TODO: Remove this prefix and stop toStringing in the wrapper and
-      // instead do it at each callsite as needed.
-      // Careful: RN currently depends on this prefix
-      // eslint-disable-next-line react-internal/safe-string-coercion
-      args = args.map(function (item) {
-        return String(item);
-      });
-      args.unshift('Warning: ' + format);
-    } // We intentionally don't use spread (or .apply) directly because it
+    var argsWithFormat = args.map(function (item) {
+      return String(item);
+    }); // Careful: RN currently depends on this prefix
+
+    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
     // breaks IE9: https://github.com/facebook/react/issues/13610
     // eslint-disable-next-line react-internal/no-production-logging
 
-
-    Function.prototype.apply.call(console[level], console, args);
+    Function.prototype.apply.call(console[level], console, argsWithFormat);
   }
 }
 
+// -----------------------------------------------------------------------------
+var enablePostpone = false;
+
 function scheduleWork(callback) {
   setImmediate(callback);
 }
-var scheduleMicrotask = queueMicrotask;
 function flushBuffered(destination) {
   // If we don't have any more data to send right now.
   // Flush whatever is in the buffer to the wire.
@@ -1593,37 +1576,6 @@ function describeObjectForErrorMessage(objectOrArray, expandedName) {
 
 var ReactSharedInternals = ReactSharedInternalsServer;
 
-function prepareStackTrace(error, structuredStackTrace) {
-  var name = error.name || 'Error';
-  var message = error.message || '';
-  var stack = name + ': ' + message;
-
-  for (var i = 0; i < structuredStackTrace.length; i++) {
-    stack += '\n    at ' + structuredStackTrace[i].toString();
-  }
-
-  return stack;
-}
-
-function getStack(error) {
-  // We override Error.prepareStackTrace with our own version that normalizes
-  // the stack to V8 formatting even if the server uses other formatting.
-  // It also ensures that source maps are NOT applied to this since that can
-  // be slow we're better off doing that lazily from the client instead of
-  // eagerly on the server. If the stack has already been read, then we might
-  // not get a normalized stack and it might still have been source mapped.
-  // So the client still needs to be resilient to this.
-  var previousPrepare = Error.prepareStackTrace;
-  Error.prepareStackTrace = prepareStackTrace;
-
-  try {
-    // eslint-disable-next-line react-internal/safe-string-coercion
-    return String(error.stack);
-  } finally {
-    Error.prepareStackTrace = previousPrepare;
-  }
-}
-
 var ObjectPrototype = Object.prototype;
 var stringify = JSON.stringify; // Serializable values
 // Thenable<ReactClientValue>
@@ -1633,8 +1585,6 @@ var PENDING$1 = 0;
 var COMPLETED = 1;
 var ABORTED = 3;
 var ERRORED$1 = 4;
-var RENDERING = 5;
-var AbortSigil = {};
 
 function defaultErrorHandler(error) {
   console['error'](error); // Don't transform to our wrapper
@@ -1644,9 +1594,8 @@ function defaultPostponeHandler(reason) {// Noop
 }
 
 var OPEN = 0;
-var ABORTING = 1;
-var CLOSING = 2;
-var CLOSED = 3;
+var CLOSING = 1;
+var CLOSED = 2;
 function createRequest(model, bundlerConfig, onError, identifierPrefix, onPostpone, environmentName, temporaryReferences) {
   if (ReactSharedInternals.A !== null && ReactSharedInternals.A !== DefaultAsyncDispatcher) {
     throw new Error('Currently React only supports one RSC renderer at a time.');
@@ -1689,7 +1638,6 @@ function createRequest(model, bundlerConfig, onError, identifierPrefix, onPostpo
 
   {
     request.environmentName = environmentName === undefined ? 'Server' : environmentName;
-    request.didWarnForKey = null;
   }
 
   var rootTask = createTask(request, model, null, false, abortSet);
@@ -1744,16 +1692,6 @@ function serializeThenable(request, task, thenable) {
 
     default:
       {
-        if (request.status === ABORTING) {
-          // We can no longer accept any resolved values
-          newTask.status = ABORTED;
-          var errorId = request.fatalError;
-          var model = stringify(serializeByValueID(errorId));
-          emitModelChunk(request, newTask.id, model);
-          request.abortableTasks.delete(newTask);
-          return newTask.id;
-        }
-
         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
@@ -2085,8 +2023,7 @@ function callLazyInitInDEV(lazy) {
 }
 
 function renderFunctionComponent(request, task, key, Component, props, owner, // DEV-only
-stack, // DEV-only
-validated) // DEV-only
+stack) // DEV-only
 {
   // Reset the task's thenable state before continuing, so that if a later
   // component suspends we can reuse the same task object. If the same
@@ -2128,30 +2065,12 @@ validated) // DEV-only
     result = callComponentInDEV(Component, props, componentDebugInfo);
   }
 
-  if (request.status === ABORTING) {
-    // If we aborted during rendering we should interrupt the render but
-    // we don't need to provide an error because the renderer will encode
-    // the abort error as the reason.
-    throw AbortSigil;
-  }
-
-  if (typeof result === 'object' && result !== null && !isClientReference(result)) {
+  if (typeof result === 'object' && result !== null) {
     if (typeof result.then === 'function') {
       // When the return value is in children position we can resolve it immediately,
       // to its value without a wrapper if it's synchronously available.
       var thenable = result;
 
-      {
-        // If the thenable resolves to an element, then it was in a static position,
-        // the return value of a Server Component. That doesn't need further validation
-        // of keys. The Server Component itself would have had a key.
-        thenable.then(function (resolvedValue) {
-          if (typeof resolvedValue === 'object' && resolvedValue !== null && resolvedValue.$$typeof === REACT_ELEMENT_TYPE) {
-            resolvedValue._store.validated = 1;
-          }
-        }, function () {});
-      }
-
       if (thenable.status === 'fulfilled') {
         return thenable.value;
       } // TODO: Once we accept Promises as children on the client, we can just return
@@ -2222,11 +2141,6 @@ validated) // DEV-only
       {
         result._debugInfo = _iterableChild._debugInfo;
       }
-    } else if (result.$$typeof === REACT_ELEMENT_TYPE) {
-      // If the server component renders to an element, then it was in a static position.
-      // That doesn't need further validation of keys. The Server Component itself would
-      // have had a key.
-      result._store.validated = 1;
     }
   } // Track this element's key on the Server Component on the keyPath context..
 
@@ -2253,26 +2167,12 @@ validated) // DEV-only
 }
 
 function renderFragment(request, task, children) {
-  {
-    for (var i = 0; i < children.length; i++) {
-      var child = children[i];
-
-      if (child !== null && typeof child === 'object' && child.$$typeof === REACT_ELEMENT_TYPE) {
-        var element = child;
-
-        if (element.key === null && !element._store.validated) {
-          element._store.validated = 2;
-        }
-      }
-    }
-  }
-
   if (task.keyPath !== null) {
     // We have a Server Component that specifies a key but we're now splitting
     // the tree using a fragment.
     var fragment = [REACT_ELEMENT_TYPE, REACT_FRAGMENT_TYPE, task.keyPath, {
       children: children
-    }, null] ;
+    }];
 
     if (!task.implicitSlot) {
       // If this was keyed inside a set. I.e. the outer Server Component was keyed
@@ -2329,7 +2229,7 @@ function renderAsyncFragment(request, task, children, getAsyncIterator) {
     // the tree using a fragment.
     var fragment = [REACT_ELEMENT_TYPE, REACT_FRAGMENT_TYPE, task.keyPath, {
       children: children
-    }, null] ;
+    }];
 
     if (!task.implicitSlot) {
       // If this was keyed inside a set. I.e. the outer Server Component was keyed
@@ -2360,8 +2260,7 @@ function renderAsyncFragment(request, task, children, getAsyncIterator) {
 }
 
 function renderClientElement(task, type, key, props, owner, // DEV-only
-stack, // DEV-only
-validated) // DEV-only
+stack) // DEV-only
 {
   // We prepend the terminal client element that actually gets serialized with
   // the keys of any Server Components which are not serialized.
@@ -2412,8 +2311,7 @@ function outlineTask(request, task) {
 }
 
 function renderElement(request, task, type, key, ref, props, owner, // DEV only
-stack, // DEV only
-validated) // DEV only
+stack) // DEV only
 {
   if (ref !== null && ref !== undefined) {
     // When the ref moves to the regular props object this will implicitly
@@ -2476,13 +2374,6 @@ validated) // DEV only
             wrappedType = callLazyInitInDEV(type);
           }
 
-          if (request.status === ABORTING) {
-            // lazy initializers are user code and could abort during render
-            // we don't wan to return any value resolved from the lazy initializer
-            // if it aborts so we interrupt rendering here
-            throw AbortSigil;
-          }
-
           return renderElement(request, task, wrappedType, key, ref, props, owner);
         }
 
@@ -2507,7 +2398,7 @@ function pingTask(request, task) {
 
   if (pingedTasks.length === 1) {
     request.flushScheduled = request.destination !== null;
-    scheduleMicrotask(function () {
+    scheduleWork(function () {
       return performWork(request);
     });
   }
@@ -2805,32 +2696,21 @@ function renderModel(request, task, parent, key, value) {
   try {
     return renderModelDestructive(request, task, parent, key, value);
   } catch (thrownValue) {
-    // If the suspended/errored value was an element or lazy it can be reduced
-    // to a lazy reference, so that it doesn't error the parent.
-    var model = task.model;
-    var wasReactNode = typeof model === 'object' && model !== null && (model.$$typeof === REACT_ELEMENT_TYPE || model.$$typeof === REACT_LAZY_TYPE);
     var x = thrownValue === SuspenseException ? // This is a special type of exception used for Suspense. For historical
     // reasons, the rest of the Suspense implementation expects the thrown
     // value to be a thenable, because before `use` existed that was the
     // (unstable) API for suspending. This implementation detail can change
     // later, once we deprecate the old API in favor of `use`.
-    getSuspendedThenable() : thrownValue;
+    getSuspendedThenable() : thrownValue; // If the suspended/errored value was an element or lazy it can be reduced
+    // to a lazy reference, so that it doesn't error the parent.
+
+    var model = task.model;
+    var wasReactNode = typeof model === 'object' && model !== null && (model.$$typeof === REACT_ELEMENT_TYPE || model.$$typeof === REACT_LAZY_TYPE);
 
     if (typeof x === 'object' && x !== null) {
       // $FlowFixMe[method-unbinding]
       if (typeof x.then === 'function') {
-        if (request.status === ABORTING) {
-          task.status = ABORTED;
-          var errorId = request.fatalError;
-
-          if (wasReactNode) {
-            return serializeLazyID(errorId);
-          }
-
-          return serializeByValueID(errorId);
-        } // Something suspended, we'll need to create a new task and resolve it later.
-
-
+        // Something suspended, we'll need to create a new task and resolve it later.
         var newTask = createTask(request, task.model, task.keyPath, task.implicitSlot, request.abortableTasks);
         var ping = newTask.ping;
         x.then(ping, ping);
@@ -2846,17 +2726,6 @@ function renderModel(request, task, parent, key, value) {
 
         return serializeByValueID(newTask.id);
       }
-    }
-
-    if (thrownValue === AbortSigil) {
-      task.status = ABORTED;
-      var _errorId = request.fatalError;
-
-      if (wasReactNode) {
-        return serializeLazyID(_errorId);
-      }
-
-      return serializeByValueID(_errorId);
     } // Restore the context. We assume that this will be restored by the inner
     // functions in case nothing throws so we don't use "finally" here.
 
@@ -2869,12 +2738,10 @@ function renderModel(request, task, parent, key, value) {
       // We'll replace this element with a lazy reference that throws on the client
       // once it gets rendered.
       request.pendingChunks++;
-
-      var _errorId2 = request.nextChunkId++;
-
+      var errorId = request.nextChunkId++;
       var digest = logRecoverableError(request, x);
-      emitErrorChunk(request, _errorId2, digest, x);
-      return serializeLazyID(_errorId2);
+      emitErrorChunk(request, errorId, digest, x);
+      return serializeLazyID(errorId);
     } // Something errored but it was not in a React Node. There's no need to serialize
     // it by value because it'll just error the whole parent row anyway so we can
     // just stop any siblings and error the whole parent row.
@@ -2978,13 +2845,6 @@ function renderModelDestructive(request, task, parent, parentPropertyName, value
             resolvedModel = callLazyInitInDEV(lazy);
           }
 
-          if (request.status === ABORTING) {
-            // lazy initializers are user code and could abort during render
-            // we don't wan to return any value resolved from the lazy initializer
-            // if it aborts so we interrupt rendering here
-            throw AbortSigil;
-          }
-
           {
             var _debugInfo = lazy._debugInfo;
 
@@ -3393,8 +3253,9 @@ function emitPostponeChunk(request, id, postponeInstance) {
 
     try {
       // eslint-disable-next-line react-internal/safe-string-coercion
-      reason = String(postponeInstance.message);
-      stack = getStack(postponeInstance);
+      reason = String(postponeInstance.message); // eslint-disable-next-line react-internal/safe-string-coercion
+
+      stack = String(postponeInstance.stack);
     } catch (x) {}
 
     row = serializeRowHeader('P', id) + stringify({
@@ -3417,8 +3278,9 @@ function emitErrorChunk(request, id, digest, error) {
     try {
       if (error instanceof Error) {
         // eslint-disable-next-line react-internal/safe-string-coercion
-        message = String(error.message);
-        stack = getStack(error);
+        message = String(error.message); // eslint-disable-next-line react-internal/safe-string-coercion
+
+        stack = String(error.stack);
       } else if (typeof error === 'object' && error !== null) {
         message = describeObjectForErrorMessage(error);
       } else {
@@ -3895,7 +3757,6 @@ function retryTask(request, task) {
   }
 
   var prevDebugID = debugID;
-  task.status = RENDERING;
 
   try {
     // Track the root so we know that we have to emit this object even though it
@@ -3952,35 +3813,14 @@ function retryTask(request, task) {
     if (typeof x === 'object' && x !== null) {
       // $FlowFixMe[method-unbinding]
       if (typeof x.then === 'function') {
-        if (request.status === ABORTING) {
-          request.abortableTasks.delete(task);
-          task.status = ABORTED;
-          var errorId = request.fatalError;
-          var model = stringify(serializeByValueID(errorId));
-          emitModelChunk(request, task.id, model);
-          return;
-        } // Something suspended again, let's pick it back up later.
-
-
-        task.status = PENDING$1;
-        task.thenableState = getThenableStateAfterSuspending();
+        // Something suspended again, let's pick it back up later.
         var ping = task.ping;
         x.then(ping, ping);
+        task.thenableState = getThenableStateAfterSuspending();
         return;
       }
     }
 
-    if (x === AbortSigil) {
-      request.abortableTasks.delete(task);
-      task.status = ABORTED;
-      var _errorId3 = request.fatalError;
-
-      var _model = stringify(serializeByValueID(_errorId3));
-
-      emitModelChunk(request, task.id, _model);
-      return;
-    }
-
     request.abortableTasks.delete(task);
     task.status = ERRORED$1;
     var digest = logRecoverableError(request, x);
@@ -4042,11 +3882,6 @@ function performWork(request) {
 }
 
 function abortTask(task, request, errorId) {
-  if (task.status === RENDERING) {
-    // This task will be aborted by the render
-    return;
-  }
-
   task.status = ABORTED; // Instead of emitting an error per task.id, we emit a model that only
   // has a single value referencing the error.
 
@@ -4141,7 +3976,6 @@ function flushCompletedChunks(request, destination) {
 
   if (request.pendingChunks === 0) {
 
-    request.status = CLOSED;
     close$1(destination);
     request.destination = null;
   }
@@ -4162,14 +3996,10 @@ function enqueueFlush(request) {
   request.pingedTasks.length === 0 && // If there is no destination there is nothing we can flush to. A flush will
   // happen when we start flowing again
   request.destination !== null) {
+    var destination = request.destination;
     request.flushScheduled = true;
     scheduleWork(function () {
-      request.flushScheduled = false;
-      var destination = request.destination;
-
-      if (destination) {
-        flushCompletedChunks(request, destination);
-      }
+      return flushCompletedChunks(request, destination);
     });
   }
 }
@@ -4205,17 +4035,15 @@ function stopFlowing(request) {
 
 function abort(request, reason) {
   try {
-    request.status = ABORTING;
     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) {
       request.pendingChunks++;
       var errorId = request.nextChunkId++;
-      request.fatalError = errorId;
 
       var postponeInstance; if (enablePostpone && typeof reason === 'object' && reason !== null && reason.$$typeof === REACT_POSTPONE_TYPE) ; else {
-        var error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : typeof reason === 'object' && reason !== null && typeof reason.then === 'function' ? new Error('The render was aborted by the server with a promise.') : reason;
+        var error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
         var digest = logRecoverableError(request, error);
         emitErrorChunk(request, errorId, digest, error);
       }
@@ -4232,7 +4060,7 @@ function abort(request, reason) {
       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.') : typeof reason === 'object' && reason !== null && typeof reason.then === 'function' ? new Error('The render was aborted by the server with a promise.') : reason;
+        _error = reason === undefined ? new Error('The render was aborted by the server without a reason.') : reason;
       }
 
       abortListeners.forEach(function (callback) {