react-server-dom-webpack 19.0.1 → 19.0.2

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

@@ -117,7 +117,14 @@ function bind() {
   }
   return newFn;
 }
-var PROMISE_PROTOTYPE = Promise.prototype,
+var serverReferenceToString = {
+    value: function () {
+      return "function () { [omitted code] }";
+    },
+    configurable: !0,
+    writable: !0
+  },
+  PROMISE_PROTOTYPE = Promise.prototype,
   deepProxyHandlers = {
     get: function (target, name) {
       switch (name) {
@@ -1590,7 +1597,7 @@ function renderModelDestructive(
         (task = request.writtenServerReferences),
         (parentPropertyName = task.get(value)),
         void 0 !== parentPropertyName
-          ? (request = "$F" + parentPropertyName.toString(16))
+          ? (request = "$h" + parentPropertyName.toString(16))
           : ((parentPropertyName = value.$$bound),
             (parentPropertyName =
               null === parentPropertyName
@@ -1601,7 +1608,7 @@ function renderModelDestructive(
               bound: parentPropertyName
             })),
             task.set(value, request),
-            (request = "$F" + request.toString(16))),
+            (request = "$h" + request.toString(16))),
         request
       );
     if (
@@ -2022,7 +2029,23 @@ ReactPromise.prototype.then = function (resolve, reject) {
   }
   switch (this.status) {
     case "fulfilled":
-      "function" === typeof resolve && resolve(this.value);
+      if ("function" === typeof resolve) {
+        for (
+          var inspectedValue = this.value;
+          inspectedValue instanceof ReactPromise;
+
+        ) {
+          if (inspectedValue === this) {
+            "function" === typeof reject &&
+              reject(Error("Cannot have cyclic thenables."));
+            return;
+          }
+          if ("fulfilled" === inspectedValue.status)
+            inspectedValue = inspectedValue.value;
+          else break;
+        }
+        resolve(this.value);
+      }
       break;
     case "pending":
     case "blocked":
@@ -2174,7 +2197,7 @@ function resolveIteratorResultChunk(response, chunk, value, done) {
 }
 function loadServerReference$1(response, metaData, parentObject, key) {
   var id = metaData.id;
-  if ("string" !== typeof id) return null;
+  if ("string" !== typeof id || "then" === key) return null;
   var serverReference = resolveServerReference(response._bundlerConfig, id);
   id = metaData.bound;
   var promise = preloadModule(serverReference);
@@ -2212,6 +2235,7 @@ function loadServerReference$1(response, metaData, parentObject, key) {
           ((promiseValue = resolvedValue.value),
           (resolvedValue.status = "fulfilled"),
           (resolvedValue.value = handler.value),
+          (resolvedValue.reason = null),
           null !== promiseValue &&
             wakeChunk(response, promiseValue, handler.value)));
     },
@@ -2303,6 +2327,7 @@ function initializeModelChunk(chunk) {
     }
     chunk.status = "fulfilled";
     chunk.value = value;
+    chunk.reason = null;
   } catch (error) {
     (chunk.status = "rejected"), (chunk.reason = error);
   } finally {
@@ -2311,7 +2336,11 @@ function initializeModelChunk(chunk) {
 }
 function reportGlobalError(response, error) {
   response._chunks.forEach(function (chunk) {
-    "pending" === chunk.status && triggerErrorOnChunk(response, chunk, error);
+    "pending" === chunk.status
+      ? triggerErrorOnChunk(response, chunk, error)
+      : "fulfilled" === chunk.status &&
+        null !== chunk.reason &&
+        chunk.reason.error(error);
   });
 }
 function getChunk(response, id) {
@@ -2327,58 +2356,39 @@ function getChunk(response, id) {
   return chunk;
 }
 function fulfillReference(response, reference, value) {
-  for (
-    var handler = reference.handler,
-      parentObject = reference.parentObject,
-      key = reference.key,
-      map = reference.map,
-      path = reference.path,
-      i = 1;
-    i < path.length;
-    i++
-  ) {
-    for (; value instanceof ReactPromise; ) {
-      switch (value.status) {
-        case "resolved_model":
-          initializeModelChunk(value);
-      }
-      switch (value.status) {
-        case "fulfilled":
-          value = value.value;
-          continue;
-        case "blocked":
-        case "pending":
-          path.splice(0, i - 1);
-          null === value.value
-            ? (value.value = [reference])
-            : value.value.push(reference);
-          null === value.reason
-            ? (value.reason = [reference])
-            : value.reason.push(reference);
-          return;
-        default:
-          rejectReference(response, reference.handler, value.reason);
-          return;
-      }
+  var handler = reference.handler,
+    parentObject = reference.parentObject,
+    key = reference.key,
+    map = reference.map,
+    path = reference.path;
+  try {
+    for (var i = 1; i < path.length; i++) {
+      var name = path[i];
+      if (
+        "object" !== typeof value ||
+        !hasOwnProperty.call(value, name) ||
+        value instanceof Promise
+      )
+        throw Error("Invalid reference.");
+      value = value[name];
     }
-    var name = path[i];
-    "object" === typeof value &&
-      hasOwnProperty.call(value, name) &&
-      (value = value[name]);
+    var mappedValue = map(response, value, parentObject, key);
+    parentObject[key] = mappedValue;
+    "" === key && null === handler.value && (handler.value = mappedValue);
+  } catch (error) {
+    rejectReference(response, reference.handler, error);
+    return;
   }
-  reference = map(response, value, parentObject, key);
-  parentObject[key] = reference;
-  "" === key && null === handler.value && (handler.value = reference);
   handler.deps--;
   0 === handler.deps &&
-    ((parentObject = handler.chunk),
-    null !== parentObject &&
-      "blocked" === parentObject.status &&
-      ((key = parentObject.value),
-      (parentObject.status = "fulfilled"),
-      (parentObject.value = handler.value),
-      (parentObject.reason = handler.reason),
-      null !== key && wakeChunk(response, key, handler.value)));
+    ((reference = handler.chunk),
+    null !== reference &&
+      "blocked" === reference.status &&
+      ((value = reference.value),
+      (reference.status = "fulfilled"),
+      (reference.value = handler.value),
+      (reference.reason = handler.reason),
+      null !== value && wakeChunk(response, value, handler.value)));
 }
 function rejectReference(response, handler, error) {
   handler.errored ||
@@ -2390,33 +2400,6 @@ function rejectReference(response, handler, error) {
       "blocked" === handler.status &&
       triggerErrorOnChunk(response, handler, error));
 }
-function waitForReference(
-  referencedChunk,
-  parentObject,
-  key,
-  response,
-  map,
-  path
-) {
-  initializingHandler
-    ? ((response = initializingHandler), response.deps++)
-    : (response = initializingHandler =
-        { chunk: null, value: null, reason: null, deps: 1, errored: !1 });
-  parentObject = {
-    handler: response,
-    parentObject: parentObject,
-    key: key,
-    map: map,
-    path: path
-  };
-  null === referencedChunk.value
-    ? (referencedChunk.value = [parentObject])
-    : referencedChunk.value.push(parentObject);
-  null === referencedChunk.reason
-    ? (referencedChunk.reason = [parentObject])
-    : referencedChunk.reason.push(parentObject);
-  return null;
-}
 function getOutlinedModel(response, reference, parentObject, key, map) {
   reference = reference.split(":");
   var id = parseInt(reference[0], 16);
@@ -2427,53 +2410,40 @@ function getOutlinedModel(response, reference, parentObject, key, map) {
   }
   switch (id.status) {
     case "fulfilled":
-      var value = id.value;
-      for (id = 1; id < reference.length; id++) {
-        for (; value instanceof ReactPromise; ) {
-          switch (value.status) {
-            case "resolved_model":
-              initializeModelChunk(value);
-          }
-          switch (value.status) {
-            case "fulfilled":
-              value = value.value;
-              break;
-            case "blocked":
-            case "pending":
-              return waitForReference(
-                value,
-                parentObject,
-                key,
-                response,
-                map,
-                reference.slice(id - 1)
-              );
-            default:
-              return (
-                initializingHandler
-                  ? ((initializingHandler.errored = !0),
-                    (initializingHandler.value = null),
-                    (initializingHandler.reason = value.reason))
-                  : (initializingHandler = {
-                      chunk: null,
-                      value: null,
-                      reason: value.reason,
-                      deps: 0,
-                      errored: !0
-                    }),
-                null
-              );
-          }
-        }
-        var name = reference[id];
-        "object" === typeof value &&
-          hasOwnProperty.call(value, name) &&
-          (value = value[name]);
+      id = id.value;
+      for (var i = 1; i < reference.length; i++) {
+        var name = reference[i];
+        if (
+          "object" !== typeof id ||
+          !hasOwnProperty.call(id, name) ||
+          id instanceof Promise
+        )
+          throw Error("Invalid reference.");
+        id = id[name];
       }
-      return map(response, value, parentObject, key);
+      return map(response, id, parentObject, key);
     case "pending":
     case "blocked":
-      return waitForReference(id, parentObject, key, response, map, reference);
+      return (
+        initializingHandler
+          ? ((response = initializingHandler), response.deps++)
+          : (response = initializingHandler =
+              { chunk: null, value: null, reason: null, deps: 1, errored: !1 }),
+        (parentObject = {
+          handler: response,
+          parentObject: parentObject,
+          key: key,
+          map: map,
+          path: reference
+        }),
+        null === id.value
+          ? (id.value = [parentObject])
+          : id.value.push(parentObject),
+        null === id.reason
+          ? (id.reason = [parentObject])
+          : id.reason.push(parentObject),
+        null
+      );
     default:
       return (
         initializingHandler
@@ -2500,8 +2470,8 @@ function createSet(response, model) {
 function extractIterator(response, model) {
   return model[Symbol.iterator]();
 }
-function createModel(response, model) {
-  return model;
+function createModel(response, model, parentObject, key) {
+  return "then" === key && "function" === typeof model ? null : model;
 }
 function parseTypedArray(
   response,
@@ -2512,9 +2482,10 @@ function parseTypedArray(
   parentKey
 ) {
   reference = parseInt(reference.slice(2), 16);
-  reference = response._formData
-    .get(response._prefix + reference)
-    .arrayBuffer();
+  bytesPerElement = response._prefix + reference;
+  if (response._chunks.has(reference))
+    throw Error("Already initialized typed array.");
+  reference = response._formData.get(bytesPerElement).arrayBuffer();
   if (initializingHandler) {
     var handler = initializingHandler;
     handler.deps++;
@@ -2540,6 +2511,7 @@ function parseTypedArray(
         var resolveListeners = buffer.value;
         buffer.status = "fulfilled";
         buffer.value = handler.value;
+        buffer.reason = null;
         null !== resolveListeners &&
           wakeChunk(response, resolveListeners, handler.value);
       }
@@ -2572,7 +2544,10 @@ function resolveStream(response, id, stream, controller) {
 }
 function parseReadableStream(response, reference, type) {
   reference = parseInt(reference.slice(2), 16);
-  var controller = null;
+  if (response._chunks.has(reference))
+    throw Error("Already initialized stream.");
+  var controller = null,
+    closed = !1;
   type = new ReadableStream({
     type: type,
     start: function (c) {
@@ -2615,24 +2590,27 @@ function parseReadableStream(response, reference, type) {
       }
     },
     close: function () {
-      if (null === previousBlockedChunk) controller.close();
-      else {
-        var blockedChunk = previousBlockedChunk;
-        previousBlockedChunk = null;
-        blockedChunk.then(function () {
-          return controller.close();
-        });
-      }
+      if (!closed)
+        if (((closed = !0), null === previousBlockedChunk)) controller.close();
+        else {
+          var blockedChunk = previousBlockedChunk;
+          previousBlockedChunk = null;
+          blockedChunk.then(function () {
+            return controller.close();
+          });
+        }
     },
     error: function (error) {
-      if (null === previousBlockedChunk) controller.error(error);
-      else {
-        var blockedChunk = previousBlockedChunk;
-        previousBlockedChunk = null;
-        blockedChunk.then(function () {
-          return controller.error(error);
-        });
-      }
+      if (!closed)
+        if (((closed = !0), null === previousBlockedChunk))
+          controller.error(error);
+        else {
+          var blockedChunk = previousBlockedChunk;
+          previousBlockedChunk = null;
+          blockedChunk.then(function () {
+            return controller.error(error);
+          });
+        }
     }
   });
   return type;
@@ -2647,6 +2625,8 @@ function createIterator(next) {
 }
 function parseAsyncIterable(response, reference, iterator) {
   reference = parseInt(reference.slice(2), 16);
+  if (response._chunks.has(reference))
+    throw Error("Already initialized stream.");
   var buffer = [],
     closed = !1,
     nextWriteIndex = 0,
@@ -2690,36 +2670,46 @@ function parseAsyncIterable(response, reference, iterator) {
       nextWriteIndex++;
     },
     close: function (value) {
-      closed = !0;
-      nextWriteIndex === buffer.length
-        ? (buffer[nextWriteIndex] = createResolvedIteratorResultChunk(
-            response,
-            value,
-            !0
-          ))
-        : resolveIteratorResultChunk(
+      if (!closed)
+        for (
+          closed = !0,
+            nextWriteIndex === buffer.length
+              ? (buffer[nextWriteIndex] = createResolvedIteratorResultChunk(
+                  response,
+                  value,
+                  !0
+                ))
+              : resolveIteratorResultChunk(
+                  response,
+                  buffer[nextWriteIndex],
+                  value,
+                  !0
+                ),
+            nextWriteIndex++;
+          nextWriteIndex < buffer.length;
+
+        )
+          resolveIteratorResultChunk(
             response,
-            buffer[nextWriteIndex],
-            value,
+            buffer[nextWriteIndex++],
+            '"$undefined"',
             !0
           );
-      for (nextWriteIndex++; nextWriteIndex < buffer.length; )
-        resolveIteratorResultChunk(
-          response,
-          buffer[nextWriteIndex++],
-          '"$undefined"',
-          !0
-        );
     },
     error: function (error) {
-      closed = !0;
-      for (
-        nextWriteIndex === buffer.length &&
-        (buffer[nextWriteIndex] = new ReactPromise("pending", null, null));
-        nextWriteIndex < buffer.length;
+      if (!closed)
+        for (
+          closed = !0,
+            nextWriteIndex === buffer.length &&
+              (buffer[nextWriteIndex] = new ReactPromise(
+                "pending",
+                null,
+                null
+              ));
+          nextWriteIndex < buffer.length;
 
-      )
-        triggerErrorOnChunk(response, buffer[nextWriteIndex++], error);
+        )
+          triggerErrorOnChunk(response, buffer[nextWriteIndex++], error);
     }
   });
   return iterator;
@@ -2731,7 +2721,7 @@ function parseModelString(response, obj, key, value, reference) {
         return value.slice(1);
       case "@":
         return (obj = parseInt(value.slice(2), 16)), getChunk(response, obj);
-      case "F":
+      case "h":
         return (
           (value = value.slice(2)),
           getOutlinedModel(response, value, obj, key, loadServerReference$1)
@@ -2979,13 +2969,13 @@ exports.decodeReplyFromBusboy = function (busboyStream, webpackMap, options) {
       );
     else {
       pendingFiles++;
-      var JSCompiler_object_inline_chunks_223 = [];
+      var JSCompiler_object_inline_chunks_233 = [];
       value.on("data", function (chunk) {
-        JSCompiler_object_inline_chunks_223.push(chunk);
+        JSCompiler_object_inline_chunks_233.push(chunk);
       });
       value.on("end", function () {
         try {
-          var blob = new Blob(JSCompiler_object_inline_chunks_223, {
+          var blob = new Blob(JSCompiler_object_inline_chunks_233, {
             type: mimeType
           });
           response._formData.append(name, blob, filename);
@@ -3032,7 +3022,8 @@ exports.registerServerReference = function (reference, id, exportName) {
       configurable: !0
     },
     $$bound: { value: null, configurable: !0 },
-    bind: { value: bind, configurable: !0 }
+    bind: { value: bind, configurable: !0 },
+    toString: serverReferenceToString
   });
 };
 exports.renderToPipeableStream = function (model, webpackMap, options) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-server-dom-webpack",
   "description": "React Server Components bindings for DOM using Webpack. This is intended to be integrated into meta-frameworks. It is not intended to be imported directly.",
-  "version": "19.0.1",
+  "version": "19.0.2",
   "keywords": [
     "react"
   ],
@@ -99,8 +99,8 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "^19.0.1",
-    "react-dom": "^19.0.1",
+    "react": "^19.0.2",
+    "react-dom": "^19.0.2",
     "webpack": "^5.59.0"
   },
   "dependencies": {