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

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

@@ -20,7 +20,12 @@ require('crypto');
 var async_hooks = require('async_hooks');
 var ReactDOM = require('react-dom');
 
-var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+var ReactSharedInternalsServer = // $FlowFixMe: It's defined in the one we resolve to.
+React.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+
+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.');
+}
 
 function error(format) {
   {
@@ -38,8 +43,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 = ReactSharedInternalsServer.getStackAddendum();
 
     if (stack !== '') {
       format += '%s';
@@ -520,18 +524,45 @@ function getServerReferenceBoundArguments(config, serverReference) {
   return serverReference.$$bound;
 }
 
-var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-
-var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.ReactDOMCurrentDispatcher;
-var previousDispatcher = ReactDOMCurrentDispatcher.current;
-ReactDOMCurrentDispatcher.current = {
-  prefetchDNS: prefetchDNS,
-  preconnect: preconnect,
-  preload: preload,
-  preloadModule: preloadModule$1,
-  preinitStyle: preinitStyle,
-  preinitScript: preinitScript,
-  preinitModuleScript: preinitModuleScript
+var ReactDOMSharedInternals = ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+
+var previousDispatcher = ReactDOMSharedInternals.d;
+/* ReactDOMCurrentDispatcher */
+
+ReactDOMSharedInternals.d
+/* ReactDOMCurrentDispatcher */
+= {
+  f
+  /* flushSyncWork */
+  : previousDispatcher.f
+  /* flushSyncWork */
+  ,
+  r
+  /* requestFormReset */
+  : previousDispatcher.r
+  /* requestFormReset */
+  ,
+  D
+  /* prefetchDNS */
+  : prefetchDNS,
+  C
+  /* preconnect */
+  : preconnect,
+  L
+  /* preload */
+  : preload,
+  m
+  /* preloadModule */
+  : preloadModule$1,
+  X
+  /* preinitScript */
+  : preinitScript,
+  S
+  /* preinitStyle */
+  : preinitStyle,
+  M
+  /* preinitModuleScript */
+  : preinitModuleScript
 };
 
 function prefetchDNS(href) {
@@ -550,7 +581,9 @@ function prefetchDNS(href) {
       hints.add(key);
       emitHint(request, 'D', href);
     } else {
-      previousDispatcher.prefetchDNS(href);
+      previousDispatcher.D(
+      /* prefetchDNS */
+      href);
     }
   }
 }
@@ -576,7 +609,9 @@ function preconnect(href, crossOrigin) {
         emitHint(request, 'C', href);
       }
     } else {
-      previousDispatcher.preconnect(href, crossOrigin);
+      previousDispatcher.C(
+      /* preconnect */
+      href, crossOrigin);
     }
   }
 }
@@ -609,7 +644,9 @@ function preload(href, as, options) {
         emitHint(request, 'L', [href, as]);
       }
     } else {
-      previousDispatcher.preload(href, as, options);
+      previousDispatcher.L(
+      /* preload */
+      href, as, options);
     }
   }
 }
@@ -636,7 +673,9 @@ function preloadModule$1(href, options) {
         return emitHint(request, 'm', href);
       }
     } else {
-      previousDispatcher.preloadModule(href, options);
+      previousDispatcher.m(
+      /* preloadModule */
+      href, options);
     }
   }
 }
@@ -665,7 +704,9 @@ function preinitStyle(href, precedence, options) {
         return emitHint(request, 'S', href);
       }
     } else {
-      previousDispatcher.preinitStyle(href, precedence, options);
+      previousDispatcher.S(
+      /* preinitStyle */
+      href, precedence, options);
     }
   }
 }
@@ -692,7 +733,9 @@ function preinitScript(src, options) {
         return emitHint(request, 'X', src);
       }
     } else {
-      previousDispatcher.preinitScript(src, options);
+      previousDispatcher.X(
+      /* preinitScript */
+      src, options);
     }
   }
 }
@@ -719,7 +762,9 @@ function preinitModuleScript(src, options) {
         return emitHint(request, 'M', src);
       }
     } else {
-      previousDispatcher.preinitModuleScript(src, options);
+      previousDispatcher.M(
+      /* preinitModuleScript */
+      src, options);
     }
   }
 } // Flight normally encodes undefined as a special character however for directive option
@@ -992,21 +1037,34 @@ function getSuspendedThenable() {
 var currentRequest$1 = null;
 var thenableIndexCounter = 0;
 var thenableState = null;
+var currentComponentDebugInfo = null;
 function prepareToUseHooksForRequest(request) {
   currentRequest$1 = request;
 }
 function resetHooksForRequest() {
   currentRequest$1 = null;
 }
-function prepareToUseHooksForComponent(prevThenableState) {
+function prepareToUseHooksForComponent(prevThenableState, componentDebugInfo) {
   thenableIndexCounter = 0;
   thenableState = prevThenableState;
+
+  {
+    currentComponentDebugInfo = componentDebugInfo;
+  }
 }
 function getThenableStateAfterSuspending() {
   // If you use() to Suspend this should always exist but if you throw a Promise instead,
   // which is not really supported anymore, it will be empty. We use the empty set as a
   // marker to know if this was a replay of the same component or first attempt.
   var state = thenableState || createThenableState();
+
+  {
+    // This is a hack but we stash the debug info here so that we don't need a completely
+    // different data structure just for this in DEV. Not too happy about it.
+    state._componentDebugInfo = currentComponentDebugInfo;
+    currentComponentDebugInfo = null;
+  }
+
   thenableState = null;
   return state;
 }
@@ -1464,12 +1522,7 @@ function describeObjectForErrorMessage(objectOrArray, expandedName) {
   return '\n  ' + str;
 }
 
-var ReactSharedServerInternals = // $FlowFixMe: It's defined in the one we resolve to.
-React.__SECRET_SERVER_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-
-if (!ReactSharedServerInternals) {
-  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 ReactSharedInternals = ReactSharedInternalsServer;
 
 var ObjectPrototype = Object.prototype;
 var stringify = JSON.stringify; // Serializable values
@@ -1483,8 +1536,6 @@ var ERRORED$1 = 4; // object reference status
 
 var SEEN_BUT_NOT_YET_OUTLINED = -1;
 var NEVER_OUTLINED = -2;
-var ReactCurrentCache = ReactSharedServerInternals.ReactCurrentCache;
-var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
 
 function defaultErrorHandler(error) {
   console['error'](error); // Don't transform to our wrapper
@@ -1497,11 +1548,11 @@ var OPEN = 0;
 var CLOSING = 1;
 var CLOSED = 2;
 function createRequest(model, bundlerConfig, onError, identifierPrefix, onPostpone, environmentName) {
-  if (ReactCurrentCache.current !== null && ReactCurrentCache.current !== DefaultCacheDispatcher) {
+  if (ReactSharedInternals.C !== null && ReactSharedInternals.C !== DefaultCacheDispatcher) {
     throw new Error('Currently React only supports one RSC renderer at a time.');
   }
 
-  ReactCurrentCache.current = DefaultCacheDispatcher;
+  ReactSharedInternals.C = DefaultCacheDispatcher;
   var abortSet = new Set();
   var pingedTasks = [];
   var cleanupQueue = [];
@@ -1710,33 +1761,56 @@ function createLazyWrapperAroundWakeable(wakeable) {
   return lazyType;
 }
 
-function renderFunctionComponent(request, task, key, Component, props) {
+function renderFunctionComponent(request, task, key, Component, props, owner) {
   // 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
   // component suspends again, the thenable state will be restored.
   var prevThenableState = task.thenableState;
   task.thenableState = null;
+  var componentDebugInfo = null;
 
   {
     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 if (prevThenableState !== null) ; else {
+    } else if (prevThenableState !== null) {
+      // This is a replay and we've already emitted the debug info of this component
+      // in the first pass. We skip emitting a duplicate line.
+      // As a hack we stashed the previous component debug info on this object in DEV.
+      componentDebugInfo = prevThenableState._componentDebugInfo;
+    } else {
       // This is a new component in the same task so we can emit more debug info.
       var componentName = Component.displayName || Component.name || '';
       request.pendingChunks++;
-      emitDebugChunk(request, debugID, {
+      var componentDebugID = debugID;
+      componentDebugInfo = {
         name: componentName,
-        env: request.environmentName
-      });
+        env: request.environmentName,
+        owner: owner
+      }; // We outline this model eagerly so that we can refer to by reference as an owner.
+      // If we had a smarter way to dedupe we might not have to do this if there ends up
+      // being no references to this as an owner.
+
+      outlineModel(request, componentDebugInfo);
+      emitDebugChunk(request, componentDebugID, componentDebugInfo);
     }
   }
 
-  prepareToUseHooksForComponent(prevThenableState); // The secondArg is always undefined in Server Components since refs error early.
+  prepareToUseHooksForComponent(prevThenableState, componentDebugInfo); // The secondArg is always undefined in Server Components since refs error early.
 
   var secondArg = undefined;
-  var result = Component(props, secondArg);
+  var result;
+
+  {
+    ReactSharedInternals.owner = componentDebugInfo;
+
+    try {
+      result = Component(props, secondArg);
+    } finally {
+      ReactSharedInternals.owner = null;
+    }
+  }
 
   if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
     // When the return value is in children position we can resolve it immediately,
@@ -1827,7 +1901,8 @@ function renderFragment(request, task, children) {
   return children;
 }
 
-function renderClientElement(task, type, key, props) {
+function renderClientElement(task, type, key, props, owner) // DEV-only
+{
   // the keys of any Server Components which are not serialized.
 
 
@@ -1839,7 +1914,7 @@ function renderClientElement(task, type, key, props) {
     key = keyPath + ',' + key;
   }
 
-  var element = [REACT_ELEMENT_TYPE, type, key, props];
+  var element = [REACT_ELEMENT_TYPE, type, key, props, owner] ;
 
   if (task.implicitSlot && key !== null) {
     // The root Server Component had no key so it was in an implicit slot.
@@ -1877,7 +1952,8 @@ function outlineTask(request, task) {
   return serializeLazyID(newTask.id);
 }
 
-function renderElement(request, task, type, key, ref, props) {
+function renderElement(request, task, type, key, ref, props, owner) // DEV only
+{
   if (ref !== null && ref !== undefined) {
     // When the ref moves to the regular props object this will implicitly
     // throw for functions. We could probably relax it to a DEV warning for other
@@ -1898,14 +1974,14 @@ function renderElement(request, task, type, key, ref, props) {
   if (typeof type === 'function') {
     if (isClientReference(type) || isTemporaryReference(type)) {
       // This is a reference to a Client Component.
-      return renderClientElement(task, type, key, props);
+      return renderClientElement(task, type, key, props, owner);
     } // This is a Server Component.
 
 
-    return renderFunctionComponent(request, task, key, type, props);
+    return renderFunctionComponent(request, task, key, type, props, owner);
   } else if (typeof type === 'string') {
     // This is a host element. E.g. HTML.
-    return renderClientElement(task, type, key, props);
+    return renderClientElement(task, type, key, props, owner);
   } else if (typeof type === 'symbol') {
     if (type === REACT_FRAGMENT_TYPE && key === null) {
       // For key-less fragments, we add a small optimization to avoid serializing
@@ -1923,11 +1999,11 @@ function renderElement(request, task, type, key, ref, props) {
     // Any built-in works as long as its props are serializable.
 
 
-    return renderClientElement(task, type, key, props);
+    return renderClientElement(task, type, key, props, owner);
   } else if (type != null && typeof type === 'object') {
     if (isClientReference(type)) {
       // This is a reference to a Client Component.
-      return renderClientElement(task, type, key, props);
+      return renderClientElement(task, type, key, props, owner);
     }
 
     switch (type.$$typeof) {
@@ -1936,17 +2012,17 @@ function renderElement(request, task, type, key, ref, props) {
           var payload = type._payload;
           var init = type._init;
           var wrappedType = init(payload);
-          return renderElement(request, task, wrappedType, key, ref, props);
+          return renderElement(request, task, wrappedType, key, ref, props, owner);
         }
 
       case REACT_FORWARD_REF_TYPE:
         {
-          return renderFunctionComponent(request, task, key, type.render, props);
+          return renderFunctionComponent(request, task, key, type.render, props, owner);
         }
 
       case REACT_MEMO_TYPE:
         {
-          return renderElement(request, task, type.type, key, ref, props);
+          return renderElement(request, task, type.type, key, ref, props, owner);
         }
     }
   }
@@ -2025,6 +2101,10 @@ function serializeLazyID(id) {
   return '$L' + id.toString(16);
 }
 
+function serializeInfinitePromise() {
+  return '$@';
+}
+
 function serializePromiseID(id) {
   return '$@' + id.toString(16);
 }
@@ -2189,6 +2269,12 @@ function serializeMap(request, map) {
   return '$Q' + id.toString(16);
 }
 
+function serializeFormData(request, formData) {
+  var entries = Array.from(formData.entries());
+  var id = outlineModel(request, entries);
+  return '$K' + id.toString(16);
+}
+
 function serializeSet(request, set) {
   var entries = Array.from(set);
 
@@ -2365,7 +2451,7 @@ function renderModelDestructive(request, task, parent, parentPropertyName, value
 
 
           return renderElement(request, task, element.type, // $FlowFixMe[incompatible-call] the key of an element is null | string
-          element.key, ref, props);
+          element.key, ref, props, element._owner );
         }
 
       case REACT_LAZY_TYPE:
@@ -2463,6 +2549,11 @@ function renderModelDestructive(request, task, parent, parentPropertyName, value
 
     if (value instanceof Set) {
       return serializeSet(request, value);
+    } // TODO: FormData is not available in old Node. Remove the typeof later.
+
+
+    if (typeof FormData === 'function' && value instanceof FormData) {
+      return serializeFormData(request, value);
     }
 
     var iteratorFn = getIteratorFn(value);
@@ -2726,14 +2817,216 @@ function emitModelChunk(request, id, json) {
 }
 
 function emitDebugChunk(request, id, debugInfo) {
+  // use the full serialization that requires a task.
+
+
+  var counter = {
+    objectCount: 0
+  };
 
+  function replacer(parentPropertyName, value) {
+    return renderConsoleValue(request, counter, this, parentPropertyName, value);
+  } // $FlowFixMe[incompatible-type] stringify can return null
 
-  var json = stringify(debugInfo);
+
+  var json = stringify(debugInfo, replacer);
   var row = serializeRowHeader('D', id) + json + '\n';
   var processedChunk = stringToChunk(row);
   request.completedRegularChunks.push(processedChunk);
 }
 
+function serializeEval(source) {
+
+  return '$E' + source;
+} // This is a forked version of renderModel which should never error, never suspend and is limited
+// in the depth it can encode.
+
+
+function renderConsoleValue(request, counter, parent, parentPropertyName, value) {
+  // Make sure that `parent[parentPropertyName]` wasn't JSONified before `value` was passed to us
+  // $FlowFixMe[incompatible-use]
+  var originalValue = parent[parentPropertyName];
+
+  if (value === null) {
+    return null;
+  }
+
+  if (typeof value === 'object') {
+    if (isClientReference(value)) {
+      // We actually have this value on the client so we could import it.
+      // This might be confusing though because on the Server it won't actually
+      // be this value, so if you're debugging client references maybe you'd be
+      // better with a place holder.
+      return serializeClientReference(request, parent, parentPropertyName, value);
+    }
+
+    if (counter.objectCount > 20) {
+      // We've reached our max number of objects to serialize across the wire so we serialize this
+      // object but no properties inside of it, as a place holder.
+      return Array.isArray(value) ? [] : {};
+    }
+
+    counter.objectCount++;
+    var writtenObjects = request.writtenObjects;
+    var existingId = writtenObjects.get(value); // $FlowFixMe[method-unbinding]
+
+    if (typeof value.then === 'function') {
+      if (existingId !== undefined) {
+        // We've seen this promise before, so we can just refer to the same result.
+        return serializePromiseID(existingId);
+      }
+
+      var thenable = value;
+
+      switch (thenable.status) {
+        case 'fulfilled':
+          {
+            return serializePromiseID(outlineConsoleValue(request, counter, thenable.value));
+          }
+
+        case 'rejected':
+          {
+            var x = thenable.reason;
+            request.pendingChunks++;
+            var errorId = request.nextChunkId++;
+
+            {
+              // We don't log these errors since they didn't actually throw into Flight.
+              var digest = '';
+              emitErrorChunk(request, errorId, digest, x);
+            }
+
+            return serializePromiseID(errorId);
+          }
+      } // If it hasn't already resolved (and been instrumented) we just encode an infinite
+      // promise that will never resolve.
+
+
+      return serializeInfinitePromise();
+    }
+
+    if (existingId !== undefined && existingId >= 0) {
+      // We've already emitted this as a real object, so we can
+      // just refer to that by its existing ID.
+      return serializeByValueID(existingId);
+    }
+
+    if (isArray(value)) {
+      return value;
+    }
+
+    if (value instanceof Map) {
+      return serializeMap(request, value);
+    }
+
+    if (value instanceof Set) {
+      return serializeSet(request, value);
+    } // TODO: FormData is not available in old Node. Remove the typeof later.
+
+
+    if (typeof FormData === 'function' && value instanceof FormData) {
+      return serializeFormData(request, value);
+    }
+
+    var iteratorFn = getIteratorFn(value);
+
+    if (iteratorFn) {
+      return Array.from(value);
+    } // $FlowFixMe[incompatible-return]
+
+
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    if (value[value.length - 1] === 'Z') {
+      // Possibly a Date, whose toJSON automatically calls toISOString
+      if (originalValue instanceof Date) {
+        return serializeDateFromDateJSON(value);
+      }
+    }
+
+    if (value.length >= 1024) {
+      // For large strings, we encode them outside the JSON payload so that we
+      // don't have to double encode and double parse the strings. This can also
+      // be more compact in case the string has a lot of escaped characters.
+      return serializeLargeTextString(request, value);
+    }
+
+    return escapeStringValue(value);
+  }
+
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return serializeNumber(value);
+  }
+
+  if (typeof value === 'undefined') {
+    return serializeUndefined();
+  }
+
+  if (typeof value === 'function') {
+    if (isClientReference(value)) {
+      return serializeClientReference(request, parent, parentPropertyName, value);
+    }
+
+    if (isTemporaryReference(value)) {
+      return serializeTemporaryReference(request, value);
+    } // Serialize the body of the function as an eval so it can be printed.
+    // $FlowFixMe[method-unbinding]
+
+
+    return serializeEval('(' + Function.prototype.toString.call(value) + ')');
+  }
+
+  if (typeof value === 'symbol') {
+    var writtenSymbols = request.writtenSymbols;
+
+    var _existingId3 = writtenSymbols.get(value);
+
+    if (_existingId3 !== undefined) {
+      return serializeByValueID(_existingId3);
+    } // $FlowFixMe[incompatible-type] `description` might be undefined
+
+
+    var name = value.description; // We use the Symbol.for version if it's not a global symbol. Close enough.
+
+    request.pendingChunks++;
+    var symbolId = request.nextChunkId++;
+    emitSymbolChunk(request, symbolId, name);
+    return serializeByValueID(symbolId);
+  }
+
+  if (typeof value === 'bigint') {
+    return serializeBigInt(value);
+  }
+
+  return 'unknown type ' + typeof value;
+}
+
+function outlineConsoleValue(request, counter, model) {
+
+  function replacer(parentPropertyName, value) {
+    try {
+      return renderConsoleValue(request, counter, this, parentPropertyName, value);
+    } catch (x) {
+      return 'unknown value';
+    }
+  } // $FlowFixMe[incompatible-type] stringify can return null
+
+
+  var json = stringify(model, replacer);
+  request.pendingChunks++;
+  var id = request.nextChunkId++;
+  var row = id.toString(16) + ':' + json + '\n';
+  var processedChunk = stringToChunk(row);
+  request.completedRegularChunks.push(processedChunk);
+  return id;
+}
+
 function forwardDebugInfo(request, id, debugInfo) {
   for (var i = 0; i < debugInfo.length; i++) {
     request.pendingChunks++;
@@ -2825,8 +3118,8 @@ function retryTask(request, task) {
 }
 
 function performWork(request) {
-  var prevDispatcher = ReactCurrentDispatcher.current;
-  ReactCurrentDispatcher.current = HooksDispatcher;
+  var prevDispatcher = ReactSharedInternals.H;
+  ReactSharedInternals.H = HooksDispatcher;
   var prevRequest = currentRequest;
   currentRequest = request;
   prepareToUseHooksForRequest(request);
@@ -2847,7 +3140,7 @@ function performWork(request) {
     logRecoverableError(request, error);
     fatalError(request, error);
   } finally {
-    ReactCurrentDispatcher.current = prevDispatcher;
+    ReactSharedInternals.H = prevDispatcher;
     resetHooksForRequest();
     currentRequest = prevRequest;
   }