@vitejs/plugin-rsc 0.5.5 → 0.5.7

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

@@ -2101,7 +2101,7 @@
     function serializeServerReference(request, serverReference) {
       var writtenServerReferences = request.writtenServerReferences,
         existingId = writtenServerReferences.get(serverReference);
-      if (void 0 !== existingId) return "$F" + existingId.toString(16);
+      if (void 0 !== existingId) return "$h" + existingId.toString(16);
       existingId = serverReference.$$bound;
       existingId = null === existingId ? null : Promise.resolve(existingId);
       var id = serverReference.$$id,
@@ -2127,7 +2127,7 @@
           : { id: id, bound: existingId };
       request = outlineModel(request, existingId);
       writtenServerReferences.set(serverReference, request);
-      return "$F" + request.toString(16);
+      return "$h" + request.toString(16);
     }
     function serializeLargeTextString(request, text) {
       request.pendingChunks++;
@@ -4012,7 +4012,7 @@
     }
     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);
@@ -4057,6 +4057,7 @@
               ((promiseValue = resolvedValue.value),
               (resolvedValue.status = "fulfilled"),
               (resolvedValue.value = handler.value),
+              (resolvedValue.reason = null),
               null !== promiseValue &&
                 wakeChunk(response, promiseValue, handler.value)));
         },
@@ -4160,6 +4161,7 @@
         }
         chunk.status = "fulfilled";
         chunk.value = value;
+        chunk.reason = null;
       } catch (error) {
         (chunk.status = "rejected"), (chunk.reason = error);
       } finally {
@@ -4170,8 +4172,11 @@
       response._closed = !0;
       response._closedReason = 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) {
@@ -4193,58 +4198,39 @@
       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 ||
@@ -4256,33 +4242,6 @@
           "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);
@@ -4293,59 +4252,45 @@
       }
       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 (
@@ -4373,8 +4318,8 @@
     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,
@@ -4385,9 +4330,10 @@
       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++;
@@ -4416,6 +4362,7 @@
             var resolveListeners = buffer.value;
             buffer.status = "fulfilled";
             buffer.value = handler.value;
+            buffer.reason = null;
             null !== resolveListeners &&
               wakeChunk(response, resolveListeners, handler.value);
           }
@@ -4450,7 +4397,10 @@
     }
     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) {
@@ -4497,24 +4447,28 @@
           }
         },
         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;
@@ -4529,6 +4483,8 @@
     }
     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,
@@ -4569,36 +4525,46 @@
           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;
@@ -4612,7 +4578,7 @@
             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)
@@ -4886,6 +4852,13 @@
       SERVER_REFERENCE_TAG = Symbol.for("react.server.reference"),
       FunctionBind = Function.prototype.bind,
       ArraySlice = Array.prototype.slice,
+      serverReferenceToString = {
+        value: function () {
+          return "function () { [omitted code] }";
+        },
+        configurable: !0,
+        writable: !0
+      },
       PROMISE_PROTOTYPE = Promise.prototype,
       deepProxyHandlers = {
         get: function (target, name) {
@@ -5303,7 +5276,24 @@
       }
       switch (this.status) {
         case "fulfilled":
-          "function" === typeof resolve && resolve(this.value);
+          if ("function" === typeof resolve) {
+            for (
+              var inspectedValue = this.value, cycleProtection = 0;
+              inspectedValue instanceof ReactPromise;
+
+            ) {
+              cycleProtection++;
+              if (inspectedValue === this || 1e3 < cycleProtection) {
+                "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":
@@ -5447,7 +5437,8 @@
         },
         $$bound: { value: null, configurable: !0 },
         $$location: { value: Error("react-stack-top-frame"), configurable: !0 },
-        bind: { value: bind, configurable: !0 }
+        bind: { value: bind, configurable: !0 },
+        toString: serverReferenceToString
       });
     };
     exports.renderToReadableStream = function (model, webpackMap, options) {