react-server-dom-webpack 19.0.0-canary-33a32441e9-20240418 → 19.0.0-canary-cb151849e1-20240424

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

@@ -20,6 +20,21 @@ require('crypto');
 var async_hooks = require('async_hooks');
 var ReactDOM = require('react-dom');
 
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
 var ReactSharedInternalsServer = // $FlowFixMe: It's defined in the one we resolve to.
 React.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
 
@@ -890,11 +905,7 @@ function createTemporaryReference(id) {
   return new Proxy(reference, proxyHandlers);
 }
 
-// ATTENTION
-// When adding new symbols to this file,
-// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
-// The Symbol used to tag the ReactElement-like types.
-var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+var REACT_ELEMENT_TYPE = Symbol.for('react.transitional.element') ;
 var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
 var REACT_CONTEXT_TYPE = Symbol.for('react.context');
 var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
@@ -1818,18 +1829,56 @@ function renderFunctionComponent(request, task, key, Component, props, owner) {
     }
   }
 
-  if (typeof result === 'object' && result !== null && typeof result.then === 'function') {
-    // When the return value is in children position we can resolve it immediately,
-    // to its value without a wrapper if it's synchronously available.
-    var thenable = result;
+  if (typeof result === 'object' && result !== null) {
+    if (typeof result.then === 'function') {
+      // When the return value is in children position we can resolve it immediately,
+      // to its value without a wrapper if it's synchronously available.
+      var thenable = result;
+
+      if (thenable.status === 'fulfilled') {
+        return thenable.value;
+      } // TODO: Once we accept Promises as children on the client, we can just return
+      // the thenable here.
+
 
-    if (thenable.status === 'fulfilled') {
-      return thenable.value;
-    } // TODO: Once we accept Promises as children on the client, we can just return
-    // the thenable here.
+      result = createLazyWrapperAroundWakeable(result);
+    } // Normally we'd serialize an Iterator/AsyncIterator as a single-shot which is not compatible
+    // to be rendered as a React Child. However, because we have the function to recreate
+    // an iterable from rendering the element again, we can effectively treat it as multi-
+    // shot. Therefore we treat this as an Iterable/AsyncIterable, whether it was one or not, by
+    // adding a wrapper so that this component effectively renders down to an AsyncIterable.
 
 
-    result = createLazyWrapperAroundWakeable(result);
+    var iteratorFn = getIteratorFn(result);
+
+    if (iteratorFn) {
+      var iterableChild = result;
+      result = _defineProperty({}, Symbol.iterator, function () {
+        var iterator = iteratorFn.call(iterableChild);
+
+        {
+          // If this was an Iterator but not a GeneratorFunction we warn because
+          // it might have been a mistake. Technically you can make this mistake with
+          // GeneratorFunctions and even single-shot Iterables too but it's extra
+          // tempting to try to return the value from a generator.
+          if (iterator === iterableChild) {
+            var isGeneratorComponent = // $FlowIgnore[method-unbinding]
+            Object.prototype.toString.call(Component) === '[object GeneratorFunction]' && // $FlowIgnore[method-unbinding]
+            Object.prototype.toString.call(iterableChild) === '[object Generator]';
+
+            if (!isGeneratorComponent) {
+              error('Returning an Iterator from a Server Component is not supported ' + 'since it cannot be looped over more than once. ');
+            }
+          }
+        }
+
+        return iterator;
+      });
+
+      {
+        result._debugInfo = iterableChild._debugInfo;
+      }
+    }
   } // Track this element's key on the Server Component on the keyPath context..
 
 
@@ -2301,6 +2350,11 @@ function serializeSet(request, set) {
   return '$W' + id.toString(16);
 }
 
+function serializeIterator(request, iterator) {
+  var id = outlineModel(request, Array.from(iterator));
+  return '$i' + id.toString(16);
+}
+
 function escapeStringValue(value) {
   if (value[0] === '$') {
     // We need to escape $ prefixed strings since we use those to encode
@@ -2565,7 +2619,15 @@ function renderModelDestructive(request, task, parent, parentPropertyName, value
     var iteratorFn = getIteratorFn(value);
 
     if (iteratorFn) {
-      return renderFragment(request, task, Array.from(value));
+      // TODO: Should we serialize the return value as well like we do for AsyncIterables?
+      var iterator = iteratorFn.call(value);
+
+      if (iterator === value) {
+        // Iterator, not Iterable
+        return serializeIterator(request, iterator);
+      }
+
+      return renderFragment(request, task, Array.from(iterator));
     }
 
 
@@ -3821,6 +3883,16 @@ function parseModelString(response, obj, key, value) {
           return _data2;
         }
 
+      case 'i':
+        {
+          // Iterator
+          var _id5 = parseInt(value.slice(2), 16);
+
+          var _data3 = getOutlinedModel(response, _id5);
+
+          return _data3[Symbol.iterator]();
+        }
+
       case 'I':
         {
           // $Infinity