react-server-dom-webpack 19.0.0-rc-a26e3f403e-20240611 → 19.0.0-rc-f3e09d6328-20240612

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

@@ -642,7 +642,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 &&
@@ -665,7 +664,6 @@ function readChunk(chunk) {
       return chunk.value;
     case "pending":
     case "blocked":
-    case "cyclic":
       throw chunk;
     default:
       throw chunk.reason;
@@ -684,7 +682,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]);
@@ -750,35 +747,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) {
@@ -808,46 +805,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() {
@@ -884,23 +906,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) {
@@ -926,7 +946,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);
@@ -934,7 +966,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 () {});
@@ -1120,8 +1152,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);
           },
@@ -1129,10 +1161,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);
         });
       }
     },
@@ -1260,8 +1292,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;
   }
@@ -1437,21 +1469,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() {