react-server-dom-webpack 19.0.0-rc-a26e3f403e-20240611 → 19.0.0-rc-dfd30974ab-20240613

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

@@ -626,7 +626,6 @@ Chunk.prototype.then = function (resolve, reject) {
       break;
     case "pending":
     case "blocked":
-    case "cyclic":
       resolve &&
         (null === this.value && (this.value = []), this.value.push(resolve));
       reject &&
@@ -649,7 +648,6 @@ function readChunk(chunk) {
       return chunk.value;
     case "pending":
     case "blocked":
-    case "cyclic":
       throw chunk;
     default:
       throw chunk.reason;
@@ -668,7 +666,6 @@ function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
       break;
     case "pending":
     case "blocked":
-    case "cyclic":
       if (chunk.value)
         for (var i = 0; i < resolveListeners.length; i++)
           chunk.value.push(resolveListeners[i]);
@@ -734,35 +731,35 @@ function resolveModuleChunk(chunk, value) {
       wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners));
   }
 }
-var initializingChunk = null,
-  initializingChunkBlockedModel = null;
+var initializingHandler = null;
 function initializeModelChunk(chunk) {
-  var prevChunk = initializingChunk,
-    prevBlocked = initializingChunkBlockedModel;
-  initializingChunk = chunk;
-  initializingChunkBlockedModel = null;
+  var prevHandler = initializingHandler;
+  initializingHandler = null;
   var resolvedModel = chunk.value;
-  chunk.status = "cyclic";
+  chunk.status = "blocked";
   chunk.value = null;
   chunk.reason = null;
   try {
-    var value = JSON.parse(resolvedModel, chunk._response._fromJSON);
-    if (
-      null !== initializingChunkBlockedModel &&
-      0 < initializingChunkBlockedModel.deps
-    )
-      (initializingChunkBlockedModel.value = value), (chunk.status = "blocked");
-    else {
-      var resolveListeners = chunk.value;
-      chunk.status = "fulfilled";
-      chunk.value = value;
-      null !== resolveListeners && wakeChunk(resolveListeners, value);
+    var value = JSON.parse(resolvedModel, chunk._response._fromJSON),
+      resolveListeners = chunk.value;
+    null !== resolveListeners &&
+      ((chunk.value = null),
+      (chunk.reason = null),
+      wakeChunk(resolveListeners, value));
+    if (null !== initializingHandler) {
+      if (initializingHandler.errored) throw initializingHandler.value;
+      if (0 < initializingHandler.deps) {
+        initializingHandler.value = value;
+        initializingHandler.chunk = chunk;
+        return;
+      }
     }
+    chunk.status = "fulfilled";
+    chunk.value = value;
   } catch (error) {
     (chunk.status = "rejected"), (chunk.reason = error);
   } finally {
-    (initializingChunk = prevChunk),
-      (initializingChunkBlockedModel = prevBlocked);
+    initializingHandler = prevHandler;
   }
 }
 function initializeModuleChunk(chunk) {
@@ -788,46 +785,71 @@ function reportGlobalError(response, error) {
     "pending" === chunk.status && triggerErrorOnChunk(chunk, error);
   });
 }
+function createLazyChunkWrapper(chunk) {
+  return { $$typeof: REACT_LAZY_TYPE, _payload: chunk, _init: readChunk };
+}
 function getChunk(response, id) {
   var chunks = response._chunks,
     chunk = chunks.get(id);
   chunk || ((chunk = createPendingChunk(response)), chunks.set(id, chunk));
   return chunk;
 }
-function createModelResolver(
-  chunk,
+function waitForReference(
+  referencedChunk,
   parentObject,
   key,
-  cyclic,
   response,
   map,
   path
 ) {
-  if (initializingChunkBlockedModel) {
-    var blocked = initializingChunkBlockedModel;
-    cyclic || blocked.deps++;
+  function fulfill(value) {
+    for (var i = 1; i < path.length; i++) {
+      for (; value.$$typeof === REACT_LAZY_TYPE; )
+        if (((value = value._payload), value === handler.chunk))
+          value = handler.value;
+        else if ("fulfilled" === value.status) value = value.value;
+        else {
+          path.splice(0, i - 1);
+          value.then(fulfill, reject);
+          return;
+        }
+      value = value[path[i]];
+    }
+    parentObject[key] = map(response, value);
+    "" === key && null === handler.value && (handler.value = parentObject[key]);
+    handler.deps--;
+    0 === handler.deps &&
+      ((i = handler.chunk),
+      null !== i &&
+        "blocked" === i.status &&
+        ((value = i.value),
+        (i.status = "fulfilled"),
+        (i.value = handler.value),
+        null !== value && wakeChunk(value, handler.value)));
+  }
+  function reject(error) {
+    if (!handler.errored) {
+      handler.errored = !0;
+      handler.value = error;
+      var chunk = handler.chunk;
+      null !== chunk &&
+        "blocked" === chunk.status &&
+        triggerErrorOnChunk(chunk, error);
+    }
+  }
+  if (initializingHandler) {
+    var handler = initializingHandler;
+    handler.deps++;
   } else
-    blocked = initializingChunkBlockedModel = {
-      deps: cyclic ? 0 : 1,
-      value: null
+    handler = initializingHandler = {
+      parent: null,
+      chunk: null,
+      value: null,
+      deps: 1,
+      errored: !1
     };
-  return function (value) {
-    for (var i = 1; i < path.length; i++) value = value[path[i]];
-    parentObject[key] = map(response, value);
-    "" === key && null === blocked.value && (blocked.value = parentObject[key]);
-    blocked.deps--;
-    0 === blocked.deps &&
-      "blocked" === chunk.status &&
-      ((value = chunk.value),
-      (chunk.status = "fulfilled"),
-      (chunk.value = blocked.value),
-      null !== value && wakeChunk(value, blocked.value));
-  };
-}
-function createModelReject(chunk) {
-  return function (error) {
-    return triggerErrorOnChunk(chunk, error);
-  };
+  referencedChunk.then(fulfill, reject);
+  return null;
 }
 function createServerReferenceProxy(response, metaData) {
   function proxy() {
@@ -864,23 +886,21 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
       return map(response, parentObject);
     case "pending":
     case "blocked":
-    case "cyclic":
-      var parentChunk = initializingChunk;
-      id.then(
-        createModelResolver(
-          parentChunk,
-          parentObject,
-          key,
-          "cyclic" === id.status,
-          response,
-          map,
-          reference
-        ),
-        createModelReject(parentChunk)
-      );
-      return null;
+      return waitForReference(id, parentObject, key, response, map, reference);
     default:
-      throw id.reason;
+      return (
+        initializingHandler
+          ? ((initializingHandler.errored = !0),
+            (initializingHandler.value = id.reason))
+          : (initializingHandler = {
+              parent: null,
+              chunk: null,
+              value: id.reason,
+              deps: 0,
+              errored: !0
+            }),
+        null
+      );
   }
 }
 function createMap(response, model) {
@@ -906,7 +926,19 @@ function createModel(response, model) {
 }
 function parseModelString(response, parentObject, key, value) {
   if ("$" === value[0]) {
-    if ("$" === value) return REACT_ELEMENT_TYPE;
+    if ("$" === value)
+      return (
+        null !== initializingHandler &&
+          "0" === key &&
+          (initializingHandler = {
+            parent: initializingHandler,
+            chunk: null,
+            value: null,
+            deps: 0,
+            errored: !1
+          }),
+        REACT_ELEMENT_TYPE
+      );
     switch (value[1]) {
       case "$":
         return value.slice(1);
@@ -914,7 +946,7 @@ function parseModelString(response, parentObject, key, value) {
         return (
           (parentObject = parseInt(value.slice(2), 16)),
           (response = getChunk(response, parentObject)),
-          { $$typeof: REACT_LAZY_TYPE, _payload: response, _init: readChunk }
+          createLazyChunkWrapper(response)
         );
       case "@":
         if (2 === value.length) return new Promise(function () {});
@@ -1100,8 +1132,8 @@ function startReadableStream(response, id, type) {
             (previousBlockedChunk = chunk));
       } else {
         chunk = previousBlockedChunk;
-        var chunk$51 = createPendingChunk(response);
-        chunk$51.then(
+        var chunk$52 = createPendingChunk(response);
+        chunk$52.then(
           function (v) {
             return controller.enqueue(v);
           },
@@ -1109,10 +1141,10 @@ function startReadableStream(response, id, type) {
             return controller.error(e);
           }
         );
-        previousBlockedChunk = chunk$51;
+        previousBlockedChunk = chunk$52;
         chunk.then(function () {
-          previousBlockedChunk === chunk$51 && (previousBlockedChunk = null);
-          resolveModelChunk(chunk$51, json);
+          previousBlockedChunk === chunk$52 && (previousBlockedChunk = null);
+          resolveModelChunk(chunk$52, json);
         });
       }
     },
@@ -1240,8 +1272,8 @@ function mergeBuffer(buffer, lastChunk) {
   for (var l = buffer.length, byteLength = lastChunk.length, i = 0; i < l; i++)
     byteLength += buffer[i].byteLength;
   byteLength = new Uint8Array(byteLength);
-  for (var i$52 = (i = 0); i$52 < l; i$52++) {
-    var chunk = buffer[i$52];
+  for (var i$53 = (i = 0); i$53 < l; i$53++) {
+    var chunk = buffer[i$53];
     byteLength.set(chunk, i);
     i += chunk.byteLength;
   }
@@ -1417,21 +1449,37 @@ function processFullRow(response, id, tag, buffer, chunk) {
 }
 function createFromJSONCallback(response) {
   return function (key, value) {
-    return "string" === typeof value
-      ? parseModelString(response, this, key, value)
-      : "object" === typeof value && null !== value
-      ? ((key =
-          value[0] === REACT_ELEMENT_TYPE
-            ? {
-                $$typeof: REACT_ELEMENT_TYPE,
-                type: value[1],
-                key: value[2],
-                ref: null,
-                props: value[3]
-              }
-            : value),
-        key)
-      : value;
+    if ("string" === typeof value)
+      return parseModelString(response, this, key, value);
+    if ("object" === typeof value && null !== value) {
+      if (value[0] === REACT_ELEMENT_TYPE) {
+        if (
+          ((key = {
+            $$typeof: REACT_ELEMENT_TYPE,
+            type: value[1],
+            key: value[2],
+            ref: null,
+            props: value[3]
+          }),
+          null !== initializingHandler)
+        )
+          if (
+            ((value = initializingHandler),
+            (initializingHandler = value.parent),
+            value.errored)
+          )
+            (key = new Chunk("rejected", null, value.value, response)),
+              (key = createLazyChunkWrapper(key));
+          else if (0 < value.deps) {
+            var blockedChunk = new Chunk("blocked", null, null, response);
+            value.value = key;
+            value.chunk = blockedChunk;
+            key = createLazyChunkWrapper(blockedChunk);
+          }
+      } else key = value;
+      return key;
+    }
+    return value;
   };
 }
 function noServerCall() {

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

@@ -518,7 +518,15 @@
       this.onPostpone =
         void 0 === onPostpone ? defaultPostponeHandler : onPostpone;
       this.environmentName =
-        void 0 === environmentName ? "Server" : environmentName;
+        void 0 === environmentName
+          ? function () {
+              return "Server";
+            }
+          : "function" !== typeof environmentName
+          ? function () {
+              return environmentName;
+            }
+          : environmentName;
       this.didWarnForKey = null;
       model = createTask(this, model, null, !1, abortSet);
       pingedTasks.push(model);
@@ -772,16 +780,14 @@
       if (null !== prevThenableState)
         owner = prevThenableState._componentDebugInfo;
       else {
-        var componentName = Component.displayName || Component.name || "";
+        var componentDebugID = debugID,
+          componentName = Component.displayName || Component.name || "",
+          componentEnv = request.environmentName();
         request.pendingChunks++;
-        var componentDebugID = debugID;
-        owner = {
-          name: componentName,
-          env: request.environmentName,
-          owner: owner
-        };
+        owner = { name: componentName, env: componentEnv, owner: owner };
         outlineModel(request, owner);
         emitDebugChunk(request, componentDebugID, owner);
+        task.environmentName = componentEnv;
       }
       prepareToUseHooksForComponent(prevThenableState, owner);
       props = callComponentInDEV(Component, props, owner);
@@ -1067,28 +1073,28 @@
                   ? serializeLazyID(JSCompiler_inline_result.id)
                   : serializeByValueID(JSCompiler_inline_result.id);
               }
-            else if (thrownValue === AbortSigil)
-              (originalValue.status = 3),
-                (originalValue = request.fatalError),
-                (JSCompiler_inline_result = parentPropertyName
-                  ? serializeLazyID(originalValue)
-                  : serializeByValueID(originalValue));
-            else if (
-              ((originalValue.keyPath = prevKeyPath),
-              (originalValue.implicitSlot = prevImplicitSlot),
-              parentPropertyName)
-            )
-              request.pendingChunks++,
-                (originalValue = request.nextChunkId++),
-                (prevKeyPath = logRecoverableError(request, value)),
-                emitErrorChunk(request, originalValue, prevKeyPath, value),
-                (JSCompiler_inline_result = serializeLazyID(originalValue));
-            else throw value;
+            else
+              thrownValue === AbortSigil
+                ? ((originalValue.status = 3),
+                  (originalValue = request.fatalError),
+                  (JSCompiler_inline_result = parentPropertyName
+                    ? serializeLazyID(originalValue)
+                    : serializeByValueID(originalValue)))
+                : ((originalValue.keyPath = prevKeyPath),
+                  (originalValue.implicitSlot = prevImplicitSlot),
+                  request.pendingChunks++,
+                  (originalValue = request.nextChunkId++),
+                  (prevKeyPath = logRecoverableError(request, value)),
+                  emitErrorChunk(request, originalValue, prevKeyPath, value),
+                  (JSCompiler_inline_result = parentPropertyName
+                    ? serializeLazyID(originalValue)
+                    : serializeByValueID(originalValue)));
           }
           return JSCompiler_inline_result;
         },
         thenableState: null
       };
+      task.environmentName = request.environmentName();
       abortSet.add(task);
       return task;
     }
@@ -1244,7 +1250,8 @@
       if ("object" === typeof value) {
         switch (value.$$typeof) {
           case REACT_ELEMENT_TYPE:
-            var _writtenObjects = request.writtenObjects;
+            var elementReference = null,
+              _writtenObjects = request.writtenObjects;
             if (null === task.keyPath && !task.implicitSlot) {
               var _existingReference = _writtenObjects.get(value);
               if (void 0 !== _existingReference)
@@ -1254,10 +1261,8 @@
                 -1 === parentPropertyName.indexOf(":") &&
                   ((parent = _writtenObjects.get(parent)),
                   void 0 !== parent &&
-                    _writtenObjects.set(
-                      value,
-                      parent + ":" + parentPropertyName
-                    ));
+                    ((elementReference = parent + ":" + parentPropertyName),
+                    _writtenObjects.set(value, elementReference)));
             }
             if ((parentPropertyName = value._debugInfo)) {
               if (null === debugID) return outlineTask(request, task);
@@ -1265,7 +1270,7 @@
             }
             parentPropertyName = value.props;
             parent = parentPropertyName.ref;
-            return renderElement(
+            value = renderElement(
               request,
               task,
               value.type,
@@ -1274,6 +1279,12 @@
               parentPropertyName,
               value._owner
             );
+            "object" === typeof value &&
+              null !== value &&
+              null !== elementReference &&
+              (_writtenObjects.has(value) ||
+                _writtenObjects.set(value, elementReference));
+            return value;
           case REACT_LAZY_TYPE:
             task.thenableState = null;
             parentPropertyName = callLazyInitInDEV(value);
@@ -1303,46 +1314,49 @@
           );
         if (
           void 0 !== request.temporaryReferences &&
-          ((_writtenObjects = request.temporaryReferences.get(value)),
-          void 0 !== _writtenObjects)
+          ((elementReference = request.temporaryReferences.get(value)),
+          void 0 !== elementReference)
         )
-          return "$T" + _writtenObjects;
-        _writtenObjects = request.writtenObjects;
-        _existingReference = _writtenObjects.get(value);
+          return "$T" + elementReference;
+        elementReference = request.writtenObjects;
+        _writtenObjects = elementReference.get(value);
         if ("function" === typeof value.then) {
-          if (void 0 !== _existingReference) {
+          if (void 0 !== _writtenObjects) {
             if (null !== task.keyPath || task.implicitSlot)
               return (
                 "$@" + serializeThenable(request, task, value).toString(16)
               );
             if (modelRoot === value) modelRoot = null;
-            else return _existingReference;
+            else return _writtenObjects;
           }
           request = "$@" + serializeThenable(request, task, value).toString(16);
-          _writtenObjects.set(value, request);
+          elementReference.set(value, request);
           return request;
         }
-        if (void 0 !== _existingReference)
+        if (void 0 !== _writtenObjects)
           if (modelRoot === value) modelRoot = null;
-          else return _existingReference;
+          else return _writtenObjects;
         else if (
           -1 === parentPropertyName.indexOf(":") &&
-          ((_existingReference = _writtenObjects.get(parent)),
-          void 0 !== _existingReference)
+          ((_writtenObjects = elementReference.get(parent)),
+          void 0 !== _writtenObjects)
         ) {
-          var propertyName = parentPropertyName;
+          _existingReference = parentPropertyName;
           if (isArrayImpl(parent) && parent[0] === REACT_ELEMENT_TYPE)
             switch (parentPropertyName) {
               case "1":
-                propertyName = "type";
+                _existingReference = "type";
                 break;
               case "2":
-                propertyName = "key";
+                _existingReference = "key";
                 break;
               case "3":
-                propertyName = "props";
+                _existingReference = "props";
             }
-          _writtenObjects.set(value, _existingReference + ":" + propertyName);
+          elementReference.set(
+            value,
+            _writtenObjects + ":" + _existingReference
+          );
         }
         if (isArrayImpl(value)) return renderFragment(request, task, value);
         if (value instanceof Map) return serializeMap(request, value);
@@ -1377,9 +1391,9 @@
           return serializeTypedArray(request, "V", value);
         if ("function" === typeof Blob && value instanceof Blob)
           return serializeBlob(request, value);
-        if ((_writtenObjects = getIteratorFn(value)))
+        if ((elementReference = getIteratorFn(value)))
           return (
-            (parentPropertyName = _writtenObjects.call(value)),
+            (parentPropertyName = elementReference.call(value)),
             parentPropertyName === value
               ? "$i" +
                 outlineModel(request, Array.from(parentPropertyName)).toString(
@@ -1392,8 +1406,8 @@
           value instanceof ReadableStream
         )
           return serializeReadableStream(request, task, value);
-        _writtenObjects = value[ASYNC_ITERATOR];
-        if ("function" === typeof _writtenObjects)
+        elementReference = value[ASYNC_ITERATOR];
+        if ("function" === typeof elementReference)
           return (
             null !== task.keyPath
               ? ((value = [
@@ -1404,7 +1418,7 @@
                   null
                 ]),
                 (value = task.implicitSlot ? [value] : value))
-              : ((parentPropertyName = _writtenObjects.call(value)),
+              : ((parentPropertyName = elementReference.call(value)),
                 (value = serializeAsyncIterable(
                   request,
                   task,
@@ -1421,6 +1435,16 @@
           throw Error(
             "Only plain objects, and a few built-ins, can be passed to Client Components from Server Components. Classes or null prototypes are not supported."
           );
+        if (
+          "object" === typeof value.task &&
+          null !== value.task &&
+          "function" === typeof value.task.run &&
+          "string" === typeof value.name &&
+          "string" === typeof value.env &&
+          void 0 !== value.owner &&
+          "undefined" === typeof value.stack
+        )
+          return { name: value.name, env: value.env, owner: value.owner };
         if ("Object" !== objectName(value))
           error$jscomp$0(
             "Only plain objects can be passed to Client Components from Server Components. %s objects are not supported.%s",
@@ -1432,14 +1456,14 @@
             request = Object.getOwnPropertyNames(value);
             for (task = 0; task < request.length; task++)
               if (
-                ((_writtenObjects = Object.getOwnPropertyDescriptor(
+                ((elementReference = Object.getOwnPropertyDescriptor(
                   value,
                   request[task]
                 )),
-                !_writtenObjects ||
-                  (!_writtenObjects.enumerable &&
+                !elementReference ||
+                  (!elementReference.enumerable &&
                     (("key" !== request[task] && "ref" !== request[task]) ||
-                      "function" !== typeof _writtenObjects.get)))
+                      "function" !== typeof elementReference.get)))
               ) {
                 request = !1;
                 break a;
@@ -1536,11 +1560,11 @@
       }
       if ("symbol" === typeof value) {
         task = request.writtenSymbols;
-        _writtenObjects = task.get(value);
-        if (void 0 !== _writtenObjects)
-          return serializeByValueID(_writtenObjects);
-        _writtenObjects = value.description;
-        if (Symbol.for(_writtenObjects) !== value)
+        elementReference = task.get(value);
+        if (void 0 !== elementReference)
+          return serializeByValueID(elementReference);
+        elementReference = value.description;
+        if (Symbol.for(elementReference) !== value)
           throw Error(
             "Only global symbols received from Symbol.for(...) can be passed to Client Components. The symbol Symbol.for(" +
               (value.description + ") cannot be found among global symbols.") +
@@ -1551,7 +1575,7 @@
         parent = encodeReferenceChunk(
           request,
           parentPropertyName,
-          "$S" + _writtenObjects
+          "$S" + elementReference
         );
         request.completedImportChunks.push(parent);
         task.set(value, parentPropertyName);
@@ -1800,7 +1824,10 @@
     }
     function forwardDebugInfo(request, id, debugInfo) {
       for (var i = 0; i < debugInfo.length; i++)
-        request.pendingChunks++, emitDebugChunk(request, id, debugInfo[i]);
+        request.pendingChunks++,
+          "string" === typeof debugInfo[i].name &&
+            outlineModel(request, debugInfo[i]),
+          emitDebugChunk(request, id, debugInfo[i]);
     }
     function emitChunk(request, task, value) {
       var id = task.id;
@@ -1853,14 +1880,20 @@
           modelRoot = resolvedModel;
           task.keyPath = null;
           task.implicitSlot = !1;
-          if ("object" === typeof resolvedModel && null !== resolvedModel)
+          if ("object" === typeof resolvedModel && null !== resolvedModel) {
             request.writtenObjects.set(
               resolvedModel,
               serializeByValueID(task.id)
-            ),
-              emitChunk(request, task, resolvedModel);
-          else {
-            var json = stringify(resolvedModel);
+            );
+            var currentEnv = request.environmentName();
+            currentEnv !== task.environmentName &&
+              emitDebugChunk(request, task.id, { env: currentEnv });
+            emitChunk(request, task, resolvedModel);
+          } else {
+            var json = stringify(resolvedModel),
+              _currentEnv = request.environmentName();
+            _currentEnv !== task.environmentName &&
+              emitDebugChunk(request, task.id, { env: _currentEnv });
             emitModelChunk(request, task.id, json);
           }
           request.abortableTasks.delete(task);