Shafi-Anwar
commented
9 months ago this is helping maybe
if (true) { (function() { "use strict"; var ReactDOM = webpack_require__(/! react-dom / "(app-pages-browser)/./node_modules/next/dist/compiled/react-dom/index.js"); var React = webpack_require(/! react / "(app-pages-browser)/./node_modules/next/dist/compiled/react/index.js"); // ----------------------------------------------------------------------------- var enableBinaryFlight = false; function createStringDecoder() { return new TextDecoder(); } var decoderOptions = { stream: true }; function readPartialStringChunk(decoder, buffer) { return decoder.decode(buffer, decoderOptions); } function readFinalStringChunk(decoder, buffer) { return decoder.decode(buffer); } // This is the parsed shape of the wire format which is why it is // condensed to only the essentialy information var ID = 0; var CHUNKS = 1; var NAME = 2; // export const ASYNC = 3; // This logic is correct because currently only include the 4th tuple member // when the module is async. If that changes we will need to actually assert // the value is true. We don't index into the 4th slot because flow does not // like the potential out of bounds access function isAsyncImport(metadata) { return metadata.length === 4; } function resolveClientReference(bundlerConfig, metadata) { if (bundlerConfig) { var moduleExports = bundlerConfig[metadata[ID]]; var resolvedModuleData = moduleExports[metadata[NAME]]; var name; if (resolvedModuleData) { // The potentially aliased name. name = resolvedModuleData.name; } else { // If we don't have this specific name, we might have the full module. resolvedModuleData = moduleExports["*"]; if (!resolvedModuleData) { throw new Error('Could not find the module "' + metadata[ID] + '" in the React SSR Manifest. ' + "This is probably a bug in the React Server Components bundler."); } name = metadata[NAME]; } if (isAsyncImport(metadata)) { return [resolvedModuleData.id, resolvedModuleData.chunks, name, 1]; } else { return [resolvedModuleData.id, resolvedModuleData.chunks, name]; } } return metadata; } // 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. var chunkCache = new Map(); function requireAsyncModule(id) { // We've already loaded all the chunks. We can require the module. var promise = __webpack_require(id); if (typeof promise.then !== "function") { // This wasn't a promise after all. return null; } else if (promise.status === "fulfilled") { // This module was already resolved earlier. return null; } else { // Instrument the Promise to stash the result. promise.then(function(value) { var fulfilledThenable = promise; fulfilledThenable.status = "fulfilled"; fulfilledThenable.value = value; }, function(reason) { var rejectedThenable = promise; rejectedThenable.status = "rejected"; rejectedThenable.reason = reason; }); return promise; } } function ignoreReject() {} // Start preloading the modules since we might need them soon. // This function doesn't suspend. function preloadModule(metadata) { var chunks = metadata[CHUNKS]; var promises = []; var i = 0; while (i < chunks.length) { var chunkId = chunks[i++]; var chunkFilename = chunks[i++]; var entry = chunkCache.get(chunkId); if (entry === undefined) { var thenable = loadChunk(chunkId, chunkFilename); promises.push(thenable); // $FlowFixMe[method-unbinding] var resolve = chunkCache.set.bind(chunkCache, chunkId, null); thenable.then(resolve, ignoreReject); chunkCache.set(chunkId, thenable); } else if (entry !== null) { promises.push(entry); } } if (isAsyncImport(metadata)) { if (promises.length === 0) { return requireAsyncModule(metadata[ID]); } else { return Promise.all(promises).then(function() { return requireAsyncModule(metadata[ID]); }); } } else if (promises.length > 0) { return Promise.all(promises); } else { return null; } }
function requireModule(metadata) {
var moduleExports = __webpack_require__(metadata[ID]);
if (isAsyncImport(metadata)) {
if (typeof moduleExports.then !== "function");
else if (moduleExports.status === "fulfilled") {
moduleExports = moduleExports.value;
} else {
throw moduleExports.reason;
}
}
if (metadata[NAME] === "*") {
return moduleExports;
}
if (metadata[NAME] === "")
return moduleExports.__esModule ? moduleExports.default : moduleExports;
return moduleExports[metadata[NAME]];
}
var chunkMap = new Map();
var webpackGetChunkFilename = __webpack_require__.u;
__webpack_require__.u = function(chunkId) {
var flightChunk = chunkMap.get(chunkId);
if (flightChunk !== undefined) {
return flightChunk;
}
return webpackGetChunkFilename(chunkId);
}
;
function loadChunk(chunkId, filename) {
chunkMap.set(chunkId, filename);
return __webpack_require__.e(chunkId);
}
var ReactDOMSharedInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
// This client file is in the shared folder because it applies to both SSR and browser contexts.
var ReactDOMCurrentDispatcher = ReactDOMSharedInternals.Dispatcher;
function dispatchHint(code, model) {
var dispatcher = ReactDOMCurrentDispatcher.current;
if (dispatcher) {
switch (code) {
case "D":
{
var refined = refineModel(code, model);
var href = refined;
dispatcher.prefetchDNS(href);
return;
}
case "C":
{
var _refined = refineModel(code, model);
if (typeof _refined === "string") {
var _href = _refined;
dispatcher.preconnect(_href);
} else {
var _href2 = _refined[0];
var crossOrigin = _refined[1];
dispatcher.preconnect(_href2, crossOrigin);
}
return;
}
case "L":
{
var _refined2 = refineModel(code, model);
var _href3 = _refined2[0];
var as = _refined2[1];
if (_refined2.length === 3) {
var options = _refined2[2];
dispatcher.preload(_href3, as, options);
} else {
dispatcher.preload(_href3, as);
}
return;
}
case "m":
{
var _refined3 = refineModel(code, model);
if (typeof _refined3 === "string") {
var _href4 = _refined3;
dispatcher.preloadModule(_href4);
} else {
var _href5 = _refined3[0];
var _options = _refined3[1];
dispatcher.preloadModule(_href5, _options);
}
return;
}
case "S":
{
var _refined4 = refineModel(code, model);
if (typeof _refined4 === "string") {
var _href6 = _refined4;
dispatcher.preinitStyle(_href6);
} else {
var _href7 = _refined4[0];
var precedence = _refined4[1] === 0 ? undefined : _refined4[1];
var _options2 = _refined4.length === 3 ? _refined4[2] : undefined;
dispatcher.preinitStyle(_href7, precedence, _options2);
}
return;
}
case "X":
{
var _refined5 = refineModel(code, model);
if (typeof _refined5 === "string") {
var _href8 = _refined5;
dispatcher.preinitScript(_href8);
} else {
var _href9 = _refined5[0];
var _options3 = _refined5[1];
dispatcher.preinitScript(_href9, _options3);
}
return;
}
case "M":
{
var _refined6 = refineModel(code, model);
if (typeof _refined6 === "string") {
var _href10 = _refined6;
dispatcher.preinitModuleScript(_href10);
} else {
var _href11 = _refined6[0];
var _options4 = _refined6[1];
dispatcher.preinitModuleScript(_href11, _options4);
}
return;
}
}
}
}
// Flow is having trouble refining the HintModels so we help it a bit.
// This should be compiled out in the production build.
function refineModel(code, model) {
return model;
}
var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
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);
}
}
// 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_SERVER_CONTEXT_TYPE = Symbol.for("react.server_context");
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 isArrayImpl = Array.isArray;
// eslint-disable-next-line no-redeclare
function isArray(a) {
return isArrayImpl(a);
}
var getPrototypeOf = Object.getPrototypeOf;
// 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 (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(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") {
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.slice(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) {
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) {
_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) {
_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) {
_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;
}
var ObjectPrototype = Object.prototype;
var knownServerReferences = new WeakMap();
// Serializable values
// 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 serializeFormDataReference(id) {
// Why K? F is "Function". D is "Date". What else?
return "$K" + id.toString(16);
}
function serializeNumber(number) {
if (Number.isFinite(number)) {
if (number === 0 && 1 / number === -Infinity) {
return "$-0";
} else {
return number;
}
} else {
if (number === Infinity) {
return "$Infinity";
} else if (number === -Infinity) {
return "$-Infinity";
} else {
return "$NaN";
}
}
}
function serializeUndefined() {
return "$undefined";
}
function serializeDateFromDateJSON(dateJSON) {
// JSON.stringify automatically calls Date.prototype.toJSON which calls toISOString.
// We need only tack on a $D prefix.
return "$D" + dateJSON;
}
function serializeBigInt(n) {
return "$n" + n.toString(10);
}
function serializeMapID(id) {
return "$Q" + id.toString(16);
}
function serializeSetID(id) {
return "$W" + id.toString(16);
}
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, formFieldPrefix, resolve, reject) {
var nextPartId = 1;
var pendingParts = 0;
var formData = null;
function resolveToJSON(key, value) {
var parent = this;
// Make sure that `parent[key]` wasn't JSONified before `value` was passed to us
{
// $FlowFixMe[incompatible-use]
var originalValue = parent[key];
if (typeof originalValue === "object" && originalValue !== value && !(originalValue instanceof Date)) {
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(formFieldPrefix + 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)) {
// $FlowFixMe[incompatible-return]
return value;
}
// TODO: Should we the Object.prototype.toString.call() to test for cross-realm objects?
if (value instanceof FormData) {
if (formData === null) {
// Upgrade to use FormData to allow us to use rich objects as its values.
formData = new FormData();
}
var data = formData;
var refId = nextPartId++;
// Copy all the form fields with a prefix for this reference.
// These must come first in the form order because we assume that all the
// fields are available before this is referenced.
var prefix = formFieldPrefix + refId + "_";
// $FlowFixMe[prop-missing]: FormData has forEach.
value.forEach(function(originalValue, originalKey) {
data.append(prefix + originalKey, originalValue);
});
return serializeFormDataReference(refId);
}
if (value instanceof Map) {
var partJSON = JSON.stringify(Array.from(value), resolveToJSON);
if (formData === null) {
formData = new FormData();
}
var mapId = nextPartId++;
formData.append(formFieldPrefix + mapId, partJSON);
return serializeMapID(mapId);
}
if (value instanceof Set) {
var _partJSON = JSON.stringify(Array.from(value), resolveToJSON);
if (formData === null) {
formData = new FormData();
}
var setId = nextPartId++;
formData.append(formFieldPrefix + setId, _partJSON);
return serializeSetID(setId);
}
var iteratorFn = getIteratorFn(value);
if (iteratorFn) {
return Array.from(value);
}
// Verify that this is a simple plain object.
var proto = getPrototypeOf(value);
if (proto !== ObjectPrototype && (proto === null || getPrototypeOf(proto) !== null)) {
throw new Error("Only plain objects, and a few built-ins, can be passed to Server Actions. " + "Classes or null prototypes are not supported.");
}
{
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 Server Functions from the Client. " + "%s objects are not supported.%s", objectName(value), describeObjectForErrorMessage(parent, key));
} else if (!isSimpleObject(value)) {
error("Only plain objects can be passed to Server Functions from the Client. " + "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 Server Functions from the Client. " + "Objects with symbol properties like %s are not supported.%s", symbols[0].description, describeObjectForErrorMessage(parent, key));
}
}
}
return value;
}
if (typeof value === "string") {
// TODO: Maybe too clever. If we support URL there's no similar trick.
if (value[value.length - 1] === "Z") {
// Possibly a Date, whose toJSON automatically calls toISOString
// $FlowFixMe[incompatible-use]
var _originalValue = parent[key];
if (_originalValue instanceof Date) {
return serializeDateFromDateJSON(value);
}
}
return escapeStringValue(value);
}
if (typeof value === "boolean") {
return value;
}
if (typeof value === "number") {
return serializeNumber(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(formFieldPrefix + _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[incompatible-type] `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[incompatible-type] `description` might be undefined
value.description + ") cannot be found among global symbols."));
}
return serializeSymbolReference(name);
}
if (typeof value === "bigint") {
return serializeBigInt(value);
}
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(formFieldPrefix + "0", json);
if (pendingParts === 0) {
// $FlowFixMe[incompatible-call] this has already been refined.
resolve(formData);
}
}
}
function registerServerReference(proxy, reference) {
knownServerReferences.set(proxy, reference);
}
// $FlowFixMe[method-unbinding]
function createServerReference(id, callServer) {
var proxy = function() {
// $FlowFixMe[method-unbinding]
var args = Array.prototype.slice.call(arguments);
return callServer(id, args);
};
registerServerReference(proxy, {
id: id,
bound: null
});
return proxy;
}
var ContextRegistry = ReactSharedInternals.ContextRegistry;
function getOrCreateServerContext(globalName) {
if (!ContextRegistry[globalName]) {
var context = {
$$typeof: REACT_SERVER_CONTEXT_TYPE,
// As a workaround to support multiple concurrent renderers, we categorize
// some renderers as primary and others as secondary. We only expect
// there to be two concurrent renderers at most: React Native (primary) and
// Fabric (secondary); React DOM (primary) and React ART (secondary).
// Secondary renderers store their context values on separate fields.
_currentValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
_currentValue2: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
_defaultValue: REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED,
// Used to track how many concurrent renderers this context currently
// supports within in a single renderer. Such as parallel server rendering.
_threadCount: 0,
// These are circular
Provider: null,
Consumer: null,
_globalName: globalName
};
context.Provider = {
$$typeof: REACT_PROVIDER_TYPE,
_context: context
};
{
var hasWarnedAboutUsingConsumer;
context._currentRenderer = null;
context._currentRenderer2 = null;
Object.defineProperties(context, {
Consumer: {
get: function() {
if (!hasWarnedAboutUsingConsumer) {
error("Consumer pattern is not supported by ReactServerContext");
hasWarnedAboutUsingConsumer = true;
}
return null;
}
}
});
}
ContextRegistry[globalName] = context;
}
return ContextRegistry[globalName];
}
var ROW_ID = 0;
var ROW_TAG = 1;
var ROW_LENGTH = 2;
var ROW_CHUNK_BY_NEWLINE = 3;
var ROW_CHUNK_BY_LENGTH = 4;
var PENDING = "pending";
var BLOCKED = "blocked";
var CYCLIC = "cyclic";
var RESOLVED_MODEL = "resolved_model";
var RESOLVED_MODULE = "resolved_module";
var INITIALIZED = "fulfilled";
var ERRORED = "rejected";
// $FlowFixMe[missing-this-annot]
function Chunk(status, value, reason, response) {
this.status = status;
this.value = value;
this.reason = reason;
this._response = response;
}
// We subclass Promise.prototype so that we get other methods like .catch
Chunk.prototype = Object.create(Promise.prototype);
// TODO: This doesn't return a new Promise chain unlike the real .then
Chunk.prototype.then = function(resolve, reject) {
var chunk = this;
// If we have resolved content, we try to initialize it first which
// might put us back into one of the other states.
switch (chunk.status) {
case RESOLVED_MODEL:
initializeModelChunk(chunk);
break;
case RESOLVED_MODULE:
initializeModuleChunk(chunk);
break;
}
// The status might have changed after initialization.
switch (chunk.status) {
case INITIALIZED:
resolve(chunk.value);
break;
case PENDING:
case BLOCKED:
case CYCLIC:
if (resolve) {
if (chunk.value === null) {
chunk.value = [];
}
chunk.value.push(resolve);
}
if (reject) {
if (chunk.reason === null) {
chunk.reason = [];
}
chunk.reason.push(reject);
}
break;
default:
reject(chunk.reason);
break;
}
}
;
function readChunk(chunk) {
// If we have resolved content, we try to initialize it first which
// might put us back into one of the other states.
switch (chunk.status) {
case RESOLVED_MODEL:
initializeModelChunk(chunk);
break;
case RESOLVED_MODULE:
initializeModuleChunk(chunk);
break;
}
// The status might have changed after initialization.
switch (chunk.status) {
case INITIALIZED:
return chunk.value;
case PENDING:
case BLOCKED:
case CYCLIC:
// eslint-disable-next-line no-throw-literal
throw chunk;
default:
throw chunk.reason;
}
}
function getRoot(response) {
var chunk = getChunk(response, 0);
return chunk;
}
function createPendingChunk(response) {
// $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
return new Chunk(PENDING,null,null,response);
}
function createBlockedChunk(response) {
// $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
return new Chunk(BLOCKED,null,null,response);
}
function createErrorChunk(response, error) {
// $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
return new Chunk(ERRORED,null,error,response);
}
function wakeChunk(listeners, value) {
for (var i = 0; i < listeners.length; i++) {
var listener = listeners[i];
listener(value);
}
}
function wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners) {
switch (chunk.status) {
case INITIALIZED:
wakeChunk(resolveListeners, chunk.value);
break;
case PENDING:
case BLOCKED:
case CYCLIC:
chunk.value = resolveListeners;
chunk.reason = rejectListeners;
break;
case ERRORED:
if (rejectListeners) {
wakeChunk(rejectListeners, chunk.reason);
}
break;
}
}
function triggerErrorOnChunk(chunk, error) {
if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
// We already resolved. We didn't expect to see this.
return;
}
var listeners = chunk.reason;
var erroredChunk = chunk;
erroredChunk.status = ERRORED;
erroredChunk.reason = error;
if (listeners !== null) {
wakeChunk(listeners, error);
}
}
function createResolvedModelChunk(response, value) {
// $FlowFixMe[invalid-constructor] Flow doesn't support functions as constructors
return new Chunk(RESOLVED_MODEL,value,null,response);
}
function createResolvedModuleChunk(response, value) {
return new Chunk(RESOLVED_MODULE,value,null,response);
}
function createInitializedTextChunk(response, value) {
return new Chunk(INITIALIZED,value,null,response);
}
function resolveModelChunk(chunk, value) {
if (chunk.status !== PENDING) {
return;
}
var resolveListeners = chunk.value;
var rejectListeners = chunk.reason;
var resolvedChunk = chunk;
resolvedChunk.status = RESOLVED_MODEL;
resolvedChunk.value = value;
if (resolveListeners !== null) {
initializeModelChunk(resolvedChunk);
wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
}
}
function resolveModuleChunk(chunk, value) {
if (chunk.status !== PENDING && chunk.status !== BLOCKED) {
return;
}
var resolveListeners = chunk.value;
var rejectListeners = chunk.reason;
var resolvedChunk = chunk;
resolvedChunk.status = RESOLVED_MODULE;
resolvedChunk.value = value;
if (resolveListeners !== null) {
initializeModuleChunk(resolvedChunk);
wakeChunkIfInitialized(chunk, resolveListeners, rejectListeners);
}
}
var initializingChunk = null;
var initializingChunkBlockedModel = null;
function initializeModelChunk(chunk) {
var prevChunk = initializingChunk;
var prevBlocked = initializingChunkBlockedModel;
initializingChunk = chunk;
initializingChunkBlockedModel = null;
var resolvedModel = chunk.value;
var cyclicChunk = chunk;
cyclicChunk.status = CYCLIC;
cyclicChunk.value = null;
cyclicChunk.reason = null;
try {
var value = parseModel(chunk._response, resolvedModel);
if (initializingChunkBlockedModel !== null && initializingChunkBlockedModel.deps > 0) {
initializingChunkBlockedModel.value = value;
var blockedChunk = chunk;
blockedChunk.status = BLOCKED;
blockedChunk.value = null;
blockedChunk.reason = null;
} else {
var resolveListeners = cyclicChunk.value;
var initializedChunk = chunk;
initializedChunk.status = INITIALIZED;
initializedChunk.value = value;
if (resolveListeners !== null) {
wakeChunk(resolveListeners, value);
}
}
} catch (error) {
var erroredChunk = chunk;
erroredChunk.status = ERRORED;
erroredChunk.reason = error;
} finally {
initializingChunk = prevChunk;
initializingChunkBlockedModel = prevBlocked;
}
}
function initializeModuleChunk(chunk) {
try {
var value = requireModule(chunk.value);
var initializedChunk = chunk;
initializedChunk.status = INITIALIZED;
initializedChunk.value = value;
} catch (error) {
var erroredChunk = chunk;
erroredChunk.status = ERRORED;
erroredChunk.reason = error;
}
}
function reportGlobalError(response, error) {
response._chunks.forEach(function(chunk) {
if (chunk.status === PENDING) {
triggerErrorOnChunk(chunk, error);
}
});
}
function createElement(type, key, props) {
var element = {
$$typeof: REACT_ELEMENT_TYPE,
type: type,
key: key,
ref: null,
props: props,
_owner: null
};
{
element._store = {};
Object.defineProperty(element._store, "validated", {
configurable: false,
enumerable: false,
writable: true,
value: true // This element has already been validated on the server.
});
Object.defineProperty(element, "_self", {
configurable: false,
enumerable: false,
writable: false,
value: null
});
Object.defineProperty(element, "_source", {
configurable: false,
enumerable: false,
writable: false,
value: null
});
}
return element;
}
function createLazyChunkWrapper(chunk) {
var lazyType = {
$$typeof: REACT_LAZY_TYPE,
_payload: chunk,
_init: readChunk
};
return lazyType;
}
function getChunk(response, id) {
var chunks = response._chunks;
var chunk = chunks.get(id);
if (!chunk) {
chunk = createPendingChunk(response);
chunks.set(id, chunk);
}
return chunk;
}
function createModelResolver(chunk, parentObject, key, cyclic) {
var blocked;
if (initializingChunkBlockedModel) {
blocked = initializingChunkBlockedModel;
if (!cyclic) {
blocked.deps++;
}
} else {
blocked = initializingChunkBlockedModel = {
deps: cyclic ? 0 : 1,
value: null
};
}
return function(value) {
parentObject[key] = value;
blocked.deps--;
if (blocked.deps === 0) {
if (chunk.status !== BLOCKED) {
return;
}
var resolveListeners = chunk.value;
var initializedChunk = chunk;
initializedChunk.status = INITIALIZED;
initializedChunk.value = blocked.value;
if (resolveListeners !== null) {
wakeChunk(resolveListeners, blocked.value);
}
}
}
;
}
function createModelReject(chunk) {
return function(error) {
return triggerErrorOnChunk(chunk, error);
}
;
}
function createServerReferenceProxy(response, metaData) {
var callServer = response._callServer;
var proxy = function() {
var args = Array.prototype.slice.call(arguments);
var p = metaData.bound;
if (!p) {
return callServer(metaData.id, args);
}
if (p.status === INITIALIZED) {
var bound = p.value;
return callServer(metaData.id, bound.concat(args));
}
return Promise.resolve(p).then(function(bound) {
return callServer(metaData.id, bound.concat(args));
});
};
registerServerReference(proxy, metaData);
return proxy;
}
function getOutlinedModel(response, id) {
var chunk = getChunk(response, id);
switch (chunk.status) {
case RESOLVED_MODEL:
initializeModelChunk(chunk);
break;
}
switch (chunk.status) {
case INITIALIZED:
{
return chunk.value;
}
default:
throw chunk.reason;
}
}
function parseModelString(response, parentObject, key, value) {
if (value[0] === "$") {
if (value === "$") {
// A very common symbol.
return REACT_ELEMENT_TYPE;
}
switch (value[1]) {
case "$":
{
// This was an escaped string value.
return value.slice(1);
}
case "L":
{
// Lazy node
var id = parseInt(value.slice(2), 16);
var chunk = getChunk(response, id);
// We create a React.lazy wrapper around any lazy values.
// When passed into React, we'll know how to suspend on this.
return createLazyChunkWrapper(chunk);
}
case "@":
{
// Promise
var _id = parseInt(value.slice(2), 16);
var _chunk = getChunk(response, _id);
return _chunk;
}
case "S":
{
// Symbol
return Symbol.for(value.slice(2));
}
case "P":
{
// Server Context Provider
return getOrCreateServerContext(value.slice(2)).Provider;
}
case "F":
{
// Server Reference
var _id2 = parseInt(value.slice(2), 16);
var metadata = getOutlinedModel(response, _id2);
return createServerReferenceProxy(response, metadata);
}
case "Q":
{
// Map
var _id3 = parseInt(value.slice(2), 16);
var data = getOutlinedModel(response, _id3);
return new Map(data);
}
case "W":
{
// Set
var _id4 = parseInt(value.slice(2), 16);
var _data = getOutlinedModel(response, _id4);
return new Set(_data);
}
case "I":
{
return Infinity;
}
case "-":
{
if (value === "$-0") {
return -0;
} else {
return -Infinity;
}
}
case "N":
{
// $NaN
return NaN;
}
case "u":
{
// matches "$undefined"
// Special encoding for `undefined` which can't be serialized as JSON otherwise.
return undefined;
}
case "D":
{
// Date
return new Date(Date.parse(value.slice(2)));
}
case "n":
{
// BigInt
return BigInt(value.slice(2));
}
default:
{
var _id5 = parseInt(value.slice(1), 16);
var _chunk2 = getChunk(response, _id5);
switch (_chunk2.status) {
case RESOLVED_MODEL:
initializeModelChunk(_chunk2);
break;
case RESOLVED_MODULE:
initializeModuleChunk(_chunk2);
break;
}
switch (_chunk2.status) {
case INITIALIZED:
return _chunk2.value;
case PENDING:
case BLOCKED:
case CYCLIC:
var parentChunk = initializingChunk;
_chunk2.then(createModelResolver(parentChunk, parentObject, key, _chunk2.status === CYCLIC), createModelReject(parentChunk));
return null;
default:
throw _chunk2.reason;
}
}
}
}
return value;
}
function parseModelTuple(response, value) {
var tuple = value;
if (tuple[0] === REACT_ELEMENT_TYPE) {
return createElement(tuple[1], tuple[2], tuple[3]);
}
return value;
}
function missingCall() {
throw new Error('Trying to call a function from "use server" but the callServer option ' + "was not implemented in your router runtime.");
}
function createResponse(bundlerConfig, moduleLoading, callServer, nonce) {
var chunks = new Map();
var response = {
_bundlerConfig: bundlerConfig,
_moduleLoading: moduleLoading,
_callServer: callServer !== undefined ? callServer : missingCall,
_nonce: nonce,
_chunks: chunks,
_stringDecoder: createStringDecoder(),
_fromJSON: null,
_rowState: 0,
_rowID: 0,
_rowTag: 0,
_rowLength: 0,
_buffer: []
};
response._fromJSON = createFromJSONCallback(response);
return response;
}
function resolveModel(response, id, model) {
var chunks = response._chunks;
var chunk = chunks.get(id);
if (!chunk) {
chunks.set(id, createResolvedModelChunk(response, model));
} else {
resolveModelChunk(chunk, model);
}
}
function resolveText(response, id, text) {
var chunks = response._chunks;
chunks.set(id, createInitializedTextChunk(response, text));
}
function resolveModule(response, id, model) {
var chunks = response._chunks;
var chunk = chunks.get(id);
var clientReferenceMetadata = parseModel(response, model);
var clientReference = resolveClientReference(response._bundlerConfig, clientReferenceMetadata);
var promise = preloadModule(clientReference);
if (promise) {
var blockedChunk;
if (!chunk) {
blockedChunk = createBlockedChunk(response);
chunks.set(id, blockedChunk);
} else {
blockedChunk = chunk;
blockedChunk.status = BLOCKED;
}
promise.then(function() {
return resolveModuleChunk(blockedChunk, clientReference);
}, function(error) {
return triggerErrorOnChunk(blockedChunk, error);
});
} else {
if (!chunk) {
chunks.set(id, createResolvedModuleChunk(response, clientReference));
} else {
resolveModuleChunk(chunk, clientReference);
}
}
}
function resolveErrorDev(response, id, digest, message, stack) {
var error = new Error(message || "An error occurred in the Server Components render but no message was provided");
error.stack = stack;
error.digest = digest;
var errorWithDigest = error;
var chunks = response._chunks;
var chunk = chunks.get(id);
if (!chunk) {
chunks.set(id, createErrorChunk(response, errorWithDigest));
} else {
triggerErrorOnChunk(chunk, errorWithDigest);
}
}
function resolveHint(response, code, model) {
var hintModel = parseModel(response, model);
dispatchHint(code, hintModel);
}
function processFullRow(response, id, tag, buffer, chunk) {
var stringDecoder = response._stringDecoder;
var row = "";
for (var i = 0; i < buffer.length; i++) {
row += readPartialStringChunk(stringDecoder, buffer[i]);
}
row += readFinalStringChunk(stringDecoder, chunk);
switch (tag) {
case 73:
{
resolveModule(response, id, row);
return;
}
case 72:
{
var code = row[0];
resolveHint(response, code, row.slice(1));
return;
}
case 69:
{
var errorInfo = JSON.parse(row);
{
resolveErrorDev(response, id, errorInfo.digest, errorInfo.message, errorInfo.stack);
}
return;
}
case 84:
{
resolveText(response, id, row);
return;
}
case 80:
// Fallthrough
default:
/* """ "{" "[" "t" "f" "n" "0" - "9" */
{
resolveModel(response, id, row);
return;
}
}
}
function processBinaryChunk(response, chunk) {
var i = 0;
var rowState = response._rowState;
var rowID = response._rowID;
var rowTag = response._rowTag;
var rowLength = response._rowLength;
var buffer = response._buffer;
var chunkLength = chunk.length;
while (i < chunkLength) {
var lastIdx = -1;
switch (rowState) {
case ROW_ID:
{
var byte = chunk[i++];
if (byte === 58) {
rowState = ROW_TAG;
} else {
rowID = rowID << 4 | (byte > 96 ? byte - 87 : byte - 48);
}
continue;
}
case ROW_TAG:
{
var resolvedRowTag = chunk[i];
if (resolvedRowTag === 84 || enableBinaryFlight) {
rowTag = resolvedRowTag;
rowState = ROW_LENGTH;
i++;
} else if (resolvedRowTag > 64 && resolvedRowTag < 91) {
rowTag = resolvedRowTag;
rowState = ROW_CHUNK_BY_NEWLINE;
i++;
} else {
rowTag = 0;
rowState = ROW_CHUNK_BY_NEWLINE;
}
continue;
}
case ROW_LENGTH:
{
var _byte = chunk[i++];
if (_byte === 44) {
rowState = ROW_CHUNK_BY_LENGTH;
} else {
rowLength = rowLength << 4 | (_byte > 96 ? _byte - 87 : _byte - 48);
}
continue;
}
case ROW_CHUNK_BY_NEWLINE:
{
lastIdx = chunk.indexOf(10, i);
break;
}
case ROW_CHUNK_BY_LENGTH:
{
lastIdx = i + rowLength;
if (lastIdx > chunk.length) {
lastIdx = -1;
}
break;
}
}
var offset = chunk.byteOffset + i;
if (lastIdx > -1) {
var length = lastIdx - i;
var lastChunk = new Uint8Array(chunk.buffer,offset,length);
processFullRow(response, rowID, rowTag, buffer, lastChunk);
i = lastIdx;
if (rowState === ROW_CHUNK_BY_NEWLINE) {
i++;
}
rowState = ROW_ID;
rowTag = 0;
rowID = 0;
rowLength = 0;
buffer.length = 0;
} else {
var _length = chunk.byteLength - i;
var remainingSlice = new Uint8Array(chunk.buffer,offset,_length);
buffer.push(remainingSlice);
rowLength -= remainingSlice.byteLength;
break;
}
}
response._rowState = rowState;
response._rowID = rowID;
response._rowTag = rowTag;
response._rowLength = rowLength;
}
function parseModel(response, json) {
return JSON.parse(json, response._fromJSON);
}
function createFromJSONCallback(response) {
return function(key, value) {
if (typeof value === "string") {
return parseModelString(response, this, key, value);
}
if (typeof value === "object" && value !== null) {
return parseModelTuple(response, value);
}
return value;
}
;
}
function close(response) {
reportGlobalError(response, new Error("Connection closed."));
}
function createResponseFromOptions(options) {
return createResponse(null, null, options && options.callServer ? options.callServer : undefined, undefined // nonce
);
}
function startReadingFromStream(response, stream) {
var reader = stream.getReader();
function progress(_ref) {
var done = _ref.done
, value = _ref.value;
if (done) {
close(response);
return;
}
var buffer = value;
processBinaryChunk(response, buffer);
return reader.read().then(progress).catch(error);
}
function error(e) {
reportGlobalError(response, e);
}
reader.read().then(progress).catch(error);
}
function createFromReadableStream(stream, options) {
var response = createResponseFromOptions(options);
startReadingFromStream(response, stream);
return getRoot(response);
}
function createFromFetch(promiseForResponse, options) {
var response = createResponseFromOptions(options);
promiseForResponse.then(function(r) {
startReadingFromStream(response, r.body);
}, function(e) {
reportGlobalError(response, e);
});
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.createServerReference = createServerReference;
exports.encodeReply = encodeReply;
}
)();}
Label shipment icons on the gantt chart with basic information (id and label). Permanent labels or on mouse hover may make better sense.