react-server-dom-webpack 18.3.0-next-a8875eab7-20230310 → 18.3.0-next-56a3c18e5-20230314

package/umd/react-server-dom-webpack-client.browser.development.js

@@ -48,7 +48,7 @@
     }
 
     return metadata;
-  } // The chunk cache contains all the chunks we've preloaded so far.
+  }
   // If they're still pending they're a thenable. This map also exists
   // in Webpack but unfortunately it's not exposed so we have to
   // replicate it in user space. null means that it has already loaded.
@@ -147,13 +147,35 @@
     return moduleExports[metadata.name];
   }
 
+  var knownServerReferences = new WeakMap();
+
   // 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_PROVIDER_TYPE = Symbol.for('react.provider');
+  var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+  var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+  var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+  var REACT_MEMO_TYPE = Symbol.for('react.memo');
   var REACT_LAZY_TYPE = Symbol.for('react.lazy');
   var REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for('react.default_value');
+  var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+  var FAUX_ITERATOR_SYMBOL = '@@iterator';
+  function getIteratorFn(maybeIterable) {
+    if (maybeIterable === null || typeof maybeIterable !== 'object') {
+      return null;
+    }
+
+    var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+    if (typeof maybeIterator === 'function') {
+      return maybeIterator;
+    }
+
+    return null;
+  }
 
   var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
@@ -560,6 +582,7 @@
       });
     };
 
+    knownServerReferences.set(proxy, metaData);
     return proxy;
   }
 
@@ -881,6 +904,555 @@
     return response;
   }
 
+  function error(format) {
+    {
+      {
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+
+        printWarning('error', format, args);
+      }
+    }
+  }
+
+  function printWarning(level, format, args) {
+    // When changing this logic, you might want to also
+    // update consoleWithStackDev.www.js as well.
+    {
+      var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+      var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+      if (stack !== '') {
+        format += '%s';
+        args = args.concat([stack]);
+      } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+      var argsWithFormat = args.map(function (item) {
+        return String(item);
+      }); // Careful: RN currently depends on this prefix
+
+      argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+      // breaks IE9: https://github.com/facebook/react/issues/13610
+      // eslint-disable-next-line react-internal/no-production-logging
+
+      Function.prototype.apply.call(console[level], console, argsWithFormat);
+    }
+  }
+
+  var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+  function isArray(a) {
+    return isArrayImpl(a);
+  }
+
+  // in case they error.
+
+  var jsxPropsParents = new WeakMap();
+  var jsxChildrenParents = new WeakMap();
+
+  function isObjectPrototype(object) {
+    if (!object) {
+      return false;
+    }
+
+    var ObjectPrototype = Object.prototype;
+
+    if (object === ObjectPrototype) {
+      return true;
+    } // It might be an object from a different Realm which is
+    // still just a plain simple object.
+
+
+    if (Object.getPrototypeOf(object)) {
+      return false;
+    }
+
+    var names = Object.getOwnPropertyNames(object);
+
+    for (var i = 0; i < names.length; i++) {
+      if (!(names[i] in ObjectPrototype)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  function isSimpleObject(object) {
+    if (!isObjectPrototype(Object.getPrototypeOf(object))) {
+      return false;
+    }
+
+    var names = Object.getOwnPropertyNames(object);
+
+    for (var i = 0; i < names.length; i++) {
+      var descriptor = Object.getOwnPropertyDescriptor(object, names[i]);
+
+      if (!descriptor) {
+        return false;
+      }
+
+      if (!descriptor.enumerable) {
+        if ((names[i] === 'key' || names[i] === 'ref') && typeof descriptor.get === 'function') {
+          // React adds key and ref getters to props objects to issue warnings.
+          // Those getters will not be transferred to the client, but that's ok,
+          // so we'll special case them.
+          continue;
+        }
+
+        return false;
+      }
+    }
+
+    return true;
+  }
+  function objectName(object) {
+    // $FlowFixMe[method-unbinding]
+    var name = Object.prototype.toString.call(object);
+    return name.replace(/^\[object (.*)\]$/, function (m, p0) {
+      return p0;
+    });
+  }
+
+  function describeKeyForErrorMessage(key) {
+    var encodedKey = JSON.stringify(key);
+    return '"' + key + '"' === encodedKey ? key : encodedKey;
+  }
+
+  function describeValueForErrorMessage(value) {
+    switch (typeof value) {
+      case 'string':
+        {
+          return JSON.stringify(value.length <= 10 ? value : value.substr(0, 10) + '...');
+        }
+
+      case 'object':
+        {
+          if (isArray(value)) {
+            return '[...]';
+          }
+
+          var name = objectName(value);
+
+          if (name === 'Object') {
+            return '{...}';
+          }
+
+          return name;
+        }
+
+      case 'function':
+        return 'function';
+
+      default:
+        // eslint-disable-next-line react-internal/safe-string-coercion
+        return String(value);
+    }
+  }
+
+  function describeElementType(type) {
+    if (typeof type === 'string') {
+      return type;
+    }
+
+    switch (type) {
+      case REACT_SUSPENSE_TYPE:
+        return 'Suspense';
+
+      case REACT_SUSPENSE_LIST_TYPE:
+        return 'SuspenseList';
+    }
+
+    if (typeof type === 'object') {
+      switch (type.$$typeof) {
+        case REACT_FORWARD_REF_TYPE:
+          return describeElementType(type.render);
+
+        case REACT_MEMO_TYPE:
+          return describeElementType(type.type);
+
+        case REACT_LAZY_TYPE:
+          {
+            var lazyComponent = type;
+            var payload = lazyComponent._payload;
+            var init = lazyComponent._init;
+
+            try {
+              // Lazy may contain any component type so we recursively resolve it.
+              return describeElementType(init(payload));
+            } catch (x) {}
+          }
+      }
+    }
+
+    return '';
+  }
+
+  function describeObjectForErrorMessage(objectOrArray, expandedName) {
+    var objKind = objectName(objectOrArray);
+
+    if (objKind !== 'Object' && objKind !== 'Array') {
+      return objKind;
+    }
+
+    var str = '';
+    var start = -1;
+    var length = 0;
+
+    if (isArray(objectOrArray)) {
+      if (jsxChildrenParents.has(objectOrArray)) {
+        // Print JSX Children
+        var type = jsxChildrenParents.get(objectOrArray);
+        str = '<' + describeElementType(type) + '>';
+        var array = objectOrArray;
+
+        for (var i = 0; i < array.length; i++) {
+          var value = array[i];
+          var substr = void 0;
+
+          if (typeof value === 'string') {
+            substr = value;
+          } else if (typeof value === 'object' && value !== null) {
+            // $FlowFixMe[incompatible-call] found when upgrading Flow
+            substr = '{' + describeObjectForErrorMessage(value) + '}';
+          } else {
+            substr = '{' + describeValueForErrorMessage(value) + '}';
+          }
+
+          if ('' + i === expandedName) {
+            start = str.length;
+            length = substr.length;
+            str += substr;
+          } else if (substr.length < 15 && str.length + substr.length < 40) {
+            str += substr;
+          } else {
+            str += '{...}';
+          }
+        }
+
+        str += '</' + describeElementType(type) + '>';
+      } else {
+        // Print Array
+        str = '[';
+        var _array = objectOrArray;
+
+        for (var _i = 0; _i < _array.length; _i++) {
+          if (_i > 0) {
+            str += ', ';
+          }
+
+          var _value = _array[_i];
+
+          var _substr = void 0;
+
+          if (typeof _value === 'object' && _value !== null) {
+            // $FlowFixMe[incompatible-call] found when upgrading Flow
+            _substr = describeObjectForErrorMessage(_value);
+          } else {
+            _substr = describeValueForErrorMessage(_value);
+          }
+
+          if ('' + _i === expandedName) {
+            start = str.length;
+            length = _substr.length;
+            str += _substr;
+          } else if (_substr.length < 10 && str.length + _substr.length < 40) {
+            str += _substr;
+          } else {
+            str += '...';
+          }
+        }
+
+        str += ']';
+      }
+    } else {
+      if (objectOrArray.$$typeof === REACT_ELEMENT_TYPE) {
+        str = '<' + describeElementType(objectOrArray.type) + '/>';
+      } else if (jsxPropsParents.has(objectOrArray)) {
+        // Print JSX
+        var _type = jsxPropsParents.get(objectOrArray);
+
+        str = '<' + (describeElementType(_type) || '...');
+        var object = objectOrArray;
+        var names = Object.keys(object);
+
+        for (var _i2 = 0; _i2 < names.length; _i2++) {
+          str += ' ';
+          var name = names[_i2];
+          str += describeKeyForErrorMessage(name) + '=';
+          var _value2 = object[name];
+
+          var _substr2 = void 0;
+
+          if (name === expandedName && typeof _value2 === 'object' && _value2 !== null) {
+            // $FlowFixMe[incompatible-call] found when upgrading Flow
+            _substr2 = describeObjectForErrorMessage(_value2);
+          } else {
+            _substr2 = describeValueForErrorMessage(_value2);
+          }
+
+          if (typeof _value2 !== 'string') {
+            _substr2 = '{' + _substr2 + '}';
+          }
+
+          if (name === expandedName) {
+            start = str.length;
+            length = _substr2.length;
+            str += _substr2;
+          } else if (_substr2.length < 10 && str.length + _substr2.length < 40) {
+            str += _substr2;
+          } else {
+            str += '...';
+          }
+        }
+
+        str += '>';
+      } else {
+        // Print Object
+        str = '{';
+        var _object = objectOrArray;
+
+        var _names = Object.keys(_object);
+
+        for (var _i3 = 0; _i3 < _names.length; _i3++) {
+          if (_i3 > 0) {
+            str += ', ';
+          }
+
+          var _name = _names[_i3];
+          str += describeKeyForErrorMessage(_name) + ': ';
+          var _value3 = _object[_name];
+
+          var _substr3 = void 0;
+
+          if (typeof _value3 === 'object' && _value3 !== null) {
+            // $FlowFixMe[incompatible-call] found when upgrading Flow
+            _substr3 = describeObjectForErrorMessage(_value3);
+          } else {
+            _substr3 = describeValueForErrorMessage(_value3);
+          }
+
+          if (_name === expandedName) {
+            start = str.length;
+            length = _substr3.length;
+            str += _substr3;
+          } else if (_substr3.length < 10 && str.length + _substr3.length < 40) {
+            str += _substr3;
+          } else {
+            str += '...';
+          }
+        }
+
+        str += '}';
+      }
+    }
+
+    if (expandedName === undefined) {
+      return str;
+    }
+
+    if (start > -1 && length > 0) {
+      var highlight = ' '.repeat(start) + '^'.repeat(length);
+      return '\n  ' + str + '\n  ' + highlight;
+    }
+
+    return '\n  ' + str;
+  }
+
+  // Thenable<ReactServerValue>
+  // function serializeByValueID(id: number): string {
+  //   return '$' + id.toString(16);
+  // }
+
+  function serializePromiseID(id) {
+    return '$@' + id.toString(16);
+  }
+
+  function serializeServerReferenceID(id) {
+    return '$F' + id.toString(16);
+  }
+
+  function serializeSymbolReference(name) {
+    return '$S' + name;
+  }
+
+  function serializeUndefined() {
+    return '$undefined';
+  }
+
+  function escapeStringValue(value) {
+    if (value[0] === '$') {
+      // We need to escape $ prefixed strings since we use those to encode
+      // references to IDs and as special symbol values.
+      return '$' + value;
+    } else {
+      return value;
+    }
+  }
+
+  function processReply(root, resolve, reject) {
+    var nextPartId = 1;
+    var pendingParts = 0;
+    var formData = null;
+
+    function resolveToJSON(key, value) {
+      var parent = this;
+
+      {
+        // $FlowFixMe
+        var originalValue = this[key];
+
+        if (typeof originalValue === 'object' && originalValue !== value) {
+          if (objectName(originalValue) !== 'Object') {
+            error('Only plain objects can be passed to Server Functions from the Client. ' + '%s objects are not supported.%s', objectName(originalValue), describeObjectForErrorMessage(parent, key));
+          } else {
+            error('Only plain objects can be passed to Server Functions from the Client. ' + 'Objects with toJSON methods are not supported. Convert it manually ' + 'to a simple value before passing it to props.%s', describeObjectForErrorMessage(parent, key));
+          }
+        }
+      }
+
+      if (value === null) {
+        return null;
+      }
+
+      if (typeof value === 'object') {
+        // $FlowFixMe[method-unbinding]
+        if (typeof value.then === 'function') {
+          // We assume that any object with a .then property is a "Thenable" type,
+          // or a Promise type. Either of which can be represented by a Promise.
+          if (formData === null) {
+            // Upgrade to use FormData to allow us to stream this value.
+            formData = new FormData();
+          }
+
+          pendingParts++;
+          var promiseId = nextPartId++;
+          var thenable = value;
+          thenable.then(function (partValue) {
+            var partJSON = JSON.stringify(partValue, resolveToJSON); // $FlowFixMe[incompatible-type] We know it's not null because we assigned it above.
+
+            var data = formData; // eslint-disable-next-line react-internal/safe-string-coercion
+
+            data.append('' + promiseId, partJSON);
+            pendingParts--;
+
+            if (pendingParts === 0) {
+              resolve(data);
+            }
+          }, function (reason) {
+            // In the future we could consider serializing this as an error
+            // that throws on the server instead.
+            reject(reason);
+          });
+          return serializePromiseID(promiseId);
+        }
+
+        if (!isArray(value)) {
+          var iteratorFn = getIteratorFn(value);
+
+          if (iteratorFn) {
+            return Array.from(value);
+          }
+        }
+
+        {
+          if (value !== null && !isArray(value)) {
+            // Verify that this is a simple plain object.
+            if (value.$$typeof === REACT_ELEMENT_TYPE) {
+              error('React Element cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
+            } else if (value.$$typeof === REACT_LAZY_TYPE) {
+              error('React Lazy cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
+            } else if (value.$$typeof === REACT_PROVIDER_TYPE) {
+              error('React Context Providers cannot be passed to Server Functions from the Client.%s', describeObjectForErrorMessage(parent, key));
+            } else if (objectName(value) !== 'Object') {
+              error('Only plain objects can be passed to Client Components from Server Components. ' + '%s objects are not supported.%s', objectName(value), describeObjectForErrorMessage(parent, key));
+            } else if (!isSimpleObject(value)) {
+              error('Only plain objects can be passed to Client Components from Server Components. ' + 'Classes or other objects with methods are not supported.%s', describeObjectForErrorMessage(parent, key));
+            } else if (Object.getOwnPropertySymbols) {
+              var symbols = Object.getOwnPropertySymbols(value);
+
+              if (symbols.length > 0) {
+                error('Only plain objects can be passed to Client Components from Server Components. ' + 'Objects with symbol properties like %s are not supported.%s', symbols[0].description, describeObjectForErrorMessage(parent, key));
+              }
+            }
+          }
+        } // $FlowFixMe
+
+
+        return value;
+      }
+
+      if (typeof value === 'string') {
+        return escapeStringValue(value);
+      }
+
+      if (typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+      }
+
+      if (typeof value === 'undefined') {
+        return serializeUndefined();
+      }
+
+      if (typeof value === 'function') {
+        var metaData = knownServerReferences.get(value);
+
+        if (metaData !== undefined) {
+          var metaDataJSON = JSON.stringify(metaData, resolveToJSON);
+
+          if (formData === null) {
+            // Upgrade to use FormData to allow us to stream this value.
+            formData = new FormData();
+          } // The reference to this function came from the same client so we can pass it back.
+
+
+          var refId = nextPartId++; // eslint-disable-next-line react-internal/safe-string-coercion
+
+          formData.set('' + refId, metaDataJSON);
+          return serializeServerReferenceID(refId);
+        }
+
+        throw new Error('Client Functions cannot be passed directly to Server Functions. ' + 'Only Functions passed from the Server can be passed back again.');
+      }
+
+      if (typeof value === 'symbol') {
+        // $FlowFixMe `description` might be undefined
+        var name = value.description;
+
+        if (Symbol.for(name) !== value) {
+          throw new Error('Only global symbols received from Symbol.for(...) can be passed to Server Functions. ' + ("The symbol Symbol.for(" + // $FlowFixMe `description` might be undefined
+          value.description + ") cannot be found among global symbols."));
+        }
+
+        return serializeSymbolReference(name);
+      }
+
+      if (typeof value === 'bigint') {
+        throw new Error("BigInt (" + value + ") is not yet supported as an argument to a Server Function.");
+      }
+
+      throw new Error("Type " + typeof value + " is not supported as an argument to a Server Function.");
+    } // $FlowFixMe[incompatible-type] it's not going to be undefined because we'll encode it.
+
+
+    var json = JSON.stringify(root, resolveToJSON);
+
+    if (formData === null) {
+      // If it's a simple data structure, we just use plain JSON.
+      resolve(json);
+    } else {
+      // Otherwise, we use FormData to let us stream in the result.
+      formData.set('0', json);
+
+      if (pendingParts === 0) {
+        // $FlowFixMe[incompatible-call] this has already been refined.
+        resolve(formData);
+      }
+    }
+  }
+
   function createResponseFromOptions(options) {
     return createResponse(null, options && options.callServer ? options.callServer : undefined);
   }
@@ -952,8 +1524,17 @@
     return getRoot(response);
   }
 
+  function encodeReply(value)
+  /* We don't use URLSearchParams yet but maybe */
+  {
+    return new Promise(function (resolve, reject) {
+      processReply(value, resolve, reject);
+    });
+  }
+
   exports.createFromFetch = createFromFetch;
   exports.createFromReadableStream = createFromReadableStream;
   exports.createFromXHR = createFromXHR;
+  exports.encodeReply = encodeReply;
 
 }));