@matthamlin/react-client 0.0.0-experimental-31d91651-20250625 → 0.0.0-experimental-1e0d12b6-20250630

package/cjs/react-client-flight.production.js

@@ -585,17 +585,64 @@ module.exports = function ($$$config) {
     return new ReactPromise("rejected", null, error);
   }
   function wakeChunk(listeners, value) {
-    for (var i = 0; i < listeners.length; i++) (0, listeners[i])(value);
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      "function" === typeof listener
+        ? listener(value)
+        : fulfillReference(listener, value);
+    }
+  }
+  function rejectChunk(listeners, error) {
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      "function" === typeof listener
+        ? listener(error)
+        : rejectReference(listener, error);
+    }
+  }
+  function resolveBlockedCycle(resolvedChunk, reference) {
+    var referencedChunk = reference.handler.chunk;
+    if (null === referencedChunk) return null;
+    if (referencedChunk === resolvedChunk) return reference.handler;
+    reference = referencedChunk.value;
+    if (null !== reference)
+      for (
+        referencedChunk = 0;
+        referencedChunk < reference.length;
+        referencedChunk++
+      ) {
+        var listener = reference[referencedChunk];
+        if (
+          "function" !== typeof listener &&
+          ((listener = resolveBlockedCycle(resolvedChunk, listener)),
+          null !== listener)
+        )
+          return listener;
+      }
+    return null;
   }
   function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
     switch (chunk.status) {
       case "fulfilled":
         wakeChunk(resolveListeners, chunk.value);
         break;
-      case "pending":
       case "blocked":
+        for (var i = 0; i < resolveListeners.length; i++) {
+          var listener = resolveListeners[i];
+          if ("function" !== typeof listener) {
+            var cyclicHandler = resolveBlockedCycle(chunk, listener);
+            null !== cyclicHandler &&
+              (fulfillReference(listener, cyclicHandler.value),
+              resolveListeners.splice(i, 1),
+              i--,
+              null !== rejectListeners &&
+                ((listener = rejectListeners.indexOf(listener)),
+                -1 !== listener && rejectListeners.splice(listener, 1)));
+          }
+        }
+      case "pending":
         if (chunk.value)
-          for (var i = 0; i < resolveListeners.length; i++)
+          for (i = 0; i < resolveListeners.length; i++)
             chunk.value.push(resolveListeners[i]);
         else chunk.value = resolveListeners;
         if (chunk.reason) {
@@ -609,7 +656,7 @@ module.exports = function ($$$config) {
         } else chunk.reason = rejectListeners;
         break;
       case "rejected":
-        rejectListeners && wakeChunk(rejectListeners, chunk.reason);
+        rejectListeners && rejectChunk(rejectListeners, chunk.reason);
     }
   }
   function triggerErrorOnChunk(chunk, error) {
@@ -619,7 +666,7 @@ module.exports = function ($$$config) {
       var listeners = chunk.reason;
       chunk.status = "rejected";
       chunk.reason = error;
-      null !== listeners && wakeChunk(listeners, error);
+      null !== listeners && rejectChunk(listeners, error);
     }
   }
   function createResolvedIteratorResultChunk(response, value, done) {
@@ -720,6 +767,90 @@ module.exports = function ($$$config) {
       chunks.set(id, chunk));
     return chunk;
   }
+  function fulfillReference(reference, value) {
+    for (
+      var response = reference.response,
+        handler = reference.handler,
+        parentObject = reference.parentObject,
+        key = reference.key,
+        map = reference.map,
+        path = reference.path,
+        i = 1;
+      i < path.length;
+      i++
+    ) {
+      for (; value.$$typeof === REACT_LAZY_TYPE; )
+        if (((value = value._payload), value === handler.chunk))
+          value = handler.value;
+        else {
+          switch (value.status) {
+            case "resolved_model":
+              initializeModelChunk(value);
+              break;
+            case "resolved_module":
+              initializeModuleChunk(value);
+          }
+          switch (value.status) {
+            case "fulfilled":
+              value = value.value;
+              continue;
+            case "blocked":
+              var cyclicHandler = resolveBlockedCycle(value, reference);
+              if (null !== cyclicHandler) {
+                value = cyclicHandler.value;
+                continue;
+              }
+            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;
+            case "halted":
+              return;
+            default:
+              rejectReference(reference, value.reason);
+              return;
+          }
+        }
+      value = value[path[i]];
+    }
+    reference = map(response, value, parentObject, key);
+    parentObject[key] = reference;
+    "" === key && null === handler.value && (handler.value = reference);
+    if (
+      parentObject[0] === REACT_ELEMENT_TYPE &&
+      "object" === typeof handler.value &&
+      null !== handler.value &&
+      handler.value.$$typeof === REACT_ELEMENT_TYPE
+    )
+      switch (((parentObject = handler.value), key)) {
+        case "3":
+          parentObject.props = reference;
+      }
+    handler.deps--;
+    0 === handler.deps &&
+      ((key = handler.chunk),
+      null !== key &&
+        "blocked" === key.status &&
+        ((parentObject = key.value),
+        (key.status = "fulfilled"),
+        (key.value = handler.value),
+        null !== parentObject && wakeChunk(parentObject, handler.value)));
+  }
+  function rejectReference(reference, error) {
+    reference = reference.handler;
+    reference.errored ||
+      ((reference.errored = !0),
+      (reference.value = error),
+      (reference = reference.chunk),
+      null !== reference &&
+        "blocked" === reference.status &&
+        triggerErrorOnChunk(reference, error));
+  }
   function waitForReference(
     referencedChunk,
     parentObject,
@@ -728,52 +859,6 @@ module.exports = function ($$$config) {
     map,
     path
   ) {
-    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]];
-      }
-      i = map(response, value, parentObject, key);
-      parentObject[key] = i;
-      "" === key && null === handler.value && (handler.value = i);
-      if (
-        parentObject[0] === REACT_ELEMENT_TYPE &&
-        "object" === typeof handler.value &&
-        null !== handler.value &&
-        handler.value.$$typeof === REACT_ELEMENT_TYPE
-      )
-        switch (((value = handler.value), key)) {
-          case "3":
-            value.props = i;
-        }
-      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++;
@@ -785,7 +870,20 @@ module.exports = function ($$$config) {
         deps: 1,
         errored: !1
       };
-    referencedChunk.then(fulfill, reject);
+    parentObject = {
+      response: response,
+      handler: handler,
+      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 loadServerReference(response, metaData, parentObject, key) {
@@ -889,24 +987,63 @@ module.exports = function ($$$config) {
       case "fulfilled":
         var value = id.value;
         for (id = 1; id < reference.length; id++) {
-          for (; value.$$typeof === REACT_LAZY_TYPE; )
-            if (((value = value._payload), "fulfilled" === value.status))
-              value = value.value;
-            else
-              return waitForReference(
-                value,
-                parentObject,
-                key,
-                response,
-                map,
-                reference.slice(id - 1)
-              );
+          for (; value.$$typeof === REACT_LAZY_TYPE; ) {
+            value = value._payload;
+            switch (value.status) {
+              case "resolved_model":
+                initializeModelChunk(value);
+                break;
+              case "resolved_module":
+                initializeModuleChunk(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)
+                );
+              case "halted":
+                return (
+                  initializingHandler
+                    ? ((response = initializingHandler), response.deps++)
+                    : (initializingHandler = {
+                        parent: null,
+                        chunk: null,
+                        value: null,
+                        deps: 1,
+                        errored: !1
+                      }),
+                  null
+                );
+              default:
+                return (
+                  initializingHandler
+                    ? ((initializingHandler.errored = !0),
+                      (initializingHandler.value = value.reason))
+                    : (initializingHandler = {
+                        parent: null,
+                        chunk: null,
+                        value: value.reason,
+                        deps: 0,
+                        errored: !0
+                      }),
+                  null
+                );
+            }
+          }
           value = value[reference[id]];
         }
         return map(response, value, parentObject, key);
       case "pending":
       case "blocked":
-      case "halted":
         return waitForReference(
           id,
           parentObject,
@@ -915,6 +1052,19 @@ module.exports = function ($$$config) {
           map,
           reference
         );
+      case "halted":
+        return (
+          initializingHandler
+            ? ((response = initializingHandler), response.deps++)
+            : (initializingHandler = {
+                parent: null,
+                chunk: null,
+                value: null,
+                deps: 1,
+                errored: !1
+              }),
+          null
+        );
       default:
         return (
           initializingHandler
@@ -1171,8 +1321,8 @@ module.exports = function ($$$config) {
               (previousBlockedChunk = chunk));
         } else {
           chunk = previousBlockedChunk;
-          var chunk$30 = new ReactPromise("pending", null, null);
-          chunk$30.then(
+          var chunk$31 = new ReactPromise("pending", null, null);
+          chunk$31.then(
             function (v) {
               return controller.enqueue(v);
             },
@@ -1180,10 +1330,10 @@ module.exports = function ($$$config) {
               return controller.error(e);
             }
           );
-          previousBlockedChunk = chunk$30;
+          previousBlockedChunk = chunk$31;
           chunk.then(function () {
-            previousBlockedChunk === chunk$30 && (previousBlockedChunk = null);
-            resolveModelChunk(response, chunk$30, json);
+            previousBlockedChunk === chunk$31 && (previousBlockedChunk = null);
+            resolveModelChunk(response, chunk$31, json);
           });
         }
       },
@@ -1324,8 +1474,8 @@ module.exports = function ($$$config) {
     )
       byteLength += buffer[i].byteLength;
     byteLength = new Uint8Array(byteLength);
-    for (var i$31 = (i = 0); i$31 < l; i$31++) {
-      var chunk = buffer[i$31];
+    for (var i$32 = (i = 0); i$32 < l; i$32++) {
+      var chunk = buffer[i$32];
       byteLength.set(chunk, i);
       i += chunk.byteLength;
     }
@@ -1552,20 +1702,20 @@ module.exports = function ($$$config) {
     }
     switch (this.status) {
       case "fulfilled":
-        resolve(this.value);
+        "function" === typeof resolve && resolve(this.value);
         break;
       case "pending":
       case "blocked":
-        resolve &&
+        "function" === typeof resolve &&
           (null === this.value && (this.value = []), this.value.push(resolve));
-        reject &&
+        "function" === typeof reject &&
           (null === this.reason && (this.reason = []),
           this.reason.push(reject));
         break;
       case "halted":
         break;
       default:
-        reject && reject(this.reason);
+        "function" === typeof reject && reject(this.reason);
     }
   };
   var initializingHandler = null;
@@ -1600,7 +1750,7 @@ module.exports = function ($$$config) {
       version: rendererVersion,
       rendererPackageName: rendererPackageName,
       currentDispatcherRef: ReactSharedInternals,
-      reconcilerVersion: "19.2.0-experimental-31d91651-20250625",
+      reconcilerVersion: "19.2.0-experimental-1e0d12b6-20250630",
       getCurrentComponentInfo: getCurrentOwnerInDEV
     };
     if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@matthamlin/react-client",
   "description": "React package for consuming streaming models.",
-  "version": "0.0.0-experimental-31d91651-20250625",
+  "version": "0.0.0-experimental-1e0d12b6-20250630",
   "keywords": [
     "react"
   ],
@@ -23,6 +23,6 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "0.0.0-experimental-31d91651-20250625"
+    "react": "0.0.0-experimental-1e0d12b6-20250630"
   }
 }