mirror of
https://github.com/facebook/react.git
synced 2025-11-01 09:12:30 +00:00
Update compiled-rn destination paths to vendor/react (#28989)
I'm changing the destination paths in fbsource from `vendor/*` to `vendor/react/*`. DiffTrain build for commit https://github.com/facebook/react/commit/46abd7b1deb42d23b65480432609a2f8c5014cde.
This commit is contained in:
yungsters
Vendored
+201
@@ -0,0 +1,201 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<cc5ff8fe75f7cb7812ce459378d61959>>
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
if (__DEV__) {
|
||||
(function() {
|
||||
'use strict';
|
||||
|
||||
// Re-export dynamic flags from the internal module.
|
||||
var enableDebugTracing = false;
|
||||
var enableRenderableContext = true;
|
||||
var enableScopeAPI = false;
|
||||
var enableLegacyHidden = false;
|
||||
var enableTransitionTracing = false;
|
||||
|
||||
// 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_LEGACY_ELEMENT_TYPE = Symbol.for('react.element');
|
||||
var REACT_ELEMENT_TYPE = REACT_LEGACY_ELEMENT_TYPE;
|
||||
var REACT_PORTAL_TYPE = Symbol.for('react.portal');
|
||||
var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
|
||||
var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
|
||||
var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
|
||||
var REACT_PROVIDER_TYPE = Symbol.for('react.provider'); // TODO: Delete with enableRenderableContext
|
||||
|
||||
var REACT_CONSUMER_TYPE = Symbol.for('react.consumer');
|
||||
var REACT_CONTEXT_TYPE = Symbol.for('react.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_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
|
||||
|
||||
var REACT_CLIENT_REFERENCE = Symbol.for('react.client.reference');
|
||||
function isValidElementType(type) {
|
||||
if (typeof type === 'string' || typeof type === 'function') {
|
||||
return true;
|
||||
} // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
|
||||
|
||||
|
||||
if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableTransitionTracing ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (typeof type === 'object' && type !== null) {
|
||||
if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || !enableRenderableContext || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
|
||||
// types supported by any Flight configuration anywhere since
|
||||
// we don't know which Flight build this will end up being used
|
||||
// with.
|
||||
type.$$typeof === REACT_CLIENT_REFERENCE || type.getModuleId !== undefined) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function typeOf(object) {
|
||||
if (typeof object === 'object' && object !== null) {
|
||||
var $$typeof = object.$$typeof;
|
||||
|
||||
switch ($$typeof) {
|
||||
case REACT_ELEMENT_TYPE:
|
||||
var type = object.type;
|
||||
|
||||
switch (type) {
|
||||
case REACT_FRAGMENT_TYPE:
|
||||
case REACT_PROFILER_TYPE:
|
||||
case REACT_STRICT_MODE_TYPE:
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return type;
|
||||
|
||||
default:
|
||||
var $$typeofType = type && type.$$typeof;
|
||||
|
||||
switch ($$typeofType) {
|
||||
case REACT_CONTEXT_TYPE:
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
case REACT_LAZY_TYPE:
|
||||
case REACT_MEMO_TYPE:
|
||||
return $$typeofType;
|
||||
|
||||
case REACT_CONSUMER_TYPE:
|
||||
{
|
||||
return $$typeofType;
|
||||
}
|
||||
|
||||
// Fall through
|
||||
|
||||
case REACT_PROVIDER_TYPE:
|
||||
|
||||
// Fall through
|
||||
|
||||
default:
|
||||
return $$typeof;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
case REACT_PORTAL_TYPE:
|
||||
return $$typeof;
|
||||
}
|
||||
}
|
||||
|
||||
return undefined;
|
||||
}
|
||||
var ContextConsumer = REACT_CONSUMER_TYPE ;
|
||||
var ContextProvider = REACT_CONTEXT_TYPE ;
|
||||
var Element = REACT_ELEMENT_TYPE;
|
||||
var ForwardRef = REACT_FORWARD_REF_TYPE;
|
||||
var Fragment = REACT_FRAGMENT_TYPE;
|
||||
var Lazy = REACT_LAZY_TYPE;
|
||||
var Memo = REACT_MEMO_TYPE;
|
||||
var Portal = REACT_PORTAL_TYPE;
|
||||
var Profiler = REACT_PROFILER_TYPE;
|
||||
var StrictMode = REACT_STRICT_MODE_TYPE;
|
||||
var Suspense = REACT_SUSPENSE_TYPE;
|
||||
var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
|
||||
function isContextConsumer(object) {
|
||||
{
|
||||
return typeOf(object) === REACT_CONSUMER_TYPE;
|
||||
}
|
||||
}
|
||||
function isContextProvider(object) {
|
||||
{
|
||||
return typeOf(object) === REACT_CONTEXT_TYPE;
|
||||
}
|
||||
}
|
||||
function isElement(object) {
|
||||
return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
|
||||
}
|
||||
function isForwardRef(object) {
|
||||
return typeOf(object) === REACT_FORWARD_REF_TYPE;
|
||||
}
|
||||
function isFragment(object) {
|
||||
return typeOf(object) === REACT_FRAGMENT_TYPE;
|
||||
}
|
||||
function isLazy(object) {
|
||||
return typeOf(object) === REACT_LAZY_TYPE;
|
||||
}
|
||||
function isMemo(object) {
|
||||
return typeOf(object) === REACT_MEMO_TYPE;
|
||||
}
|
||||
function isPortal(object) {
|
||||
return typeOf(object) === REACT_PORTAL_TYPE;
|
||||
}
|
||||
function isProfiler(object) {
|
||||
return typeOf(object) === REACT_PROFILER_TYPE;
|
||||
}
|
||||
function isStrictMode(object) {
|
||||
return typeOf(object) === REACT_STRICT_MODE_TYPE;
|
||||
}
|
||||
function isSuspense(object) {
|
||||
return typeOf(object) === REACT_SUSPENSE_TYPE;
|
||||
}
|
||||
function isSuspenseList(object) {
|
||||
return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
|
||||
}
|
||||
|
||||
exports.ContextConsumer = ContextConsumer;
|
||||
exports.ContextProvider = ContextProvider;
|
||||
exports.Element = Element;
|
||||
exports.ForwardRef = ForwardRef;
|
||||
exports.Fragment = Fragment;
|
||||
exports.Lazy = Lazy;
|
||||
exports.Memo = Memo;
|
||||
exports.Portal = Portal;
|
||||
exports.Profiler = Profiler;
|
||||
exports.StrictMode = StrictMode;
|
||||
exports.Suspense = Suspense;
|
||||
exports.SuspenseList = SuspenseList;
|
||||
exports.isContextConsumer = isContextConsumer;
|
||||
exports.isContextProvider = isContextProvider;
|
||||
exports.isElement = isElement;
|
||||
exports.isForwardRef = isForwardRef;
|
||||
exports.isFragment = isFragment;
|
||||
exports.isLazy = isLazy;
|
||||
exports.isMemo = isMemo;
|
||||
exports.isPortal = isPortal;
|
||||
exports.isProfiler = isProfiler;
|
||||
exports.isStrictMode = isStrictMode;
|
||||
exports.isSuspense = isSuspense;
|
||||
exports.isSuspenseList = isSuspenseList;
|
||||
exports.isValidElementType = isValidElementType;
|
||||
exports.typeOf = typeOf;
|
||||
})();
|
||||
}
|
||||
Vendored
+132
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<b5f0f82fdd9d6e3043c1259e7ffcf255>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
|
||||
REACT_PORTAL_TYPE = Symbol.for("react.portal"),
|
||||
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
|
||||
REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
|
||||
REACT_PROFILER_TYPE = Symbol.for("react.profiler");
|
||||
Symbol.for("react.provider");
|
||||
var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
|
||||
REACT_CONTEXT_TYPE = Symbol.for("react.context"),
|
||||
REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
|
||||
REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
|
||||
REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
|
||||
REACT_MEMO_TYPE = Symbol.for("react.memo"),
|
||||
REACT_LAZY_TYPE = Symbol.for("react.lazy"),
|
||||
REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
|
||||
REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
|
||||
function typeOf(object) {
|
||||
if ("object" === typeof object && null !== object) {
|
||||
var $$typeof = object.$$typeof;
|
||||
switch ($$typeof) {
|
||||
case REACT_LEGACY_ELEMENT_TYPE:
|
||||
switch (((object = object.type), object)) {
|
||||
case REACT_FRAGMENT_TYPE:
|
||||
case REACT_PROFILER_TYPE:
|
||||
case REACT_STRICT_MODE_TYPE:
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return object;
|
||||
default:
|
||||
switch (((object = object && object.$$typeof), object)) {
|
||||
case REACT_CONTEXT_TYPE:
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
case REACT_LAZY_TYPE:
|
||||
case REACT_MEMO_TYPE:
|
||||
return object;
|
||||
case REACT_CONSUMER_TYPE:
|
||||
return object;
|
||||
default:
|
||||
return $$typeof;
|
||||
}
|
||||
}
|
||||
case REACT_PORTAL_TYPE:
|
||||
return $$typeof;
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.ContextConsumer = REACT_CONSUMER_TYPE;
|
||||
exports.ContextProvider = REACT_CONTEXT_TYPE;
|
||||
exports.Element = REACT_LEGACY_ELEMENT_TYPE;
|
||||
exports.ForwardRef = REACT_FORWARD_REF_TYPE;
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.Lazy = REACT_LAZY_TYPE;
|
||||
exports.Memo = REACT_MEMO_TYPE;
|
||||
exports.Portal = REACT_PORTAL_TYPE;
|
||||
exports.Profiler = REACT_PROFILER_TYPE;
|
||||
exports.StrictMode = REACT_STRICT_MODE_TYPE;
|
||||
exports.Suspense = REACT_SUSPENSE_TYPE;
|
||||
exports.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
|
||||
exports.isContextConsumer = function (object) {
|
||||
return typeOf(object) === REACT_CONSUMER_TYPE;
|
||||
};
|
||||
exports.isContextProvider = function (object) {
|
||||
return typeOf(object) === REACT_CONTEXT_TYPE;
|
||||
};
|
||||
exports.isElement = function (object) {
|
||||
return (
|
||||
"object" === typeof object &&
|
||||
null !== object &&
|
||||
object.$$typeof === REACT_LEGACY_ELEMENT_TYPE
|
||||
);
|
||||
};
|
||||
exports.isForwardRef = function (object) {
|
||||
return typeOf(object) === REACT_FORWARD_REF_TYPE;
|
||||
};
|
||||
exports.isFragment = function (object) {
|
||||
return typeOf(object) === REACT_FRAGMENT_TYPE;
|
||||
};
|
||||
exports.isLazy = function (object) {
|
||||
return typeOf(object) === REACT_LAZY_TYPE;
|
||||
};
|
||||
exports.isMemo = function (object) {
|
||||
return typeOf(object) === REACT_MEMO_TYPE;
|
||||
};
|
||||
exports.isPortal = function (object) {
|
||||
return typeOf(object) === REACT_PORTAL_TYPE;
|
||||
};
|
||||
exports.isProfiler = function (object) {
|
||||
return typeOf(object) === REACT_PROFILER_TYPE;
|
||||
};
|
||||
exports.isStrictMode = function (object) {
|
||||
return typeOf(object) === REACT_STRICT_MODE_TYPE;
|
||||
};
|
||||
exports.isSuspense = function (object) {
|
||||
return typeOf(object) === REACT_SUSPENSE_TYPE;
|
||||
};
|
||||
exports.isSuspenseList = function (object) {
|
||||
return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
|
||||
};
|
||||
exports.isValidElementType = function (type) {
|
||||
return "string" === typeof type ||
|
||||
"function" === typeof type ||
|
||||
type === REACT_FRAGMENT_TYPE ||
|
||||
type === REACT_PROFILER_TYPE ||
|
||||
type === REACT_STRICT_MODE_TYPE ||
|
||||
type === REACT_SUSPENSE_TYPE ||
|
||||
type === REACT_SUSPENSE_LIST_TYPE ||
|
||||
type === REACT_OFFSCREEN_TYPE ||
|
||||
("object" === typeof type &&
|
||||
null !== type &&
|
||||
(type.$$typeof === REACT_LAZY_TYPE ||
|
||||
type.$$typeof === REACT_MEMO_TYPE ||
|
||||
type.$$typeof === REACT_CONTEXT_TYPE ||
|
||||
type.$$typeof === REACT_CONSUMER_TYPE ||
|
||||
type.$$typeof === REACT_FORWARD_REF_TYPE ||
|
||||
type.$$typeof === REACT_CLIENT_REFERENCE ||
|
||||
void 0 !== type.getModuleId))
|
||||
? !0
|
||||
: !1;
|
||||
};
|
||||
exports.typeOf = typeOf;
|
||||
Vendored
+132
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<b5f0f82fdd9d6e3043c1259e7ffcf255>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
|
||||
REACT_PORTAL_TYPE = Symbol.for("react.portal"),
|
||||
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
|
||||
REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
|
||||
REACT_PROFILER_TYPE = Symbol.for("react.profiler");
|
||||
Symbol.for("react.provider");
|
||||
var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
|
||||
REACT_CONTEXT_TYPE = Symbol.for("react.context"),
|
||||
REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
|
||||
REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
|
||||
REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
|
||||
REACT_MEMO_TYPE = Symbol.for("react.memo"),
|
||||
REACT_LAZY_TYPE = Symbol.for("react.lazy"),
|
||||
REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
|
||||
REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
|
||||
function typeOf(object) {
|
||||
if ("object" === typeof object && null !== object) {
|
||||
var $$typeof = object.$$typeof;
|
||||
switch ($$typeof) {
|
||||
case REACT_LEGACY_ELEMENT_TYPE:
|
||||
switch (((object = object.type), object)) {
|
||||
case REACT_FRAGMENT_TYPE:
|
||||
case REACT_PROFILER_TYPE:
|
||||
case REACT_STRICT_MODE_TYPE:
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return object;
|
||||
default:
|
||||
switch (((object = object && object.$$typeof), object)) {
|
||||
case REACT_CONTEXT_TYPE:
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
case REACT_LAZY_TYPE:
|
||||
case REACT_MEMO_TYPE:
|
||||
return object;
|
||||
case REACT_CONSUMER_TYPE:
|
||||
return object;
|
||||
default:
|
||||
return $$typeof;
|
||||
}
|
||||
}
|
||||
case REACT_PORTAL_TYPE:
|
||||
return $$typeof;
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.ContextConsumer = REACT_CONSUMER_TYPE;
|
||||
exports.ContextProvider = REACT_CONTEXT_TYPE;
|
||||
exports.Element = REACT_LEGACY_ELEMENT_TYPE;
|
||||
exports.ForwardRef = REACT_FORWARD_REF_TYPE;
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.Lazy = REACT_LAZY_TYPE;
|
||||
exports.Memo = REACT_MEMO_TYPE;
|
||||
exports.Portal = REACT_PORTAL_TYPE;
|
||||
exports.Profiler = REACT_PROFILER_TYPE;
|
||||
exports.StrictMode = REACT_STRICT_MODE_TYPE;
|
||||
exports.Suspense = REACT_SUSPENSE_TYPE;
|
||||
exports.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
|
||||
exports.isContextConsumer = function (object) {
|
||||
return typeOf(object) === REACT_CONSUMER_TYPE;
|
||||
};
|
||||
exports.isContextProvider = function (object) {
|
||||
return typeOf(object) === REACT_CONTEXT_TYPE;
|
||||
};
|
||||
exports.isElement = function (object) {
|
||||
return (
|
||||
"object" === typeof object &&
|
||||
null !== object &&
|
||||
object.$$typeof === REACT_LEGACY_ELEMENT_TYPE
|
||||
);
|
||||
};
|
||||
exports.isForwardRef = function (object) {
|
||||
return typeOf(object) === REACT_FORWARD_REF_TYPE;
|
||||
};
|
||||
exports.isFragment = function (object) {
|
||||
return typeOf(object) === REACT_FRAGMENT_TYPE;
|
||||
};
|
||||
exports.isLazy = function (object) {
|
||||
return typeOf(object) === REACT_LAZY_TYPE;
|
||||
};
|
||||
exports.isMemo = function (object) {
|
||||
return typeOf(object) === REACT_MEMO_TYPE;
|
||||
};
|
||||
exports.isPortal = function (object) {
|
||||
return typeOf(object) === REACT_PORTAL_TYPE;
|
||||
};
|
||||
exports.isProfiler = function (object) {
|
||||
return typeOf(object) === REACT_PROFILER_TYPE;
|
||||
};
|
||||
exports.isStrictMode = function (object) {
|
||||
return typeOf(object) === REACT_STRICT_MODE_TYPE;
|
||||
};
|
||||
exports.isSuspense = function (object) {
|
||||
return typeOf(object) === REACT_SUSPENSE_TYPE;
|
||||
};
|
||||
exports.isSuspenseList = function (object) {
|
||||
return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
|
||||
};
|
||||
exports.isValidElementType = function (type) {
|
||||
return "string" === typeof type ||
|
||||
"function" === typeof type ||
|
||||
type === REACT_FRAGMENT_TYPE ||
|
||||
type === REACT_PROFILER_TYPE ||
|
||||
type === REACT_STRICT_MODE_TYPE ||
|
||||
type === REACT_SUSPENSE_TYPE ||
|
||||
type === REACT_SUSPENSE_LIST_TYPE ||
|
||||
type === REACT_OFFSCREEN_TYPE ||
|
||||
("object" === typeof type &&
|
||||
null !== type &&
|
||||
(type.$$typeof === REACT_LAZY_TYPE ||
|
||||
type.$$typeof === REACT_MEMO_TYPE ||
|
||||
type.$$typeof === REACT_CONTEXT_TYPE ||
|
||||
type.$$typeof === REACT_CONSUMER_TYPE ||
|
||||
type.$$typeof === REACT_FORWARD_REF_TYPE ||
|
||||
type.$$typeof === REACT_CLIENT_REFERENCE ||
|
||||
void 0 !== type.getModuleId))
|
||||
? !0
|
||||
: !1;
|
||||
};
|
||||
exports.typeOf = typeOf;
|
||||
+24360
File diff suppressed because it is too large
Load Diff
+9464
File diff suppressed because it is too large
Load Diff
+10107
File diff suppressed because it is too large
Load Diff
Vendored
+1513
File diff suppressed because it is too large
Load Diff
Vendored
+16
@@ -0,0 +1,16 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<548b04958213d77fe22adf99372702ad>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.jsxDEV = void 0;
|
||||
compiled-rn/facebook-fbsource/xplat/js/RKJSModules/vendor/react/react/cjs/JSXDEVRuntime-profiling.js
Vendored
+16
@@ -0,0 +1,16 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<548b04958213d77fe22adf99372702ad>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.jsxDEV = void 0;
|
||||
Vendored
+1541
File diff suppressed because it is too large
Load Diff
Vendored
+89
@@ -0,0 +1,89 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<33a22d7e025b0504577f8d6f9a29d73e>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var dynamicFlagsUntyped = require("ReactNativeInternalFeatureFlags"),
|
||||
React = require("react"),
|
||||
disableDefaultPropsExceptForClasses =
|
||||
dynamicFlagsUntyped.disableDefaultPropsExceptForClasses,
|
||||
REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
|
||||
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
|
||||
function formatProdErrorMessage(code) {
|
||||
var url = "https://react.dev/errors/" + code;
|
||||
if (1 < arguments.length) {
|
||||
url += "?args[]=" + encodeURIComponent(arguments[1]);
|
||||
for (var i = 2; i < arguments.length; i++)
|
||||
url += "&args[]=" + encodeURIComponent(arguments[i]);
|
||||
}
|
||||
return (
|
||||
"Minified React error #" +
|
||||
code +
|
||||
"; visit " +
|
||||
url +
|
||||
" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."
|
||||
);
|
||||
}
|
||||
var ReactSharedInternals =
|
||||
React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
|
||||
function getOwner() {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return null === dispatcher ? null : dispatcher.getOwner();
|
||||
}
|
||||
function jsxProd(type, config, maybeKey) {
|
||||
var key = null,
|
||||
ref = null;
|
||||
void 0 !== maybeKey && (key = "" + maybeKey);
|
||||
void 0 !== config.key && (key = "" + config.key);
|
||||
if (void 0 !== config.ref)
|
||||
a: {
|
||||
(ref = config.ref), (maybeKey = getOwner());
|
||||
if ("string" !== typeof ref)
|
||||
if ("number" === typeof ref || "boolean" === typeof ref) ref = "" + ref;
|
||||
else break a;
|
||||
var callback = stringRefAsCallbackRef.bind(null, ref, type, maybeKey);
|
||||
callback.__stringRef = ref;
|
||||
callback.__type = type;
|
||||
callback.__owner = maybeKey;
|
||||
ref = callback;
|
||||
}
|
||||
maybeKey = {};
|
||||
for (var propName in config)
|
||||
"key" !== propName &&
|
||||
"ref" !== propName &&
|
||||
(maybeKey[propName] = config[propName]);
|
||||
if (!disableDefaultPropsExceptForClasses && type && type.defaultProps) {
|
||||
config = type.defaultProps;
|
||||
for (var propName$0 in config)
|
||||
void 0 === maybeKey[propName$0] &&
|
||||
(maybeKey[propName$0] = config[propName$0]);
|
||||
}
|
||||
propName$0 = getOwner();
|
||||
return {
|
||||
$$typeof: REACT_LEGACY_ELEMENT_TYPE,
|
||||
type: type,
|
||||
key: key,
|
||||
ref: ref,
|
||||
props: maybeKey,
|
||||
_owner: propName$0
|
||||
};
|
||||
}
|
||||
function stringRefAsCallbackRef(stringRef, type, owner, value) {
|
||||
if (!owner) throw Error(formatProdErrorMessage(290, stringRef));
|
||||
if (1 !== owner.tag) throw Error(formatProdErrorMessage(309));
|
||||
type = owner.stateNode;
|
||||
if (!type) throw Error(formatProdErrorMessage(147, stringRef));
|
||||
type = type.refs;
|
||||
null === value ? delete type[stringRef] : (type[stringRef] = value);
|
||||
}
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.jsx = jsxProd;
|
||||
exports.jsxs = jsxProd;
|
||||
Vendored
+89
@@ -0,0 +1,89 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<33a22d7e025b0504577f8d6f9a29d73e>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var dynamicFlagsUntyped = require("ReactNativeInternalFeatureFlags"),
|
||||
React = require("react"),
|
||||
disableDefaultPropsExceptForClasses =
|
||||
dynamicFlagsUntyped.disableDefaultPropsExceptForClasses,
|
||||
REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
|
||||
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
|
||||
function formatProdErrorMessage(code) {
|
||||
var url = "https://react.dev/errors/" + code;
|
||||
if (1 < arguments.length) {
|
||||
url += "?args[]=" + encodeURIComponent(arguments[1]);
|
||||
for (var i = 2; i < arguments.length; i++)
|
||||
url += "&args[]=" + encodeURIComponent(arguments[i]);
|
||||
}
|
||||
return (
|
||||
"Minified React error #" +
|
||||
code +
|
||||
"; visit " +
|
||||
url +
|
||||
" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."
|
||||
);
|
||||
}
|
||||
var ReactSharedInternals =
|
||||
React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
|
||||
function getOwner() {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return null === dispatcher ? null : dispatcher.getOwner();
|
||||
}
|
||||
function jsxProd(type, config, maybeKey) {
|
||||
var key = null,
|
||||
ref = null;
|
||||
void 0 !== maybeKey && (key = "" + maybeKey);
|
||||
void 0 !== config.key && (key = "" + config.key);
|
||||
if (void 0 !== config.ref)
|
||||
a: {
|
||||
(ref = config.ref), (maybeKey = getOwner());
|
||||
if ("string" !== typeof ref)
|
||||
if ("number" === typeof ref || "boolean" === typeof ref) ref = "" + ref;
|
||||
else break a;
|
||||
var callback = stringRefAsCallbackRef.bind(null, ref, type, maybeKey);
|
||||
callback.__stringRef = ref;
|
||||
callback.__type = type;
|
||||
callback.__owner = maybeKey;
|
||||
ref = callback;
|
||||
}
|
||||
maybeKey = {};
|
||||
for (var propName in config)
|
||||
"key" !== propName &&
|
||||
"ref" !== propName &&
|
||||
(maybeKey[propName] = config[propName]);
|
||||
if (!disableDefaultPropsExceptForClasses && type && type.defaultProps) {
|
||||
config = type.defaultProps;
|
||||
for (var propName$0 in config)
|
||||
void 0 === maybeKey[propName$0] &&
|
||||
(maybeKey[propName$0] = config[propName$0]);
|
||||
}
|
||||
propName$0 = getOwner();
|
||||
return {
|
||||
$$typeof: REACT_LEGACY_ELEMENT_TYPE,
|
||||
type: type,
|
||||
key: key,
|
||||
ref: ref,
|
||||
props: maybeKey,
|
||||
_owner: propName$0
|
||||
};
|
||||
}
|
||||
function stringRefAsCallbackRef(stringRef, type, owner, value) {
|
||||
if (!owner) throw Error(formatProdErrorMessage(290, stringRef));
|
||||
if (1 !== owner.tag) throw Error(formatProdErrorMessage(309));
|
||||
type = owner.stateNode;
|
||||
if (!type) throw Error(formatProdErrorMessage(147, stringRef));
|
||||
type = type.refs;
|
||||
null === value ? delete type[stringRef] : (type[stringRef] = value);
|
||||
}
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.jsx = jsxProd;
|
||||
exports.jsxs = jsxProd;
|
||||
+3340
File diff suppressed because it is too large
Load Diff
+647
@@ -0,0 +1,647 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<9ea1237f908f176144eb5e942e6b346c>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var disableDefaultPropsExceptForClasses =
|
||||
require("ReactNativeInternalFeatureFlags").disableDefaultPropsExceptForClasses,
|
||||
REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
|
||||
REACT_PORTAL_TYPE = Symbol.for("react.portal"),
|
||||
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
|
||||
REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
|
||||
REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
|
||||
REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
|
||||
REACT_CONTEXT_TYPE = Symbol.for("react.context"),
|
||||
REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
|
||||
REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
|
||||
REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
|
||||
REACT_MEMO_TYPE = Symbol.for("react.memo"),
|
||||
REACT_LAZY_TYPE = Symbol.for("react.lazy"),
|
||||
REACT_SCOPE_TYPE = Symbol.for("react.scope"),
|
||||
REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for("react.debug_trace_mode"),
|
||||
REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
|
||||
REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"),
|
||||
REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker"),
|
||||
MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
|
||||
function getIteratorFn(maybeIterable) {
|
||||
if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
|
||||
maybeIterable =
|
||||
(MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
|
||||
maybeIterable["@@iterator"];
|
||||
return "function" === typeof maybeIterable ? maybeIterable : null;
|
||||
}
|
||||
var ReactNoopUpdateQueue = {
|
||||
isMounted: function () {
|
||||
return !1;
|
||||
},
|
||||
enqueueForceUpdate: function () {},
|
||||
enqueueReplaceState: function () {},
|
||||
enqueueSetState: function () {}
|
||||
},
|
||||
assign = Object.assign,
|
||||
emptyObject = {};
|
||||
function Component(props, context, updater) {
|
||||
this.props = props;
|
||||
this.context = context;
|
||||
this.refs = emptyObject;
|
||||
this.updater = updater || ReactNoopUpdateQueue;
|
||||
}
|
||||
Component.prototype.isReactComponent = {};
|
||||
Component.prototype.setState = function (partialState, callback) {
|
||||
if (
|
||||
"object" !== typeof partialState &&
|
||||
"function" !== typeof partialState &&
|
||||
null != partialState
|
||||
)
|
||||
throw Error(
|
||||
"takes an object of state variables to update or a function which returns an object of state variables."
|
||||
);
|
||||
this.updater.enqueueSetState(this, partialState, callback, "setState");
|
||||
};
|
||||
Component.prototype.forceUpdate = function (callback) {
|
||||
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
|
||||
};
|
||||
function ComponentDummy() {}
|
||||
ComponentDummy.prototype = Component.prototype;
|
||||
function PureComponent(props, context, updater) {
|
||||
this.props = props;
|
||||
this.context = context;
|
||||
this.refs = emptyObject;
|
||||
this.updater = updater || ReactNoopUpdateQueue;
|
||||
}
|
||||
var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());
|
||||
pureComponentPrototype.constructor = PureComponent;
|
||||
assign(pureComponentPrototype, Component.prototype);
|
||||
pureComponentPrototype.isPureReactComponent = !0;
|
||||
var isArrayImpl = Array.isArray,
|
||||
ReactSharedInternals = { H: null, A: null, T: null },
|
||||
hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
function getOwner() {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return null === dispatcher ? null : dispatcher.getOwner();
|
||||
}
|
||||
function ReactElement(type, key, _ref, self, source, owner, props) {
|
||||
return {
|
||||
$$typeof: REACT_LEGACY_ELEMENT_TYPE,
|
||||
type: type,
|
||||
key: key,
|
||||
ref: _ref,
|
||||
props: props,
|
||||
_owner: owner
|
||||
};
|
||||
}
|
||||
function jsxProd(type, config, maybeKey) {
|
||||
var key = null,
|
||||
ref = null;
|
||||
void 0 !== maybeKey && (key = "" + maybeKey);
|
||||
void 0 !== config.key && (key = "" + config.key);
|
||||
void 0 !== config.ref &&
|
||||
((ref = config.ref), (ref = coerceStringRef(ref, getOwner(), type)));
|
||||
maybeKey = {};
|
||||
for (var propName in config)
|
||||
"key" !== propName &&
|
||||
"ref" !== propName &&
|
||||
(maybeKey[propName] = config[propName]);
|
||||
if (!disableDefaultPropsExceptForClasses && type && type.defaultProps) {
|
||||
config = type.defaultProps;
|
||||
for (var propName$0 in config)
|
||||
void 0 === maybeKey[propName$0] &&
|
||||
(maybeKey[propName$0] = config[propName$0]);
|
||||
}
|
||||
return ReactElement(type, key, ref, void 0, void 0, getOwner(), maybeKey);
|
||||
}
|
||||
function cloneAndReplaceKey(oldElement, newKey) {
|
||||
return ReactElement(
|
||||
oldElement.type,
|
||||
newKey,
|
||||
oldElement.ref,
|
||||
void 0,
|
||||
void 0,
|
||||
oldElement._owner,
|
||||
oldElement.props
|
||||
);
|
||||
}
|
||||
function isValidElement(object) {
|
||||
return (
|
||||
"object" === typeof object &&
|
||||
null !== object &&
|
||||
object.$$typeof === REACT_LEGACY_ELEMENT_TYPE
|
||||
);
|
||||
}
|
||||
function coerceStringRef(mixedRef, owner, type) {
|
||||
if ("string" !== typeof mixedRef)
|
||||
if ("number" === typeof mixedRef || "boolean" === typeof mixedRef)
|
||||
mixedRef = "" + mixedRef;
|
||||
else return mixedRef;
|
||||
var callback = stringRefAsCallbackRef.bind(null, mixedRef, type, owner);
|
||||
callback.__stringRef = mixedRef;
|
||||
callback.__type = type;
|
||||
callback.__owner = owner;
|
||||
return callback;
|
||||
}
|
||||
function stringRefAsCallbackRef(stringRef, type, owner, value) {
|
||||
if (!owner)
|
||||
throw Error(
|
||||
"Element ref was specified as a string (" +
|
||||
stringRef +
|
||||
") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://react.dev/link/refs-must-have-owner for more information."
|
||||
);
|
||||
if (1 !== owner.tag)
|
||||
throw Error(
|
||||
"Function components cannot have string refs. We recommend using useRef() instead. Learn more about using refs safely here: https://react.dev/link/strict-mode-string-ref"
|
||||
);
|
||||
type = owner.stateNode;
|
||||
if (!type)
|
||||
throw Error(
|
||||
"Missing owner for string ref " +
|
||||
stringRef +
|
||||
". This error is likely caused by a bug in React. Please file an issue."
|
||||
);
|
||||
type = type.refs;
|
||||
null === value ? delete type[stringRef] : (type[stringRef] = value);
|
||||
}
|
||||
function escape(key) {
|
||||
var escaperLookup = { "=": "=0", ":": "=2" };
|
||||
return (
|
||||
"$" +
|
||||
key.replace(/[=:]/g, function (match) {
|
||||
return escaperLookup[match];
|
||||
})
|
||||
);
|
||||
}
|
||||
var userProvidedKeyEscapeRegex = /\/+/g;
|
||||
function getElementKey(element, index) {
|
||||
return "object" === typeof element && null !== element && null != element.key
|
||||
? escape("" + element.key)
|
||||
: index.toString(36);
|
||||
}
|
||||
function noop$1() {}
|
||||
function resolveThenable(thenable) {
|
||||
switch (thenable.status) {
|
||||
case "fulfilled":
|
||||
return thenable.value;
|
||||
case "rejected":
|
||||
throw thenable.reason;
|
||||
default:
|
||||
switch (
|
||||
("string" === typeof thenable.status
|
||||
? thenable.then(noop$1, noop$1)
|
||||
: ((thenable.status = "pending"),
|
||||
thenable.then(
|
||||
function (fulfilledValue) {
|
||||
"pending" === thenable.status &&
|
||||
((thenable.status = "fulfilled"),
|
||||
(thenable.value = fulfilledValue));
|
||||
},
|
||||
function (error) {
|
||||
"pending" === thenable.status &&
|
||||
((thenable.status = "rejected"), (thenable.reason = error));
|
||||
}
|
||||
)),
|
||||
thenable.status)
|
||||
) {
|
||||
case "fulfilled":
|
||||
return thenable.value;
|
||||
case "rejected":
|
||||
throw thenable.reason;
|
||||
}
|
||||
}
|
||||
throw thenable;
|
||||
}
|
||||
function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
|
||||
var type = typeof children;
|
||||
if ("undefined" === type || "boolean" === type) children = null;
|
||||
var invokeCallback = !1;
|
||||
if (null === children) invokeCallback = !0;
|
||||
else
|
||||
switch (type) {
|
||||
case "bigint":
|
||||
case "string":
|
||||
case "number":
|
||||
invokeCallback = !0;
|
||||
break;
|
||||
case "object":
|
||||
switch (children.$$typeof) {
|
||||
case REACT_LEGACY_ELEMENT_TYPE:
|
||||
case REACT_PORTAL_TYPE:
|
||||
invokeCallback = !0;
|
||||
break;
|
||||
case REACT_LAZY_TYPE:
|
||||
return (
|
||||
(invokeCallback = children._init),
|
||||
mapIntoArray(
|
||||
invokeCallback(children._payload),
|
||||
array,
|
||||
escapedPrefix,
|
||||
nameSoFar,
|
||||
callback
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
if (invokeCallback)
|
||||
return (
|
||||
(callback = callback(children)),
|
||||
(invokeCallback =
|
||||
"" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar),
|
||||
isArrayImpl(callback)
|
||||
? ((escapedPrefix = ""),
|
||||
null != invokeCallback &&
|
||||
(escapedPrefix =
|
||||
invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"),
|
||||
mapIntoArray(callback, array, escapedPrefix, "", function (c) {
|
||||
return c;
|
||||
}))
|
||||
: null != callback &&
|
||||
(isValidElement(callback) &&
|
||||
(callback = cloneAndReplaceKey(
|
||||
callback,
|
||||
escapedPrefix +
|
||||
(!callback.key || (children && children.key === callback.key)
|
||||
? ""
|
||||
: ("" + callback.key).replace(
|
||||
userProvidedKeyEscapeRegex,
|
||||
"$&/"
|
||||
) + "/") +
|
||||
invokeCallback
|
||||
)),
|
||||
array.push(callback)),
|
||||
1
|
||||
);
|
||||
invokeCallback = 0;
|
||||
var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
|
||||
if (isArrayImpl(children))
|
||||
for (var i = 0; i < children.length; i++)
|
||||
(nameSoFar = children[i]),
|
||||
(type = nextNamePrefix + getElementKey(nameSoFar, i)),
|
||||
(invokeCallback += mapIntoArray(
|
||||
nameSoFar,
|
||||
array,
|
||||
escapedPrefix,
|
||||
type,
|
||||
callback
|
||||
));
|
||||
else if (((i = getIteratorFn(children)), "function" === typeof i))
|
||||
for (
|
||||
children = i.call(children), i = 0;
|
||||
!(nameSoFar = children.next()).done;
|
||||
|
||||
)
|
||||
(nameSoFar = nameSoFar.value),
|
||||
(type = nextNamePrefix + getElementKey(nameSoFar, i++)),
|
||||
(invokeCallback += mapIntoArray(
|
||||
nameSoFar,
|
||||
array,
|
||||
escapedPrefix,
|
||||
type,
|
||||
callback
|
||||
));
|
||||
else if ("object" === type) {
|
||||
if ("function" === typeof children.then)
|
||||
return mapIntoArray(
|
||||
resolveThenable(children),
|
||||
array,
|
||||
escapedPrefix,
|
||||
nameSoFar,
|
||||
callback
|
||||
);
|
||||
array = String(children);
|
||||
throw Error(
|
||||
"Objects are not valid as a React child (found: " +
|
||||
("[object Object]" === array
|
||||
? "object with keys {" + Object.keys(children).join(", ") + "}"
|
||||
: array) +
|
||||
"). If you meant to render a collection of children, use an array instead."
|
||||
);
|
||||
}
|
||||
return invokeCallback;
|
||||
}
|
||||
function mapChildren(children, func, context) {
|
||||
if (null == children) return children;
|
||||
var result = [],
|
||||
count = 0;
|
||||
mapIntoArray(children, result, "", "", function (child) {
|
||||
return func.call(context, child, count++);
|
||||
});
|
||||
return result;
|
||||
}
|
||||
function lazyInitializer(payload) {
|
||||
if (-1 === payload._status) {
|
||||
var ctor = payload._result;
|
||||
ctor = ctor();
|
||||
ctor.then(
|
||||
function (moduleObject) {
|
||||
if (0 === payload._status || -1 === payload._status)
|
||||
(payload._status = 1), (payload._result = moduleObject);
|
||||
},
|
||||
function (error) {
|
||||
if (0 === payload._status || -1 === payload._status)
|
||||
(payload._status = 2), (payload._result = error);
|
||||
}
|
||||
);
|
||||
-1 === payload._status && ((payload._status = 0), (payload._result = ctor));
|
||||
}
|
||||
if (1 === payload._status) return payload._result.default;
|
||||
throw payload._result;
|
||||
}
|
||||
function useMemoCache(size) {
|
||||
return ReactSharedInternals.H.useMemoCache(size);
|
||||
}
|
||||
var reportGlobalError =
|
||||
"function" === typeof reportError
|
||||
? reportError
|
||||
: function (error) {
|
||||
if (
|
||||
"object" === typeof window &&
|
||||
"function" === typeof window.ErrorEvent
|
||||
) {
|
||||
var event = new window.ErrorEvent("error", {
|
||||
bubbles: !0,
|
||||
cancelable: !0,
|
||||
message:
|
||||
"object" === typeof error &&
|
||||
null !== error &&
|
||||
"string" === typeof error.message
|
||||
? String(error.message)
|
||||
: String(error),
|
||||
error: error
|
||||
});
|
||||
if (!window.dispatchEvent(event)) return;
|
||||
} else if (
|
||||
"object" === typeof process &&
|
||||
"function" === typeof process.emit
|
||||
) {
|
||||
process.emit("uncaughtException", error);
|
||||
return;
|
||||
}
|
||||
console.error(error);
|
||||
};
|
||||
function noop() {}
|
||||
exports.Children = {
|
||||
map: mapChildren,
|
||||
forEach: function (children, forEachFunc, forEachContext) {
|
||||
mapChildren(
|
||||
children,
|
||||
function () {
|
||||
forEachFunc.apply(this, arguments);
|
||||
},
|
||||
forEachContext
|
||||
);
|
||||
},
|
||||
count: function (children) {
|
||||
var n = 0;
|
||||
mapChildren(children, function () {
|
||||
n++;
|
||||
});
|
||||
return n;
|
||||
},
|
||||
toArray: function (children) {
|
||||
return (
|
||||
mapChildren(children, function (child) {
|
||||
return child;
|
||||
}) || []
|
||||
);
|
||||
},
|
||||
only: function (children) {
|
||||
if (!isValidElement(children))
|
||||
throw Error(
|
||||
"React.Children.only expected to receive a single React element child."
|
||||
);
|
||||
return children;
|
||||
}
|
||||
};
|
||||
exports.Component = Component;
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.Profiler = REACT_PROFILER_TYPE;
|
||||
exports.PureComponent = PureComponent;
|
||||
exports.StrictMode = REACT_STRICT_MODE_TYPE;
|
||||
exports.Suspense = REACT_SUSPENSE_TYPE;
|
||||
exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
|
||||
ReactSharedInternals;
|
||||
exports.act = function () {
|
||||
throw Error("act(...) is not supported in production builds of React.");
|
||||
};
|
||||
exports.c = useMemoCache;
|
||||
exports.cache = function (fn) {
|
||||
return function () {
|
||||
return fn.apply(null, arguments);
|
||||
};
|
||||
};
|
||||
exports.cloneElement = function (element, config, children) {
|
||||
if (null === element || void 0 === element)
|
||||
throw Error(
|
||||
"The argument must be a React element, but you passed " + element + "."
|
||||
);
|
||||
var props = assign({}, element.props),
|
||||
key = element.key,
|
||||
ref = element.ref,
|
||||
owner = element._owner;
|
||||
if (null != config) {
|
||||
void 0 !== config.ref &&
|
||||
((owner = getOwner()),
|
||||
(ref = config.ref),
|
||||
(ref = coerceStringRef(ref, owner, element.type)));
|
||||
void 0 !== config.key && (key = "" + config.key);
|
||||
if (
|
||||
!disableDefaultPropsExceptForClasses &&
|
||||
element.type &&
|
||||
element.type.defaultProps
|
||||
)
|
||||
var defaultProps = element.type.defaultProps;
|
||||
for (propName in config)
|
||||
hasOwnProperty.call(config, propName) &&
|
||||
"key" !== propName &&
|
||||
"ref" !== propName &&
|
||||
"__self" !== propName &&
|
||||
"__source" !== propName &&
|
||||
(props[propName] =
|
||||
disableDefaultPropsExceptForClasses ||
|
||||
void 0 !== config[propName] ||
|
||||
void 0 === defaultProps
|
||||
? config[propName]
|
||||
: defaultProps[propName]);
|
||||
}
|
||||
var propName = arguments.length - 2;
|
||||
if (1 === propName) props.children = children;
|
||||
else if (1 < propName) {
|
||||
defaultProps = Array(propName);
|
||||
for (var i = 0; i < propName; i++) defaultProps[i] = arguments[i + 2];
|
||||
props.children = defaultProps;
|
||||
}
|
||||
return ReactElement(element.type, key, ref, void 0, void 0, owner, props);
|
||||
};
|
||||
exports.createContext = function (defaultValue) {
|
||||
defaultValue = {
|
||||
$$typeof: REACT_CONTEXT_TYPE,
|
||||
_currentValue: defaultValue,
|
||||
_currentValue2: defaultValue,
|
||||
_threadCount: 0,
|
||||
Provider: null,
|
||||
Consumer: null
|
||||
};
|
||||
defaultValue.Provider = defaultValue;
|
||||
defaultValue.Consumer = {
|
||||
$$typeof: REACT_CONSUMER_TYPE,
|
||||
_context: defaultValue
|
||||
};
|
||||
return defaultValue;
|
||||
};
|
||||
exports.createElement = function (type, config, children) {
|
||||
var propName,
|
||||
props = {},
|
||||
key = null,
|
||||
ref = null;
|
||||
if (null != config)
|
||||
for (propName in (void 0 !== config.ref &&
|
||||
((ref = config.ref), (ref = coerceStringRef(ref, getOwner(), type))),
|
||||
void 0 !== config.key && (key = "" + config.key),
|
||||
config))
|
||||
hasOwnProperty.call(config, propName) &&
|
||||
"key" !== propName &&
|
||||
"ref" !== propName &&
|
||||
"__self" !== propName &&
|
||||
"__source" !== propName &&
|
||||
(props[propName] = config[propName]);
|
||||
var childrenLength = arguments.length - 2;
|
||||
if (1 === childrenLength) props.children = children;
|
||||
else if (1 < childrenLength) {
|
||||
for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
|
||||
childArray[i] = arguments[i + 2];
|
||||
props.children = childArray;
|
||||
}
|
||||
if (type && type.defaultProps)
|
||||
for (propName in ((childrenLength = type.defaultProps), childrenLength))
|
||||
void 0 === props[propName] &&
|
||||
(props[propName] = childrenLength[propName]);
|
||||
return ReactElement(type, key, ref, void 0, void 0, getOwner(), props);
|
||||
};
|
||||
exports.createRef = function () {
|
||||
return { current: null };
|
||||
};
|
||||
exports.experimental_useEffectEvent = function (callback) {
|
||||
return ReactSharedInternals.H.useEffectEvent(callback);
|
||||
};
|
||||
exports.forwardRef = function (render) {
|
||||
return { $$typeof: REACT_FORWARD_REF_TYPE, render: render };
|
||||
};
|
||||
exports.isValidElement = isValidElement;
|
||||
exports.jsx = jsxProd;
|
||||
exports.jsxDEV = void 0;
|
||||
exports.jsxs = jsxProd;
|
||||
exports.lazy = function (ctor) {
|
||||
return {
|
||||
$$typeof: REACT_LAZY_TYPE,
|
||||
_payload: { _status: -1, _result: ctor },
|
||||
_init: lazyInitializer
|
||||
};
|
||||
};
|
||||
exports.memo = function (type, compare) {
|
||||
return {
|
||||
$$typeof: REACT_MEMO_TYPE,
|
||||
type: type,
|
||||
compare: void 0 === compare ? null : compare
|
||||
};
|
||||
};
|
||||
exports.startTransition = function (scope) {
|
||||
var prevTransition = ReactSharedInternals.T,
|
||||
callbacks = new Set();
|
||||
ReactSharedInternals.T = { _callbacks: callbacks };
|
||||
var currentTransition = ReactSharedInternals.T;
|
||||
try {
|
||||
var returnValue = scope();
|
||||
"object" === typeof returnValue &&
|
||||
null !== returnValue &&
|
||||
"function" === typeof returnValue.then &&
|
||||
(callbacks.forEach(function (callback) {
|
||||
return callback(currentTransition, returnValue);
|
||||
}),
|
||||
returnValue.then(noop, reportGlobalError));
|
||||
} catch (error) {
|
||||
reportGlobalError(error);
|
||||
} finally {
|
||||
ReactSharedInternals.T = prevTransition;
|
||||
}
|
||||
};
|
||||
exports.unstable_Activity = REACT_OFFSCREEN_TYPE;
|
||||
exports.unstable_DebugTracingMode = REACT_DEBUG_TRACING_MODE_TYPE;
|
||||
exports.unstable_LegacyHidden = REACT_LEGACY_HIDDEN_TYPE;
|
||||
exports.unstable_Scope = REACT_SCOPE_TYPE;
|
||||
exports.unstable_SuspenseList = REACT_SUSPENSE_LIST_TYPE;
|
||||
exports.unstable_TracingMarker = REACT_TRACING_MARKER_TYPE;
|
||||
exports.unstable_getCacheForType = function (resourceType) {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return dispatcher ? dispatcher.getCacheForType(resourceType) : resourceType();
|
||||
};
|
||||
exports.unstable_useCacheRefresh = function () {
|
||||
return ReactSharedInternals.H.useCacheRefresh();
|
||||
};
|
||||
exports.unstable_useMemoCache = useMemoCache;
|
||||
exports.use = function (usable) {
|
||||
return ReactSharedInternals.H.use(usable);
|
||||
};
|
||||
exports.useActionState = function (action, initialState, permalink) {
|
||||
return ReactSharedInternals.H.useActionState(action, initialState, permalink);
|
||||
};
|
||||
exports.useCallback = function (callback, deps) {
|
||||
return ReactSharedInternals.H.useCallback(callback, deps);
|
||||
};
|
||||
exports.useContext = function (Context) {
|
||||
return ReactSharedInternals.H.useContext(Context);
|
||||
};
|
||||
exports.useDebugValue = function () {};
|
||||
exports.useDeferredValue = function (value, initialValue) {
|
||||
return ReactSharedInternals.H.useDeferredValue(value, initialValue);
|
||||
};
|
||||
exports.useEffect = function (create, deps) {
|
||||
return ReactSharedInternals.H.useEffect(create, deps);
|
||||
};
|
||||
exports.useId = function () {
|
||||
return ReactSharedInternals.H.useId();
|
||||
};
|
||||
exports.useImperativeHandle = function (ref, create, deps) {
|
||||
return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
|
||||
};
|
||||
exports.useInsertionEffect = function (create, deps) {
|
||||
return ReactSharedInternals.H.useInsertionEffect(create, deps);
|
||||
};
|
||||
exports.useLayoutEffect = function (create, deps) {
|
||||
return ReactSharedInternals.H.useLayoutEffect(create, deps);
|
||||
};
|
||||
exports.useMemo = function (create, deps) {
|
||||
return ReactSharedInternals.H.useMemo(create, deps);
|
||||
};
|
||||
exports.useOptimistic = function (passthrough, reducer) {
|
||||
return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
|
||||
};
|
||||
exports.useReducer = function (reducer, initialArg, init) {
|
||||
return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
|
||||
};
|
||||
exports.useRef = function (initialValue) {
|
||||
return ReactSharedInternals.H.useRef(initialValue);
|
||||
};
|
||||
exports.useState = function (initialState) {
|
||||
return ReactSharedInternals.H.useState(initialState);
|
||||
};
|
||||
exports.useSyncExternalStore = function (
|
||||
subscribe,
|
||||
getSnapshot,
|
||||
getServerSnapshot
|
||||
) {
|
||||
return ReactSharedInternals.H.useSyncExternalStore(
|
||||
subscribe,
|
||||
getSnapshot,
|
||||
getServerSnapshot
|
||||
);
|
||||
};
|
||||
exports.useTransition = function () {
|
||||
return ReactSharedInternals.H.useTransition();
|
||||
};
|
||||
exports.version = "19.0.0-beta-d06e1498";
|
||||
Vendored
+655
@@ -0,0 +1,655 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<781e1307597af2cfaf5c8e440f586e5b>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
|
||||
"function" ===
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
|
||||
var disableDefaultPropsExceptForClasses =
|
||||
require("ReactNativeInternalFeatureFlags").disableDefaultPropsExceptForClasses,
|
||||
REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"),
|
||||
REACT_PORTAL_TYPE = Symbol.for("react.portal"),
|
||||
REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
|
||||
REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
|
||||
REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
|
||||
REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
|
||||
REACT_CONTEXT_TYPE = Symbol.for("react.context"),
|
||||
REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
|
||||
REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
|
||||
REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
|
||||
REACT_MEMO_TYPE = Symbol.for("react.memo"),
|
||||
REACT_LAZY_TYPE = Symbol.for("react.lazy"),
|
||||
REACT_SCOPE_TYPE = Symbol.for("react.scope"),
|
||||
REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for("react.debug_trace_mode"),
|
||||
REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
|
||||
REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"),
|
||||
REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker"),
|
||||
MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
|
||||
function getIteratorFn(maybeIterable) {
|
||||
if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
|
||||
maybeIterable =
|
||||
(MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
|
||||
maybeIterable["@@iterator"];
|
||||
return "function" === typeof maybeIterable ? maybeIterable : null;
|
||||
}
|
||||
var ReactNoopUpdateQueue = {
|
||||
isMounted: function () {
|
||||
return !1;
|
||||
},
|
||||
enqueueForceUpdate: function () {},
|
||||
enqueueReplaceState: function () {},
|
||||
enqueueSetState: function () {}
|
||||
},
|
||||
assign = Object.assign,
|
||||
emptyObject = {};
|
||||
function Component(props, context, updater) {
|
||||
this.props = props;
|
||||
this.context = context;
|
||||
this.refs = emptyObject;
|
||||
this.updater = updater || ReactNoopUpdateQueue;
|
||||
}
|
||||
Component.prototype.isReactComponent = {};
|
||||
Component.prototype.setState = function (partialState, callback) {
|
||||
if (
|
||||
"object" !== typeof partialState &&
|
||||
"function" !== typeof partialState &&
|
||||
null != partialState
|
||||
)
|
||||
throw Error(
|
||||
"takes an object of state variables to update or a function which returns an object of state variables."
|
||||
);
|
||||
this.updater.enqueueSetState(this, partialState, callback, "setState");
|
||||
};
|
||||
Component.prototype.forceUpdate = function (callback) {
|
||||
this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
|
||||
};
|
||||
function ComponentDummy() {}
|
||||
ComponentDummy.prototype = Component.prototype;
|
||||
function PureComponent(props, context, updater) {
|
||||
this.props = props;
|
||||
this.context = context;
|
||||
this.refs = emptyObject;
|
||||
this.updater = updater || ReactNoopUpdateQueue;
|
||||
}
|
||||
var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());
|
||||
pureComponentPrototype.constructor = PureComponent;
|
||||
assign(pureComponentPrototype, Component.prototype);
|
||||
pureComponentPrototype.isPureReactComponent = !0;
|
||||
var isArrayImpl = Array.isArray,
|
||||
ReactSharedInternals = { H: null, A: null, T: null },
|
||||
hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||
function getOwner() {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return null === dispatcher ? null : dispatcher.getOwner();
|
||||
}
|
||||
function ReactElement(type, key, _ref, self, source, owner, props) {
|
||||
return {
|
||||
$$typeof: REACT_LEGACY_ELEMENT_TYPE,
|
||||
type: type,
|
||||
key: key,
|
||||
ref: _ref,
|
||||
props: props,
|
||||
_owner: owner
|
||||
};
|
||||
}
|
||||
function jsxProd(type, config, maybeKey) {
|
||||
var key = null,
|
||||
ref = null;
|
||||
void 0 !== maybeKey && (key = "" + maybeKey);
|
||||
void 0 !== config.key && (key = "" + config.key);
|
||||
void 0 !== config.ref &&
|
||||
((ref = config.ref), (ref = coerceStringRef(ref, getOwner(), type)));
|
||||
maybeKey = {};
|
||||
for (var propName in config)
|
||||
"key" !== propName &&
|
||||
"ref" !== propName &&
|
||||
(maybeKey[propName] = config[propName]);
|
||||
if (!disableDefaultPropsExceptForClasses && type && type.defaultProps) {
|
||||
config = type.defaultProps;
|
||||
for (var propName$0 in config)
|
||||
void 0 === maybeKey[propName$0] &&
|
||||
(maybeKey[propName$0] = config[propName$0]);
|
||||
}
|
||||
return ReactElement(type, key, ref, void 0, void 0, getOwner(), maybeKey);
|
||||
}
|
||||
function cloneAndReplaceKey(oldElement, newKey) {
|
||||
return ReactElement(
|
||||
oldElement.type,
|
||||
newKey,
|
||||
oldElement.ref,
|
||||
void 0,
|
||||
void 0,
|
||||
oldElement._owner,
|
||||
oldElement.props
|
||||
);
|
||||
}
|
||||
function isValidElement(object) {
|
||||
return (
|
||||
"object" === typeof object &&
|
||||
null !== object &&
|
||||
object.$$typeof === REACT_LEGACY_ELEMENT_TYPE
|
||||
);
|
||||
}
|
||||
function coerceStringRef(mixedRef, owner, type) {
|
||||
if ("string" !== typeof mixedRef)
|
||||
if ("number" === typeof mixedRef || "boolean" === typeof mixedRef)
|
||||
mixedRef = "" + mixedRef;
|
||||
else return mixedRef;
|
||||
var callback = stringRefAsCallbackRef.bind(null, mixedRef, type, owner);
|
||||
callback.__stringRef = mixedRef;
|
||||
callback.__type = type;
|
||||
callback.__owner = owner;
|
||||
return callback;
|
||||
}
|
||||
function stringRefAsCallbackRef(stringRef, type, owner, value) {
|
||||
if (!owner)
|
||||
throw Error(
|
||||
"Element ref was specified as a string (" +
|
||||
stringRef +
|
||||
") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://react.dev/link/refs-must-have-owner for more information."
|
||||
);
|
||||
if (1 !== owner.tag)
|
||||
throw Error(
|
||||
"Function components cannot have string refs. We recommend using useRef() instead. Learn more about using refs safely here: https://react.dev/link/strict-mode-string-ref"
|
||||
);
|
||||
type = owner.stateNode;
|
||||
if (!type)
|
||||
throw Error(
|
||||
"Missing owner for string ref " +
|
||||
stringRef +
|
||||
". This error is likely caused by a bug in React. Please file an issue."
|
||||
);
|
||||
type = type.refs;
|
||||
null === value ? delete type[stringRef] : (type[stringRef] = value);
|
||||
}
|
||||
function escape(key) {
|
||||
var escaperLookup = { "=": "=0", ":": "=2" };
|
||||
return (
|
||||
"$" +
|
||||
key.replace(/[=:]/g, function (match) {
|
||||
return escaperLookup[match];
|
||||
})
|
||||
);
|
||||
}
|
||||
var userProvidedKeyEscapeRegex = /\/+/g;
|
||||
function getElementKey(element, index) {
|
||||
return "object" === typeof element && null !== element && null != element.key
|
||||
? escape("" + element.key)
|
||||
: index.toString(36);
|
||||
}
|
||||
function noop$1() {}
|
||||
function resolveThenable(thenable) {
|
||||
switch (thenable.status) {
|
||||
case "fulfilled":
|
||||
return thenable.value;
|
||||
case "rejected":
|
||||
throw thenable.reason;
|
||||
default:
|
||||
switch (
|
||||
("string" === typeof thenable.status
|
||||
? thenable.then(noop$1, noop$1)
|
||||
: ((thenable.status = "pending"),
|
||||
thenable.then(
|
||||
function (fulfilledValue) {
|
||||
"pending" === thenable.status &&
|
||||
((thenable.status = "fulfilled"),
|
||||
(thenable.value = fulfilledValue));
|
||||
},
|
||||
function (error) {
|
||||
"pending" === thenable.status &&
|
||||
((thenable.status = "rejected"), (thenable.reason = error));
|
||||
}
|
||||
)),
|
||||
thenable.status)
|
||||
) {
|
||||
case "fulfilled":
|
||||
return thenable.value;
|
||||
case "rejected":
|
||||
throw thenable.reason;
|
||||
}
|
||||
}
|
||||
throw thenable;
|
||||
}
|
||||
function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
|
||||
var type = typeof children;
|
||||
if ("undefined" === type || "boolean" === type) children = null;
|
||||
var invokeCallback = !1;
|
||||
if (null === children) invokeCallback = !0;
|
||||
else
|
||||
switch (type) {
|
||||
case "bigint":
|
||||
case "string":
|
||||
case "number":
|
||||
invokeCallback = !0;
|
||||
break;
|
||||
case "object":
|
||||
switch (children.$$typeof) {
|
||||
case REACT_LEGACY_ELEMENT_TYPE:
|
||||
case REACT_PORTAL_TYPE:
|
||||
invokeCallback = !0;
|
||||
break;
|
||||
case REACT_LAZY_TYPE:
|
||||
return (
|
||||
(invokeCallback = children._init),
|
||||
mapIntoArray(
|
||||
invokeCallback(children._payload),
|
||||
array,
|
||||
escapedPrefix,
|
||||
nameSoFar,
|
||||
callback
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
if (invokeCallback)
|
||||
return (
|
||||
(callback = callback(children)),
|
||||
(invokeCallback =
|
||||
"" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar),
|
||||
isArrayImpl(callback)
|
||||
? ((escapedPrefix = ""),
|
||||
null != invokeCallback &&
|
||||
(escapedPrefix =
|
||||
invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"),
|
||||
mapIntoArray(callback, array, escapedPrefix, "", function (c) {
|
||||
return c;
|
||||
}))
|
||||
: null != callback &&
|
||||
(isValidElement(callback) &&
|
||||
(callback = cloneAndReplaceKey(
|
||||
callback,
|
||||
escapedPrefix +
|
||||
(!callback.key || (children && children.key === callback.key)
|
||||
? ""
|
||||
: ("" + callback.key).replace(
|
||||
userProvidedKeyEscapeRegex,
|
||||
"$&/"
|
||||
) + "/") +
|
||||
invokeCallback
|
||||
)),
|
||||
array.push(callback)),
|
||||
1
|
||||
);
|
||||
invokeCallback = 0;
|
||||
var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
|
||||
if (isArrayImpl(children))
|
||||
for (var i = 0; i < children.length; i++)
|
||||
(nameSoFar = children[i]),
|
||||
(type = nextNamePrefix + getElementKey(nameSoFar, i)),
|
||||
(invokeCallback += mapIntoArray(
|
||||
nameSoFar,
|
||||
array,
|
||||
escapedPrefix,
|
||||
type,
|
||||
callback
|
||||
));
|
||||
else if (((i = getIteratorFn(children)), "function" === typeof i))
|
||||
for (
|
||||
children = i.call(children), i = 0;
|
||||
!(nameSoFar = children.next()).done;
|
||||
|
||||
)
|
||||
(nameSoFar = nameSoFar.value),
|
||||
(type = nextNamePrefix + getElementKey(nameSoFar, i++)),
|
||||
(invokeCallback += mapIntoArray(
|
||||
nameSoFar,
|
||||
array,
|
||||
escapedPrefix,
|
||||
type,
|
||||
callback
|
||||
));
|
||||
else if ("object" === type) {
|
||||
if ("function" === typeof children.then)
|
||||
return mapIntoArray(
|
||||
resolveThenable(children),
|
||||
array,
|
||||
escapedPrefix,
|
||||
nameSoFar,
|
||||
callback
|
||||
);
|
||||
array = String(children);
|
||||
throw Error(
|
||||
"Objects are not valid as a React child (found: " +
|
||||
("[object Object]" === array
|
||||
? "object with keys {" + Object.keys(children).join(", ") + "}"
|
||||
: array) +
|
||||
"). If you meant to render a collection of children, use an array instead."
|
||||
);
|
||||
}
|
||||
return invokeCallback;
|
||||
}
|
||||
function mapChildren(children, func, context) {
|
||||
if (null == children) return children;
|
||||
var result = [],
|
||||
count = 0;
|
||||
mapIntoArray(children, result, "", "", function (child) {
|
||||
return func.call(context, child, count++);
|
||||
});
|
||||
return result;
|
||||
}
|
||||
function lazyInitializer(payload) {
|
||||
if (-1 === payload._status) {
|
||||
var ctor = payload._result;
|
||||
ctor = ctor();
|
||||
ctor.then(
|
||||
function (moduleObject) {
|
||||
if (0 === payload._status || -1 === payload._status)
|
||||
(payload._status = 1), (payload._result = moduleObject);
|
||||
},
|
||||
function (error) {
|
||||
if (0 === payload._status || -1 === payload._status)
|
||||
(payload._status = 2), (payload._result = error);
|
||||
}
|
||||
);
|
||||
-1 === payload._status && ((payload._status = 0), (payload._result = ctor));
|
||||
}
|
||||
if (1 === payload._status) return payload._result.default;
|
||||
throw payload._result;
|
||||
}
|
||||
function useMemoCache(size) {
|
||||
return ReactSharedInternals.H.useMemoCache(size);
|
||||
}
|
||||
var reportGlobalError =
|
||||
"function" === typeof reportError
|
||||
? reportError
|
||||
: function (error) {
|
||||
if (
|
||||
"object" === typeof window &&
|
||||
"function" === typeof window.ErrorEvent
|
||||
) {
|
||||
var event = new window.ErrorEvent("error", {
|
||||
bubbles: !0,
|
||||
cancelable: !0,
|
||||
message:
|
||||
"object" === typeof error &&
|
||||
null !== error &&
|
||||
"string" === typeof error.message
|
||||
? String(error.message)
|
||||
: String(error),
|
||||
error: error
|
||||
});
|
||||
if (!window.dispatchEvent(event)) return;
|
||||
} else if (
|
||||
"object" === typeof process &&
|
||||
"function" === typeof process.emit
|
||||
) {
|
||||
process.emit("uncaughtException", error);
|
||||
return;
|
||||
}
|
||||
console.error(error);
|
||||
};
|
||||
function noop() {}
|
||||
exports.Children = {
|
||||
map: mapChildren,
|
||||
forEach: function (children, forEachFunc, forEachContext) {
|
||||
mapChildren(
|
||||
children,
|
||||
function () {
|
||||
forEachFunc.apply(this, arguments);
|
||||
},
|
||||
forEachContext
|
||||
);
|
||||
},
|
||||
count: function (children) {
|
||||
var n = 0;
|
||||
mapChildren(children, function () {
|
||||
n++;
|
||||
});
|
||||
return n;
|
||||
},
|
||||
toArray: function (children) {
|
||||
return (
|
||||
mapChildren(children, function (child) {
|
||||
return child;
|
||||
}) || []
|
||||
);
|
||||
},
|
||||
only: function (children) {
|
||||
if (!isValidElement(children))
|
||||
throw Error(
|
||||
"React.Children.only expected to receive a single React element child."
|
||||
);
|
||||
return children;
|
||||
}
|
||||
};
|
||||
exports.Component = Component;
|
||||
exports.Fragment = REACT_FRAGMENT_TYPE;
|
||||
exports.Profiler = REACT_PROFILER_TYPE;
|
||||
exports.PureComponent = PureComponent;
|
||||
exports.StrictMode = REACT_STRICT_MODE_TYPE;
|
||||
exports.Suspense = REACT_SUSPENSE_TYPE;
|
||||
exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
|
||||
ReactSharedInternals;
|
||||
exports.act = function () {
|
||||
throw Error("act(...) is not supported in production builds of React.");
|
||||
};
|
||||
exports.c = useMemoCache;
|
||||
exports.cache = function (fn) {
|
||||
return function () {
|
||||
return fn.apply(null, arguments);
|
||||
};
|
||||
};
|
||||
exports.cloneElement = function (element, config, children) {
|
||||
if (null === element || void 0 === element)
|
||||
throw Error(
|
||||
"The argument must be a React element, but you passed " + element + "."
|
||||
);
|
||||
var props = assign({}, element.props),
|
||||
key = element.key,
|
||||
ref = element.ref,
|
||||
owner = element._owner;
|
||||
if (null != config) {
|
||||
void 0 !== config.ref &&
|
||||
((owner = getOwner()),
|
||||
(ref = config.ref),
|
||||
(ref = coerceStringRef(ref, owner, element.type)));
|
||||
void 0 !== config.key && (key = "" + config.key);
|
||||
if (
|
||||
!disableDefaultPropsExceptForClasses &&
|
||||
element.type &&
|
||||
element.type.defaultProps
|
||||
)
|
||||
var defaultProps = element.type.defaultProps;
|
||||
for (propName in config)
|
||||
hasOwnProperty.call(config, propName) &&
|
||||
"key" !== propName &&
|
||||
"ref" !== propName &&
|
||||
"__self" !== propName &&
|
||||
"__source" !== propName &&
|
||||
(props[propName] =
|
||||
disableDefaultPropsExceptForClasses ||
|
||||
void 0 !== config[propName] ||
|
||||
void 0 === defaultProps
|
||||
? config[propName]
|
||||
: defaultProps[propName]);
|
||||
}
|
||||
var propName = arguments.length - 2;
|
||||
if (1 === propName) props.children = children;
|
||||
else if (1 < propName) {
|
||||
defaultProps = Array(propName);
|
||||
for (var i = 0; i < propName; i++) defaultProps[i] = arguments[i + 2];
|
||||
props.children = defaultProps;
|
||||
}
|
||||
return ReactElement(element.type, key, ref, void 0, void 0, owner, props);
|
||||
};
|
||||
exports.createContext = function (defaultValue) {
|
||||
defaultValue = {
|
||||
$$typeof: REACT_CONTEXT_TYPE,
|
||||
_currentValue: defaultValue,
|
||||
_currentValue2: defaultValue,
|
||||
_threadCount: 0,
|
||||
Provider: null,
|
||||
Consumer: null
|
||||
};
|
||||
defaultValue.Provider = defaultValue;
|
||||
defaultValue.Consumer = {
|
||||
$$typeof: REACT_CONSUMER_TYPE,
|
||||
_context: defaultValue
|
||||
};
|
||||
return defaultValue;
|
||||
};
|
||||
exports.createElement = function (type, config, children) {
|
||||
var propName,
|
||||
props = {},
|
||||
key = null,
|
||||
ref = null;
|
||||
if (null != config)
|
||||
for (propName in (void 0 !== config.ref &&
|
||||
((ref = config.ref), (ref = coerceStringRef(ref, getOwner(), type))),
|
||||
void 0 !== config.key && (key = "" + config.key),
|
||||
config))
|
||||
hasOwnProperty.call(config, propName) &&
|
||||
"key" !== propName &&
|
||||
"ref" !== propName &&
|
||||
"__self" !== propName &&
|
||||
"__source" !== propName &&
|
||||
(props[propName] = config[propName]);
|
||||
var childrenLength = arguments.length - 2;
|
||||
if (1 === childrenLength) props.children = children;
|
||||
else if (1 < childrenLength) {
|
||||
for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
|
||||
childArray[i] = arguments[i + 2];
|
||||
props.children = childArray;
|
||||
}
|
||||
if (type && type.defaultProps)
|
||||
for (propName in ((childrenLength = type.defaultProps), childrenLength))
|
||||
void 0 === props[propName] &&
|
||||
(props[propName] = childrenLength[propName]);
|
||||
return ReactElement(type, key, ref, void 0, void 0, getOwner(), props);
|
||||
};
|
||||
exports.createRef = function () {
|
||||
return { current: null };
|
||||
};
|
||||
exports.experimental_useEffectEvent = function (callback) {
|
||||
return ReactSharedInternals.H.useEffectEvent(callback);
|
||||
};
|
||||
exports.forwardRef = function (render) {
|
||||
return { $$typeof: REACT_FORWARD_REF_TYPE, render: render };
|
||||
};
|
||||
exports.isValidElement = isValidElement;
|
||||
exports.jsx = jsxProd;
|
||||
exports.jsxDEV = void 0;
|
||||
exports.jsxs = jsxProd;
|
||||
exports.lazy = function (ctor) {
|
||||
return {
|
||||
$$typeof: REACT_LAZY_TYPE,
|
||||
_payload: { _status: -1, _result: ctor },
|
||||
_init: lazyInitializer
|
||||
};
|
||||
};
|
||||
exports.memo = function (type, compare) {
|
||||
return {
|
||||
$$typeof: REACT_MEMO_TYPE,
|
||||
type: type,
|
||||
compare: void 0 === compare ? null : compare
|
||||
};
|
||||
};
|
||||
exports.startTransition = function (scope) {
|
||||
var prevTransition = ReactSharedInternals.T,
|
||||
callbacks = new Set();
|
||||
ReactSharedInternals.T = { _callbacks: callbacks };
|
||||
var currentTransition = ReactSharedInternals.T;
|
||||
try {
|
||||
var returnValue = scope();
|
||||
"object" === typeof returnValue &&
|
||||
null !== returnValue &&
|
||||
"function" === typeof returnValue.then &&
|
||||
(callbacks.forEach(function (callback) {
|
||||
return callback(currentTransition, returnValue);
|
||||
}),
|
||||
returnValue.then(noop, reportGlobalError));
|
||||
} catch (error) {
|
||||
reportGlobalError(error);
|
||||
} finally {
|
||||
ReactSharedInternals.T = prevTransition;
|
||||
}
|
||||
};
|
||||
exports.unstable_Activity = REACT_OFFSCREEN_TYPE;
|
||||
exports.unstable_DebugTracingMode = REACT_DEBUG_TRACING_MODE_TYPE;
|
||||
exports.unstable_LegacyHidden = REACT_LEGACY_HIDDEN_TYPE;
|
||||
exports.unstable_Scope = REACT_SCOPE_TYPE;
|
||||
exports.unstable_SuspenseList = REACT_SUSPENSE_LIST_TYPE;
|
||||
exports.unstable_TracingMarker = REACT_TRACING_MARKER_TYPE;
|
||||
exports.unstable_getCacheForType = function (resourceType) {
|
||||
var dispatcher = ReactSharedInternals.A;
|
||||
return dispatcher ? dispatcher.getCacheForType(resourceType) : resourceType();
|
||||
};
|
||||
exports.unstable_useCacheRefresh = function () {
|
||||
return ReactSharedInternals.H.useCacheRefresh();
|
||||
};
|
||||
exports.unstable_useMemoCache = useMemoCache;
|
||||
exports.use = function (usable) {
|
||||
return ReactSharedInternals.H.use(usable);
|
||||
};
|
||||
exports.useActionState = function (action, initialState, permalink) {
|
||||
return ReactSharedInternals.H.useActionState(action, initialState, permalink);
|
||||
};
|
||||
exports.useCallback = function (callback, deps) {
|
||||
return ReactSharedInternals.H.useCallback(callback, deps);
|
||||
};
|
||||
exports.useContext = function (Context) {
|
||||
return ReactSharedInternals.H.useContext(Context);
|
||||
};
|
||||
exports.useDebugValue = function () {};
|
||||
exports.useDeferredValue = function (value, initialValue) {
|
||||
return ReactSharedInternals.H.useDeferredValue(value, initialValue);
|
||||
};
|
||||
exports.useEffect = function (create, deps) {
|
||||
return ReactSharedInternals.H.useEffect(create, deps);
|
||||
};
|
||||
exports.useId = function () {
|
||||
return ReactSharedInternals.H.useId();
|
||||
};
|
||||
exports.useImperativeHandle = function (ref, create, deps) {
|
||||
return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
|
||||
};
|
||||
exports.useInsertionEffect = function (create, deps) {
|
||||
return ReactSharedInternals.H.useInsertionEffect(create, deps);
|
||||
};
|
||||
exports.useLayoutEffect = function (create, deps) {
|
||||
return ReactSharedInternals.H.useLayoutEffect(create, deps);
|
||||
};
|
||||
exports.useMemo = function (create, deps) {
|
||||
return ReactSharedInternals.H.useMemo(create, deps);
|
||||
};
|
||||
exports.useOptimistic = function (passthrough, reducer) {
|
||||
return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
|
||||
};
|
||||
exports.useReducer = function (reducer, initialArg, init) {
|
||||
return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
|
||||
};
|
||||
exports.useRef = function (initialValue) {
|
||||
return ReactSharedInternals.H.useRef(initialValue);
|
||||
};
|
||||
exports.useState = function (initialState) {
|
||||
return ReactSharedInternals.H.useState(initialState);
|
||||
};
|
||||
exports.useSyncExternalStore = function (
|
||||
subscribe,
|
||||
getSnapshot,
|
||||
getServerSnapshot
|
||||
) {
|
||||
return ReactSharedInternals.H.useSyncExternalStore(
|
||||
subscribe,
|
||||
getSnapshot,
|
||||
getServerSnapshot
|
||||
);
|
||||
};
|
||||
exports.useTransition = function () {
|
||||
return ReactSharedInternals.H.useTransition();
|
||||
};
|
||||
exports.version = "19.0.0-beta-bc24118f";
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
|
||||
"function" ===
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
|
||||
Vendored
+623
@@ -0,0 +1,623 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<e367cc047b9d2098d9835d7bb141eaa2>>
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
if (__DEV__) {
|
||||
(function() {
|
||||
'use strict';
|
||||
if (
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
|
||||
'function'
|
||||
) {
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
|
||||
}
|
||||
var enableSchedulerDebugging = false;
|
||||
var enableProfiling = false;
|
||||
var frameYieldMs = 5;
|
||||
var userBlockingPriorityTimeout = 250;
|
||||
var normalPriorityTimeout = 5000;
|
||||
var lowPriorityTimeout = 10000;
|
||||
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
siftUp(heap, node, index);
|
||||
}
|
||||
function peek(heap) {
|
||||
return heap.length === 0 ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (heap.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
var first = heap[0];
|
||||
var last = heap.pop();
|
||||
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
siftDown(heap, last, 0);
|
||||
}
|
||||
|
||||
return first;
|
||||
}
|
||||
|
||||
function siftUp(heap, node, i) {
|
||||
var index = i;
|
||||
|
||||
while (index > 0) {
|
||||
var parentIndex = index - 1 >>> 1;
|
||||
var parent = heap[parentIndex];
|
||||
|
||||
if (compare(parent, node) > 0) {
|
||||
// The parent is larger. Swap positions.
|
||||
heap[parentIndex] = node;
|
||||
heap[index] = parent;
|
||||
index = parentIndex;
|
||||
} else {
|
||||
// The parent is smaller. Exit.
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function siftDown(heap, node, i) {
|
||||
var index = i;
|
||||
var length = heap.length;
|
||||
var halfLength = length >>> 1;
|
||||
|
||||
while (index < halfLength) {
|
||||
var leftIndex = (index + 1) * 2 - 1;
|
||||
var left = heap[leftIndex];
|
||||
var rightIndex = leftIndex + 1;
|
||||
var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
|
||||
|
||||
if (compare(left, node) < 0) {
|
||||
if (rightIndex < length && compare(right, left) < 0) {
|
||||
heap[index] = right;
|
||||
heap[rightIndex] = node;
|
||||
index = rightIndex;
|
||||
} else {
|
||||
heap[index] = left;
|
||||
heap[leftIndex] = node;
|
||||
index = leftIndex;
|
||||
}
|
||||
} else if (rightIndex < length && compare(right, node) < 0) {
|
||||
heap[index] = right;
|
||||
heap[rightIndex] = node;
|
||||
index = rightIndex;
|
||||
} else {
|
||||
// Neither child is smaller. Exit.
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function compare(a, b) {
|
||||
// Compare sort index first, then task id.
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return diff !== 0 ? diff : a.id - b.id;
|
||||
}
|
||||
|
||||
// TODO: Use symbols?
|
||||
var ImmediatePriority = 1;
|
||||
var UserBlockingPriority = 2;
|
||||
var NormalPriority = 3;
|
||||
var LowPriority = 4;
|
||||
var IdlePriority = 5;
|
||||
|
||||
function markTaskErrored(task, ms) {
|
||||
}
|
||||
|
||||
/* eslint-disable no-var */
|
||||
exports.unstable_now = void 0;
|
||||
var hasPerformanceNow = // $FlowFixMe[method-unbinding]
|
||||
typeof performance === 'object' && typeof performance.now === 'function';
|
||||
|
||||
if (hasPerformanceNow) {
|
||||
var localPerformance = performance;
|
||||
|
||||
exports.unstable_now = function () {
|
||||
return localPerformance.now();
|
||||
};
|
||||
} else {
|
||||
var localDate = Date;
|
||||
var initialTime = localDate.now();
|
||||
|
||||
exports.unstable_now = function () {
|
||||
return localDate.now() - initialTime;
|
||||
};
|
||||
} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
|
||||
// Math.pow(2, 30) - 1
|
||||
// 0b111111111111111111111111111111
|
||||
|
||||
|
||||
var maxSigned31BitInt = 1073741823; // Tasks are stored on a min heap
|
||||
|
||||
var taskQueue = [];
|
||||
var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
|
||||
|
||||
var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
|
||||
var currentTask = null;
|
||||
var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
|
||||
|
||||
var isPerformingWork = false;
|
||||
var isHostCallbackScheduled = false;
|
||||
var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.
|
||||
|
||||
var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
|
||||
var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
|
||||
var localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
|
||||
|
||||
function advanceTimers(currentTime) {
|
||||
// Check for tasks that are no longer delayed and add them to the queue.
|
||||
var timer = peek(timerQueue);
|
||||
|
||||
while (timer !== null) {
|
||||
if (timer.callback === null) {
|
||||
// Timer was cancelled.
|
||||
pop(timerQueue);
|
||||
} else if (timer.startTime <= currentTime) {
|
||||
// Timer fired. Transfer to the task queue.
|
||||
pop(timerQueue);
|
||||
timer.sortIndex = timer.expirationTime;
|
||||
push(taskQueue, timer);
|
||||
} else {
|
||||
// Remaining timers are pending.
|
||||
return;
|
||||
}
|
||||
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = false;
|
||||
advanceTimers(currentTime);
|
||||
|
||||
if (!isHostCallbackScheduled) {
|
||||
if (peek(taskQueue) !== null) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback();
|
||||
} else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
|
||||
if (firstTimer !== null) {
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function flushWork(initialTime) {
|
||||
|
||||
|
||||
isHostCallbackScheduled = false;
|
||||
|
||||
if (isHostTimeoutScheduled) {
|
||||
// We scheduled a timeout but it's no longer needed. Cancel it.
|
||||
isHostTimeoutScheduled = false;
|
||||
cancelHostTimeout();
|
||||
}
|
||||
|
||||
isPerformingWork = true;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
|
||||
try {
|
||||
var currentTime; if (enableProfiling) ; else {
|
||||
// No catch in prod code path.
|
||||
return workLoop(initialTime);
|
||||
}
|
||||
} finally {
|
||||
currentTask = null;
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
isPerformingWork = false;
|
||||
}
|
||||
}
|
||||
|
||||
function workLoop(initialTime) {
|
||||
var currentTime = initialTime;
|
||||
advanceTimers(currentTime);
|
||||
currentTask = peek(taskQueue);
|
||||
|
||||
while (currentTask !== null && !(enableSchedulerDebugging )) {
|
||||
if (currentTask.expirationTime > currentTime && shouldYieldToHost()) {
|
||||
// This currentTask hasn't expired, and we've reached the deadline.
|
||||
break;
|
||||
} // $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
|
||||
|
||||
var callback = currentTask.callback;
|
||||
|
||||
if (typeof callback === 'function') {
|
||||
// $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
|
||||
currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
|
||||
var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
|
||||
|
||||
var continuationCallback = callback(didUserCallbackTimeout);
|
||||
currentTime = exports.unstable_now();
|
||||
|
||||
if (typeof continuationCallback === 'function') {
|
||||
// If a continuation is returned, immediately yield to the main thread
|
||||
// regardless of how much time is left in the current time slice.
|
||||
// $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
currentTask.callback = continuationCallback;
|
||||
|
||||
advanceTimers(currentTime);
|
||||
return true;
|
||||
} else {
|
||||
|
||||
if (currentTask === peek(taskQueue)) {
|
||||
pop(taskQueue);
|
||||
}
|
||||
|
||||
advanceTimers(currentTime);
|
||||
}
|
||||
} else {
|
||||
pop(taskQueue);
|
||||
}
|
||||
|
||||
currentTask = peek(taskQueue);
|
||||
} // Return whether there's additional work
|
||||
|
||||
|
||||
if (currentTask !== null) {
|
||||
return true;
|
||||
} else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
|
||||
if (firstTimer !== null) {
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_runWithPriority(priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case ImmediatePriority:
|
||||
case UserBlockingPriority:
|
||||
case NormalPriority:
|
||||
case LowPriority:
|
||||
case IdlePriority:
|
||||
break;
|
||||
|
||||
default:
|
||||
priorityLevel = NormalPriority;
|
||||
}
|
||||
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_next(eventHandler) {
|
||||
var priorityLevel;
|
||||
|
||||
switch (currentPriorityLevel) {
|
||||
case ImmediatePriority:
|
||||
case UserBlockingPriority:
|
||||
case NormalPriority:
|
||||
// Shift down to normal priority
|
||||
priorityLevel = NormalPriority;
|
||||
break;
|
||||
|
||||
default:
|
||||
// Anything lower than normal priority should remain at the current level.
|
||||
priorityLevel = currentPriorityLevel;
|
||||
break;
|
||||
}
|
||||
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_wrapCallback(callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel; // $FlowFixMe[incompatible-return]
|
||||
// $FlowFixMe[missing-this-annot]
|
||||
|
||||
return function () {
|
||||
// This is a fork of runWithPriority, inlined for performance.
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function unstable_scheduleCallback(priorityLevel, callback, options) {
|
||||
var currentTime = exports.unstable_now();
|
||||
var startTime;
|
||||
|
||||
if (typeof options === 'object' && options !== null) {
|
||||
var delay = options.delay;
|
||||
|
||||
if (typeof delay === 'number' && delay > 0) {
|
||||
startTime = currentTime + delay;
|
||||
} else {
|
||||
startTime = currentTime;
|
||||
}
|
||||
} else {
|
||||
startTime = currentTime;
|
||||
}
|
||||
|
||||
var timeout;
|
||||
|
||||
switch (priorityLevel) {
|
||||
case ImmediatePriority:
|
||||
// Times out immediately
|
||||
timeout = -1;
|
||||
break;
|
||||
|
||||
case UserBlockingPriority:
|
||||
// Eventually times out
|
||||
timeout = userBlockingPriorityTimeout;
|
||||
break;
|
||||
|
||||
case IdlePriority:
|
||||
// Never times out
|
||||
timeout = maxSigned31BitInt;
|
||||
break;
|
||||
|
||||
case LowPriority:
|
||||
// Eventually times out
|
||||
timeout = lowPriorityTimeout;
|
||||
break;
|
||||
|
||||
case NormalPriority:
|
||||
default:
|
||||
// Eventually times out
|
||||
timeout = normalPriorityTimeout;
|
||||
break;
|
||||
}
|
||||
|
||||
var expirationTime = startTime + timeout;
|
||||
var newTask = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: startTime,
|
||||
expirationTime: expirationTime,
|
||||
sortIndex: -1
|
||||
};
|
||||
|
||||
if (startTime > currentTime) {
|
||||
// This is a delayed task.
|
||||
newTask.sortIndex = startTime;
|
||||
push(timerQueue, newTask);
|
||||
|
||||
if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
|
||||
// All tasks are delayed, and this is the task with the earliest delay.
|
||||
if (isHostTimeoutScheduled) {
|
||||
// Cancel an existing timeout.
|
||||
cancelHostTimeout();
|
||||
} else {
|
||||
isHostTimeoutScheduled = true;
|
||||
} // Schedule a timeout.
|
||||
|
||||
|
||||
requestHostTimeout(handleTimeout, startTime - currentTime);
|
||||
}
|
||||
} else {
|
||||
newTask.sortIndex = expirationTime;
|
||||
push(taskQueue, newTask);
|
||||
// wait until the next time we yield.
|
||||
|
||||
|
||||
if (!isHostCallbackScheduled && !isPerformingWork) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback();
|
||||
}
|
||||
}
|
||||
|
||||
return newTask;
|
||||
}
|
||||
|
||||
function unstable_pauseExecution() {
|
||||
}
|
||||
|
||||
function unstable_continueExecution() {
|
||||
|
||||
if (!isHostCallbackScheduled && !isPerformingWork) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback();
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_getFirstCallbackNode() {
|
||||
return peek(taskQueue);
|
||||
}
|
||||
|
||||
function unstable_cancelCallback(task) {
|
||||
// remove from the queue because you can't remove arbitrary nodes from an
|
||||
// array based heap, only the first one.)
|
||||
|
||||
|
||||
task.callback = null;
|
||||
}
|
||||
|
||||
function unstable_getCurrentPriorityLevel() {
|
||||
return currentPriorityLevel;
|
||||
}
|
||||
|
||||
var isMessageLoopRunning = false;
|
||||
var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
|
||||
// thread, like user events. By default, it yields multiple times per frame.
|
||||
// It does not attempt to align with frame boundaries, since most tasks don't
|
||||
// need to be frame aligned; for those that do, use requestAnimationFrame.
|
||||
|
||||
var frameInterval = frameYieldMs;
|
||||
var startTime = -1;
|
||||
|
||||
function shouldYieldToHost() {
|
||||
var timeElapsed = exports.unstable_now() - startTime;
|
||||
|
||||
if (timeElapsed < frameInterval) {
|
||||
// The main thread has only been blocked for a really short amount of time;
|
||||
// smaller than a single frame. Don't yield yet.
|
||||
return false;
|
||||
} // Yield now.
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function requestPaint() {}
|
||||
|
||||
function forceFrameRate(fps) {
|
||||
if (fps < 0 || fps > 125) {
|
||||
// Using console['error'] to evade Babel and ESLint
|
||||
console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported');
|
||||
return;
|
||||
}
|
||||
|
||||
if (fps > 0) {
|
||||
frameInterval = Math.floor(1000 / fps);
|
||||
} else {
|
||||
// reset the framerate
|
||||
frameInterval = frameYieldMs;
|
||||
}
|
||||
}
|
||||
|
||||
var performWorkUntilDeadline = function () {
|
||||
if (isMessageLoopRunning) {
|
||||
var currentTime = exports.unstable_now(); // Keep track of the start time so we can measure how long the main thread
|
||||
// has been blocked.
|
||||
|
||||
startTime = currentTime; // If a scheduler task throws, exit the current browser task so the
|
||||
// error can be observed.
|
||||
//
|
||||
// Intentionally not using a try-catch, since that makes some debugging
|
||||
// techniques harder. Instead, if `flushWork` errors, then `hasMoreWork` will
|
||||
// remain true, and we'll continue the work loop.
|
||||
|
||||
var hasMoreWork = true;
|
||||
|
||||
try {
|
||||
hasMoreWork = flushWork(currentTime);
|
||||
} finally {
|
||||
if (hasMoreWork) {
|
||||
// If there's more work, schedule the next message event at the end
|
||||
// of the preceding one.
|
||||
schedulePerformWorkUntilDeadline();
|
||||
} else {
|
||||
isMessageLoopRunning = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
var schedulePerformWorkUntilDeadline;
|
||||
|
||||
if (typeof localSetImmediate === 'function') {
|
||||
// Node.js and old IE.
|
||||
// There's a few reasons for why we prefer setImmediate.
|
||||
//
|
||||
// Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
|
||||
// (Even though this is a DOM fork of the Scheduler, you could get here
|
||||
// with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
|
||||
// https://github.com/facebook/react/issues/20756
|
||||
//
|
||||
// But also, it runs earlier which is the semantic we want.
|
||||
// If other browsers ever implement it, it's better to use it.
|
||||
// Although both of these would be inferior to native scheduling.
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetImmediate(performWorkUntilDeadline);
|
||||
};
|
||||
} else if (typeof MessageChannel !== 'undefined') {
|
||||
// DOM and Worker environments.
|
||||
// We prefer MessageChannel because of the 4ms setTimeout clamping.
|
||||
var channel = new MessageChannel();
|
||||
var port = channel.port2;
|
||||
channel.port1.onmessage = performWorkUntilDeadline;
|
||||
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
port.postMessage(null);
|
||||
};
|
||||
} else {
|
||||
// We should only fallback here in non-browser environments.
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
// $FlowFixMe[not-a-function] nullable value
|
||||
localSetTimeout(performWorkUntilDeadline, 0);
|
||||
};
|
||||
}
|
||||
|
||||
function requestHostCallback() {
|
||||
if (!isMessageLoopRunning) {
|
||||
isMessageLoopRunning = true;
|
||||
schedulePerformWorkUntilDeadline();
|
||||
}
|
||||
}
|
||||
|
||||
function requestHostTimeout(callback, ms) {
|
||||
// $FlowFixMe[not-a-function] nullable value
|
||||
taskTimeoutID = localSetTimeout(function () {
|
||||
callback(exports.unstable_now());
|
||||
}, ms);
|
||||
}
|
||||
|
||||
function cancelHostTimeout() {
|
||||
// $FlowFixMe[not-a-function] nullable value
|
||||
localClearTimeout(taskTimeoutID);
|
||||
taskTimeoutID = -1;
|
||||
}
|
||||
var unstable_Profiling = null;
|
||||
|
||||
exports.unstable_IdlePriority = IdlePriority;
|
||||
exports.unstable_ImmediatePriority = ImmediatePriority;
|
||||
exports.unstable_LowPriority = LowPriority;
|
||||
exports.unstable_NormalPriority = NormalPriority;
|
||||
exports.unstable_Profiling = unstable_Profiling;
|
||||
exports.unstable_UserBlockingPriority = UserBlockingPriority;
|
||||
exports.unstable_cancelCallback = unstable_cancelCallback;
|
||||
exports.unstable_continueExecution = unstable_continueExecution;
|
||||
exports.unstable_forceFrameRate = forceFrameRate;
|
||||
exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
|
||||
exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
|
||||
exports.unstable_next = unstable_next;
|
||||
exports.unstable_pauseExecution = unstable_pauseExecution;
|
||||
exports.unstable_requestPaint = requestPaint;
|
||||
exports.unstable_runWithPriority = unstable_runWithPriority;
|
||||
exports.unstable_scheduleCallback = unstable_scheduleCallback;
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = unstable_wrapCallback;
|
||||
if (
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
|
||||
'function'
|
||||
) {
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
|
||||
}
|
||||
|
||||
})();
|
||||
}
|
||||
Vendored
+343
@@ -0,0 +1,343 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<cff8a50048229c976ba8e49d76cca4f5>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
a: for (; 0 < index; ) {
|
||||
var parentIndex = (index - 1) >>> 1,
|
||||
parent = heap[parentIndex];
|
||||
if (0 < compare(parent, node))
|
||||
(heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
function peek(heap) {
|
||||
return 0 === heap.length ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (0 === heap.length) return null;
|
||||
var first = heap[0],
|
||||
last = heap.pop();
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
a: for (
|
||||
var index = 0, length = heap.length, halfLength = length >>> 1;
|
||||
index < halfLength;
|
||||
|
||||
) {
|
||||
var leftIndex = 2 * (index + 1) - 1,
|
||||
left = heap[leftIndex],
|
||||
rightIndex = leftIndex + 1,
|
||||
right = heap[rightIndex];
|
||||
if (0 > compare(left, last))
|
||||
rightIndex < length && 0 > compare(right, left)
|
||||
? ((heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex))
|
||||
: ((heap[index] = left),
|
||||
(heap[leftIndex] = last),
|
||||
(index = leftIndex));
|
||||
else if (rightIndex < length && 0 > compare(right, last))
|
||||
(heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
return first;
|
||||
}
|
||||
function compare(a, b) {
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return 0 !== diff ? diff : a.id - b.id;
|
||||
}
|
||||
exports.unstable_now = void 0;
|
||||
if ("object" === typeof performance && "function" === typeof performance.now) {
|
||||
var localPerformance = performance;
|
||||
exports.unstable_now = function () {
|
||||
return localPerformance.now();
|
||||
};
|
||||
} else {
|
||||
var localDate = Date,
|
||||
initialTime = localDate.now();
|
||||
exports.unstable_now = function () {
|
||||
return localDate.now() - initialTime;
|
||||
};
|
||||
}
|
||||
var taskQueue = [],
|
||||
timerQueue = [],
|
||||
taskIdCounter = 1,
|
||||
currentTask = null,
|
||||
currentPriorityLevel = 3,
|
||||
isPerformingWork = !1,
|
||||
isHostCallbackScheduled = !1,
|
||||
isHostTimeoutScheduled = !1,
|
||||
localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
|
||||
localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null,
|
||||
localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
|
||||
function advanceTimers(currentTime) {
|
||||
for (var timer = peek(timerQueue); null !== timer; ) {
|
||||
if (null === timer.callback) pop(timerQueue);
|
||||
else if (timer.startTime <= currentTime)
|
||||
pop(timerQueue),
|
||||
(timer.sortIndex = timer.expirationTime),
|
||||
push(taskQueue, timer);
|
||||
else break;
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = !1;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
(isHostCallbackScheduled = !0), requestHostCallback();
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
}
|
||||
var isMessageLoopRunning = !1,
|
||||
taskTimeoutID = -1,
|
||||
frameInterval = 5,
|
||||
startTime = -1;
|
||||
function shouldYieldToHost() {
|
||||
return exports.unstable_now() - startTime < frameInterval ? !1 : !0;
|
||||
}
|
||||
function performWorkUntilDeadline() {
|
||||
if (isMessageLoopRunning) {
|
||||
var currentTime = exports.unstable_now();
|
||||
startTime = currentTime;
|
||||
var hasMoreWork = !0;
|
||||
try {
|
||||
a: {
|
||||
isHostCallbackScheduled = !1;
|
||||
isHostTimeoutScheduled &&
|
||||
((isHostTimeoutScheduled = !1),
|
||||
localClearTimeout(taskTimeoutID),
|
||||
(taskTimeoutID = -1));
|
||||
isPerformingWork = !0;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
try {
|
||||
b: {
|
||||
advanceTimers(currentTime);
|
||||
for (
|
||||
currentTask = peek(taskQueue);
|
||||
null !== currentTask &&
|
||||
!(
|
||||
currentTask.expirationTime > currentTime && shouldYieldToHost()
|
||||
);
|
||||
|
||||
) {
|
||||
var callback = currentTask.callback;
|
||||
if ("function" === typeof callback) {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var continuationCallback = callback(
|
||||
currentTask.expirationTime <= currentTime
|
||||
);
|
||||
currentTime = exports.unstable_now();
|
||||
if ("function" === typeof continuationCallback) {
|
||||
currentTask.callback = continuationCallback;
|
||||
advanceTimers(currentTime);
|
||||
hasMoreWork = !0;
|
||||
break b;
|
||||
}
|
||||
currentTask === peek(taskQueue) && pop(taskQueue);
|
||||
advanceTimers(currentTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) hasMoreWork = !0;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
hasMoreWork = !1;
|
||||
}
|
||||
}
|
||||
break a;
|
||||
} finally {
|
||||
(currentTask = null),
|
||||
(currentPriorityLevel = previousPriorityLevel),
|
||||
(isPerformingWork = !1);
|
||||
}
|
||||
hasMoreWork = void 0;
|
||||
}
|
||||
} finally {
|
||||
hasMoreWork
|
||||
? schedulePerformWorkUntilDeadline()
|
||||
: (isMessageLoopRunning = !1);
|
||||
}
|
||||
}
|
||||
}
|
||||
var schedulePerformWorkUntilDeadline;
|
||||
if ("function" === typeof localSetImmediate)
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetImmediate(performWorkUntilDeadline);
|
||||
};
|
||||
else if ("undefined" !== typeof MessageChannel) {
|
||||
var channel = new MessageChannel(),
|
||||
port = channel.port2;
|
||||
channel.port1.onmessage = performWorkUntilDeadline;
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
port.postMessage(null);
|
||||
};
|
||||
} else
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetTimeout(performWorkUntilDeadline, 0);
|
||||
};
|
||||
function requestHostCallback() {
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
|
||||
}
|
||||
function requestHostTimeout(callback, ms) {
|
||||
taskTimeoutID = localSetTimeout(function () {
|
||||
callback(exports.unstable_now());
|
||||
}, ms);
|
||||
}
|
||||
exports.unstable_IdlePriority = 5;
|
||||
exports.unstable_ImmediatePriority = 1;
|
||||
exports.unstable_LowPriority = 4;
|
||||
exports.unstable_NormalPriority = 3;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = 2;
|
||||
exports.unstable_cancelCallback = function (task) {
|
||||
task.callback = null;
|
||||
};
|
||||
exports.unstable_continueExecution = function () {
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0), requestHostCallback());
|
||||
};
|
||||
exports.unstable_forceFrameRate = function (fps) {
|
||||
0 > fps || 125 < fps
|
||||
? console.error(
|
||||
"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
|
||||
)
|
||||
: (frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5);
|
||||
};
|
||||
exports.unstable_getCurrentPriorityLevel = function () {
|
||||
return currentPriorityLevel;
|
||||
};
|
||||
exports.unstable_getFirstCallbackNode = function () {
|
||||
return peek(taskQueue);
|
||||
};
|
||||
exports.unstable_next = function (eventHandler) {
|
||||
switch (currentPriorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
var priorityLevel = 3;
|
||||
break;
|
||||
default:
|
||||
priorityLevel = currentPriorityLevel;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_pauseExecution = function () {};
|
||||
exports.unstable_requestPaint = function () {};
|
||||
exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
break;
|
||||
default:
|
||||
priorityLevel = 3;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_scheduleCallback = function (
|
||||
priorityLevel,
|
||||
callback,
|
||||
options
|
||||
) {
|
||||
var currentTime = exports.unstable_now();
|
||||
"object" === typeof options && null !== options
|
||||
? ((options = options.delay),
|
||||
(options =
|
||||
"number" === typeof options && 0 < options
|
||||
? currentTime + options
|
||||
: currentTime))
|
||||
: (options = currentTime);
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
var timeout = -1;
|
||||
break;
|
||||
case 2:
|
||||
timeout = 250;
|
||||
break;
|
||||
case 5:
|
||||
timeout = 1073741823;
|
||||
break;
|
||||
case 4:
|
||||
timeout = 1e4;
|
||||
break;
|
||||
default:
|
||||
timeout = 5e3;
|
||||
}
|
||||
timeout = options + timeout;
|
||||
priorityLevel = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: options,
|
||||
expirationTime: timeout,
|
||||
sortIndex: -1
|
||||
};
|
||||
options > currentTime
|
||||
? ((priorityLevel.sortIndex = options),
|
||||
push(timerQueue, priorityLevel),
|
||||
null === peek(taskQueue) &&
|
||||
priorityLevel === peek(timerQueue) &&
|
||||
(isHostTimeoutScheduled
|
||||
? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
|
||||
: (isHostTimeoutScheduled = !0),
|
||||
requestHostTimeout(handleTimeout, options - currentTime)))
|
||||
: ((priorityLevel.sortIndex = timeout),
|
||||
push(taskQueue, priorityLevel),
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0), requestHostCallback()));
|
||||
return priorityLevel;
|
||||
};
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = function (callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
};
|
||||
compiled-rn/facebook-fbsource/xplat/js/RKJSModules/vendor/react/scheduler/cjs/Scheduler-profiling.js
Vendored
+351
@@ -0,0 +1,351 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<2a1458dad9404c5aa87cab9701762eca>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
|
||||
"function" ===
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
a: for (; 0 < index; ) {
|
||||
var parentIndex = (index - 1) >>> 1,
|
||||
parent = heap[parentIndex];
|
||||
if (0 < compare(parent, node))
|
||||
(heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
function peek(heap) {
|
||||
return 0 === heap.length ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (0 === heap.length) return null;
|
||||
var first = heap[0],
|
||||
last = heap.pop();
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
a: for (
|
||||
var index = 0, length = heap.length, halfLength = length >>> 1;
|
||||
index < halfLength;
|
||||
|
||||
) {
|
||||
var leftIndex = 2 * (index + 1) - 1,
|
||||
left = heap[leftIndex],
|
||||
rightIndex = leftIndex + 1,
|
||||
right = heap[rightIndex];
|
||||
if (0 > compare(left, last))
|
||||
rightIndex < length && 0 > compare(right, left)
|
||||
? ((heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex))
|
||||
: ((heap[index] = left),
|
||||
(heap[leftIndex] = last),
|
||||
(index = leftIndex));
|
||||
else if (rightIndex < length && 0 > compare(right, last))
|
||||
(heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
return first;
|
||||
}
|
||||
function compare(a, b) {
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return 0 !== diff ? diff : a.id - b.id;
|
||||
}
|
||||
exports.unstable_now = void 0;
|
||||
if ("object" === typeof performance && "function" === typeof performance.now) {
|
||||
var localPerformance = performance;
|
||||
exports.unstable_now = function () {
|
||||
return localPerformance.now();
|
||||
};
|
||||
} else {
|
||||
var localDate = Date,
|
||||
initialTime = localDate.now();
|
||||
exports.unstable_now = function () {
|
||||
return localDate.now() - initialTime;
|
||||
};
|
||||
}
|
||||
var taskQueue = [],
|
||||
timerQueue = [],
|
||||
taskIdCounter = 1,
|
||||
currentTask = null,
|
||||
currentPriorityLevel = 3,
|
||||
isPerformingWork = !1,
|
||||
isHostCallbackScheduled = !1,
|
||||
isHostTimeoutScheduled = !1,
|
||||
localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
|
||||
localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null,
|
||||
localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
|
||||
function advanceTimers(currentTime) {
|
||||
for (var timer = peek(timerQueue); null !== timer; ) {
|
||||
if (null === timer.callback) pop(timerQueue);
|
||||
else if (timer.startTime <= currentTime)
|
||||
pop(timerQueue),
|
||||
(timer.sortIndex = timer.expirationTime),
|
||||
push(taskQueue, timer);
|
||||
else break;
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = !1;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
(isHostCallbackScheduled = !0), requestHostCallback();
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
}
|
||||
var isMessageLoopRunning = !1,
|
||||
taskTimeoutID = -1,
|
||||
frameInterval = 5,
|
||||
startTime = -1;
|
||||
function shouldYieldToHost() {
|
||||
return exports.unstable_now() - startTime < frameInterval ? !1 : !0;
|
||||
}
|
||||
function performWorkUntilDeadline() {
|
||||
if (isMessageLoopRunning) {
|
||||
var currentTime = exports.unstable_now();
|
||||
startTime = currentTime;
|
||||
var hasMoreWork = !0;
|
||||
try {
|
||||
a: {
|
||||
isHostCallbackScheduled = !1;
|
||||
isHostTimeoutScheduled &&
|
||||
((isHostTimeoutScheduled = !1),
|
||||
localClearTimeout(taskTimeoutID),
|
||||
(taskTimeoutID = -1));
|
||||
isPerformingWork = !0;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
try {
|
||||
b: {
|
||||
advanceTimers(currentTime);
|
||||
for (
|
||||
currentTask = peek(taskQueue);
|
||||
null !== currentTask &&
|
||||
!(
|
||||
currentTask.expirationTime > currentTime && shouldYieldToHost()
|
||||
);
|
||||
|
||||
) {
|
||||
var callback = currentTask.callback;
|
||||
if ("function" === typeof callback) {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var continuationCallback = callback(
|
||||
currentTask.expirationTime <= currentTime
|
||||
);
|
||||
currentTime = exports.unstable_now();
|
||||
if ("function" === typeof continuationCallback) {
|
||||
currentTask.callback = continuationCallback;
|
||||
advanceTimers(currentTime);
|
||||
hasMoreWork = !0;
|
||||
break b;
|
||||
}
|
||||
currentTask === peek(taskQueue) && pop(taskQueue);
|
||||
advanceTimers(currentTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) hasMoreWork = !0;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
hasMoreWork = !1;
|
||||
}
|
||||
}
|
||||
break a;
|
||||
} finally {
|
||||
(currentTask = null),
|
||||
(currentPriorityLevel = previousPriorityLevel),
|
||||
(isPerformingWork = !1);
|
||||
}
|
||||
hasMoreWork = void 0;
|
||||
}
|
||||
} finally {
|
||||
hasMoreWork
|
||||
? schedulePerformWorkUntilDeadline()
|
||||
: (isMessageLoopRunning = !1);
|
||||
}
|
||||
}
|
||||
}
|
||||
var schedulePerformWorkUntilDeadline;
|
||||
if ("function" === typeof localSetImmediate)
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetImmediate(performWorkUntilDeadline);
|
||||
};
|
||||
else if ("undefined" !== typeof MessageChannel) {
|
||||
var channel = new MessageChannel(),
|
||||
port = channel.port2;
|
||||
channel.port1.onmessage = performWorkUntilDeadline;
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
port.postMessage(null);
|
||||
};
|
||||
} else
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetTimeout(performWorkUntilDeadline, 0);
|
||||
};
|
||||
function requestHostCallback() {
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
|
||||
}
|
||||
function requestHostTimeout(callback, ms) {
|
||||
taskTimeoutID = localSetTimeout(function () {
|
||||
callback(exports.unstable_now());
|
||||
}, ms);
|
||||
}
|
||||
exports.unstable_IdlePriority = 5;
|
||||
exports.unstable_ImmediatePriority = 1;
|
||||
exports.unstable_LowPriority = 4;
|
||||
exports.unstable_NormalPriority = 3;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = 2;
|
||||
exports.unstable_cancelCallback = function (task) {
|
||||
task.callback = null;
|
||||
};
|
||||
exports.unstable_continueExecution = function () {
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0), requestHostCallback());
|
||||
};
|
||||
exports.unstable_forceFrameRate = function (fps) {
|
||||
0 > fps || 125 < fps
|
||||
? console.error(
|
||||
"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
|
||||
)
|
||||
: (frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5);
|
||||
};
|
||||
exports.unstable_getCurrentPriorityLevel = function () {
|
||||
return currentPriorityLevel;
|
||||
};
|
||||
exports.unstable_getFirstCallbackNode = function () {
|
||||
return peek(taskQueue);
|
||||
};
|
||||
exports.unstable_next = function (eventHandler) {
|
||||
switch (currentPriorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
var priorityLevel = 3;
|
||||
break;
|
||||
default:
|
||||
priorityLevel = currentPriorityLevel;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_pauseExecution = function () {};
|
||||
exports.unstable_requestPaint = function () {};
|
||||
exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
break;
|
||||
default:
|
||||
priorityLevel = 3;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_scheduleCallback = function (
|
||||
priorityLevel,
|
||||
callback,
|
||||
options
|
||||
) {
|
||||
var currentTime = exports.unstable_now();
|
||||
"object" === typeof options && null !== options
|
||||
? ((options = options.delay),
|
||||
(options =
|
||||
"number" === typeof options && 0 < options
|
||||
? currentTime + options
|
||||
: currentTime))
|
||||
: (options = currentTime);
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
var timeout = -1;
|
||||
break;
|
||||
case 2:
|
||||
timeout = 250;
|
||||
break;
|
||||
case 5:
|
||||
timeout = 1073741823;
|
||||
break;
|
||||
case 4:
|
||||
timeout = 1e4;
|
||||
break;
|
||||
default:
|
||||
timeout = 5e3;
|
||||
}
|
||||
timeout = options + timeout;
|
||||
priorityLevel = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: options,
|
||||
expirationTime: timeout,
|
||||
sortIndex: -1
|
||||
};
|
||||
options > currentTime
|
||||
? ((priorityLevel.sortIndex = options),
|
||||
push(timerQueue, priorityLevel),
|
||||
null === peek(taskQueue) &&
|
||||
priorityLevel === peek(timerQueue) &&
|
||||
(isHostTimeoutScheduled
|
||||
? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
|
||||
: (isHostTimeoutScheduled = !0),
|
||||
requestHostTimeout(handleTimeout, options - currentTime)))
|
||||
: ((priorityLevel.sortIndex = timeout),
|
||||
push(taskQueue, priorityLevel),
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0), requestHostCallback()));
|
||||
return priorityLevel;
|
||||
};
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = function (callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
};
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
|
||||
"function" ===
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
|
||||
Vendored
+713
@@ -0,0 +1,713 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<d4da5b0b9415387cd4c7b044465b7eb0>>
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
if (__DEV__) {
|
||||
(function() {
|
||||
'use strict';
|
||||
|
||||
var enableSchedulerDebugging = false;
|
||||
var enableProfiling = false;
|
||||
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
siftUp(heap, node, index);
|
||||
}
|
||||
function peek(heap) {
|
||||
return heap.length === 0 ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (heap.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
var first = heap[0];
|
||||
var last = heap.pop();
|
||||
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
siftDown(heap, last, 0);
|
||||
}
|
||||
|
||||
return first;
|
||||
}
|
||||
|
||||
function siftUp(heap, node, i) {
|
||||
var index = i;
|
||||
|
||||
while (index > 0) {
|
||||
var parentIndex = index - 1 >>> 1;
|
||||
var parent = heap[parentIndex];
|
||||
|
||||
if (compare(parent, node) > 0) {
|
||||
// The parent is larger. Swap positions.
|
||||
heap[parentIndex] = node;
|
||||
heap[index] = parent;
|
||||
index = parentIndex;
|
||||
} else {
|
||||
// The parent is smaller. Exit.
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function siftDown(heap, node, i) {
|
||||
var index = i;
|
||||
var length = heap.length;
|
||||
var halfLength = length >>> 1;
|
||||
|
||||
while (index < halfLength) {
|
||||
var leftIndex = (index + 1) * 2 - 1;
|
||||
var left = heap[leftIndex];
|
||||
var rightIndex = leftIndex + 1;
|
||||
var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
|
||||
|
||||
if (compare(left, node) < 0) {
|
||||
if (rightIndex < length && compare(right, left) < 0) {
|
||||
heap[index] = right;
|
||||
heap[rightIndex] = node;
|
||||
index = rightIndex;
|
||||
} else {
|
||||
heap[index] = left;
|
||||
heap[leftIndex] = node;
|
||||
index = leftIndex;
|
||||
}
|
||||
} else if (rightIndex < length && compare(right, node) < 0) {
|
||||
heap[index] = right;
|
||||
heap[rightIndex] = node;
|
||||
index = rightIndex;
|
||||
} else {
|
||||
// Neither child is smaller. Exit.
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function compare(a, b) {
|
||||
// Compare sort index first, then task id.
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return diff !== 0 ? diff : a.id - b.id;
|
||||
}
|
||||
|
||||
// TODO: Use symbols?
|
||||
var ImmediatePriority = 1;
|
||||
var UserBlockingPriority = 2;
|
||||
var NormalPriority = 3;
|
||||
var LowPriority = 4;
|
||||
var IdlePriority = 5;
|
||||
|
||||
function markTaskErrored(task, ms) {
|
||||
}
|
||||
|
||||
/* eslint-disable no-var */
|
||||
// Math.pow(2, 30) - 1
|
||||
// 0b111111111111111111111111111111
|
||||
|
||||
var maxSigned31BitInt = 1073741823; // Times out immediately
|
||||
|
||||
var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
|
||||
|
||||
var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
|
||||
var NORMAL_PRIORITY_TIMEOUT = 5000;
|
||||
var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
|
||||
|
||||
var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
|
||||
|
||||
var taskQueue = [];
|
||||
var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
|
||||
|
||||
var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
|
||||
var currentTask = null;
|
||||
var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
|
||||
|
||||
var isPerformingWork = false;
|
||||
var isHostCallbackScheduled = false;
|
||||
var isHostTimeoutScheduled = false;
|
||||
var currentMockTime = 0;
|
||||
var scheduledCallback = null;
|
||||
var scheduledTimeout = null;
|
||||
var timeoutTime = -1;
|
||||
var yieldedValues = null;
|
||||
var expectedNumberOfYields = -1;
|
||||
var didStop = false;
|
||||
var isFlushing = false;
|
||||
var needsPaint = false;
|
||||
var shouldYieldForPaint = false;
|
||||
var disableYieldValue = false;
|
||||
|
||||
function setDisableYieldValue(newValue) {
|
||||
disableYieldValue = newValue;
|
||||
}
|
||||
|
||||
function advanceTimers(currentTime) {
|
||||
// Check for tasks that are no longer delayed and add them to the queue.
|
||||
var timer = peek(timerQueue);
|
||||
|
||||
while (timer !== null) {
|
||||
if (timer.callback === null) {
|
||||
// Timer was cancelled.
|
||||
pop(timerQueue);
|
||||
} else if (timer.startTime <= currentTime) {
|
||||
// Timer fired. Transfer to the task queue.
|
||||
pop(timerQueue);
|
||||
timer.sortIndex = timer.expirationTime;
|
||||
push(taskQueue, timer);
|
||||
} else {
|
||||
// Remaining timers are pending.
|
||||
return;
|
||||
}
|
||||
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = false;
|
||||
advanceTimers(currentTime);
|
||||
|
||||
if (!isHostCallbackScheduled) {
|
||||
if (peek(taskQueue) !== null) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback(flushWork);
|
||||
} else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
|
||||
if (firstTimer !== null) {
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function flushWork(hasTimeRemaining, initialTime) {
|
||||
|
||||
|
||||
isHostCallbackScheduled = false;
|
||||
|
||||
if (isHostTimeoutScheduled) {
|
||||
// We scheduled a timeout but it's no longer needed. Cancel it.
|
||||
isHostTimeoutScheduled = false;
|
||||
cancelHostTimeout();
|
||||
}
|
||||
|
||||
isPerformingWork = true;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
|
||||
try {
|
||||
var currentTime; if (enableProfiling) ; else {
|
||||
// No catch in prod code path.
|
||||
return workLoop(hasTimeRemaining, initialTime);
|
||||
}
|
||||
} finally {
|
||||
currentTask = null;
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
isPerformingWork = false;
|
||||
}
|
||||
}
|
||||
|
||||
function workLoop(hasTimeRemaining, initialTime) {
|
||||
var currentTime = initialTime;
|
||||
advanceTimers(currentTime);
|
||||
currentTask = peek(taskQueue);
|
||||
|
||||
while (currentTask !== null && !(enableSchedulerDebugging )) {
|
||||
if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
|
||||
// This currentTask hasn't expired, and we've reached the deadline.
|
||||
break;
|
||||
} // $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
|
||||
|
||||
var callback = currentTask.callback;
|
||||
|
||||
if (typeof callback === 'function') {
|
||||
// $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
|
||||
currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
|
||||
var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
|
||||
|
||||
var continuationCallback = callback(didUserCallbackTimeout);
|
||||
currentTime = getCurrentTime();
|
||||
|
||||
if (typeof continuationCallback === 'function') {
|
||||
// If a continuation is returned, immediately yield to the main thread
|
||||
// regardless of how much time is left in the current time slice.
|
||||
// $FlowFixMe[incompatible-use] found when upgrading Flow
|
||||
currentTask.callback = continuationCallback;
|
||||
|
||||
advanceTimers(currentTime);
|
||||
|
||||
if (shouldYieldForPaint) {
|
||||
needsPaint = true;
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
|
||||
if (currentTask === peek(taskQueue)) {
|
||||
pop(taskQueue);
|
||||
}
|
||||
|
||||
advanceTimers(currentTime);
|
||||
}
|
||||
} else {
|
||||
pop(taskQueue);
|
||||
}
|
||||
|
||||
currentTask = peek(taskQueue);
|
||||
} // Return whether there's additional work
|
||||
|
||||
|
||||
if (currentTask !== null) {
|
||||
return true;
|
||||
} else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
|
||||
if (firstTimer !== null) {
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_runWithPriority(priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case ImmediatePriority:
|
||||
case UserBlockingPriority:
|
||||
case NormalPriority:
|
||||
case LowPriority:
|
||||
case IdlePriority:
|
||||
break;
|
||||
|
||||
default:
|
||||
priorityLevel = NormalPriority;
|
||||
}
|
||||
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_next(eventHandler) {
|
||||
var priorityLevel;
|
||||
|
||||
switch (currentPriorityLevel) {
|
||||
case ImmediatePriority:
|
||||
case UserBlockingPriority:
|
||||
case NormalPriority:
|
||||
// Shift down to normal priority
|
||||
priorityLevel = NormalPriority;
|
||||
break;
|
||||
|
||||
default:
|
||||
// Anything lower than normal priority should remain at the current level.
|
||||
priorityLevel = currentPriorityLevel;
|
||||
break;
|
||||
}
|
||||
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_wrapCallback(callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel; // $FlowFixMe[incompatible-return]
|
||||
// $FlowFixMe[missing-this-annot]
|
||||
|
||||
return function () {
|
||||
// This is a fork of runWithPriority, inlined for performance.
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function unstable_scheduleCallback(priorityLevel, callback, options) {
|
||||
var currentTime = getCurrentTime();
|
||||
var startTime;
|
||||
|
||||
if (typeof options === 'object' && options !== null) {
|
||||
var delay = options.delay;
|
||||
|
||||
if (typeof delay === 'number' && delay > 0) {
|
||||
startTime = currentTime + delay;
|
||||
} else {
|
||||
startTime = currentTime;
|
||||
}
|
||||
} else {
|
||||
startTime = currentTime;
|
||||
}
|
||||
|
||||
var timeout;
|
||||
|
||||
switch (priorityLevel) {
|
||||
case ImmediatePriority:
|
||||
timeout = IMMEDIATE_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
|
||||
case UserBlockingPriority:
|
||||
timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
|
||||
case IdlePriority:
|
||||
timeout = IDLE_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
|
||||
case LowPriority:
|
||||
timeout = LOW_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
|
||||
case NormalPriority:
|
||||
default:
|
||||
timeout = NORMAL_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
}
|
||||
|
||||
var expirationTime = startTime + timeout;
|
||||
var newTask = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: startTime,
|
||||
expirationTime: expirationTime,
|
||||
sortIndex: -1
|
||||
};
|
||||
|
||||
if (startTime > currentTime) {
|
||||
// This is a delayed task.
|
||||
newTask.sortIndex = startTime;
|
||||
push(timerQueue, newTask);
|
||||
|
||||
if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
|
||||
// All tasks are delayed, and this is the task with the earliest delay.
|
||||
if (isHostTimeoutScheduled) {
|
||||
// Cancel an existing timeout.
|
||||
cancelHostTimeout();
|
||||
} else {
|
||||
isHostTimeoutScheduled = true;
|
||||
} // Schedule a timeout.
|
||||
|
||||
|
||||
requestHostTimeout(handleTimeout, startTime - currentTime);
|
||||
}
|
||||
} else {
|
||||
newTask.sortIndex = expirationTime;
|
||||
push(taskQueue, newTask);
|
||||
// wait until the next time we yield.
|
||||
|
||||
|
||||
if (!isHostCallbackScheduled && !isPerformingWork) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback(flushWork);
|
||||
}
|
||||
}
|
||||
|
||||
return newTask;
|
||||
}
|
||||
|
||||
function unstable_pauseExecution() {
|
||||
}
|
||||
|
||||
function unstable_continueExecution() {
|
||||
|
||||
if (!isHostCallbackScheduled && !isPerformingWork) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback(flushWork);
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_getFirstCallbackNode() {
|
||||
return peek(taskQueue);
|
||||
}
|
||||
|
||||
function unstable_cancelCallback(task) {
|
||||
// remove from the queue because you can't remove arbitrary nodes from an
|
||||
// array based heap, only the first one.)
|
||||
|
||||
|
||||
task.callback = null;
|
||||
}
|
||||
|
||||
function unstable_getCurrentPriorityLevel() {
|
||||
return currentPriorityLevel;
|
||||
}
|
||||
|
||||
function requestHostCallback(callback) {
|
||||
scheduledCallback = callback;
|
||||
}
|
||||
|
||||
function requestHostTimeout(callback, ms) {
|
||||
scheduledTimeout = callback;
|
||||
timeoutTime = currentMockTime + ms;
|
||||
}
|
||||
|
||||
function cancelHostTimeout() {
|
||||
scheduledTimeout = null;
|
||||
timeoutTime = -1;
|
||||
}
|
||||
|
||||
function shouldYieldToHost() {
|
||||
if (expectedNumberOfYields === 0 && yieldedValues === null || expectedNumberOfYields !== -1 && yieldedValues !== null && yieldedValues.length >= expectedNumberOfYields || shouldYieldForPaint && needsPaint) {
|
||||
// We yielded at least as many values as expected. Stop flushing.
|
||||
didStop = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function getCurrentTime() {
|
||||
return currentMockTime;
|
||||
}
|
||||
|
||||
function forceFrameRate() {// No-op
|
||||
}
|
||||
|
||||
function reset() {
|
||||
if (isFlushing) {
|
||||
throw new Error('Cannot reset while already flushing work.');
|
||||
}
|
||||
|
||||
currentMockTime = 0;
|
||||
scheduledCallback = null;
|
||||
scheduledTimeout = null;
|
||||
timeoutTime = -1;
|
||||
yieldedValues = null;
|
||||
expectedNumberOfYields = -1;
|
||||
didStop = false;
|
||||
isFlushing = false;
|
||||
needsPaint = false;
|
||||
} // Should only be used via an assertion helper that inspects the yielded values.
|
||||
|
||||
|
||||
function unstable_flushNumberOfYields(count) {
|
||||
if (isFlushing) {
|
||||
throw new Error('Already flushing work.');
|
||||
}
|
||||
|
||||
if (scheduledCallback !== null) {
|
||||
var cb = scheduledCallback;
|
||||
expectedNumberOfYields = count;
|
||||
isFlushing = true;
|
||||
|
||||
try {
|
||||
var hasMoreWork = true;
|
||||
|
||||
do {
|
||||
hasMoreWork = cb(true, currentMockTime);
|
||||
} while (hasMoreWork && !didStop);
|
||||
|
||||
if (!hasMoreWork) {
|
||||
scheduledCallback = null;
|
||||
}
|
||||
} finally {
|
||||
expectedNumberOfYields = -1;
|
||||
didStop = false;
|
||||
isFlushing = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_flushUntilNextPaint() {
|
||||
if (isFlushing) {
|
||||
throw new Error('Already flushing work.');
|
||||
}
|
||||
|
||||
if (scheduledCallback !== null) {
|
||||
var cb = scheduledCallback;
|
||||
shouldYieldForPaint = true;
|
||||
needsPaint = false;
|
||||
isFlushing = true;
|
||||
|
||||
try {
|
||||
var hasMoreWork = true;
|
||||
|
||||
do {
|
||||
hasMoreWork = cb(true, currentMockTime);
|
||||
} while (hasMoreWork && !didStop);
|
||||
|
||||
if (!hasMoreWork) {
|
||||
scheduledCallback = null;
|
||||
}
|
||||
} finally {
|
||||
shouldYieldForPaint = false;
|
||||
didStop = false;
|
||||
isFlushing = false;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function unstable_hasPendingWork() {
|
||||
return scheduledCallback !== null;
|
||||
}
|
||||
|
||||
function unstable_flushExpired() {
|
||||
if (isFlushing) {
|
||||
throw new Error('Already flushing work.');
|
||||
}
|
||||
|
||||
if (scheduledCallback !== null) {
|
||||
isFlushing = true;
|
||||
|
||||
try {
|
||||
var hasMoreWork = scheduledCallback(false, currentMockTime);
|
||||
|
||||
if (!hasMoreWork) {
|
||||
scheduledCallback = null;
|
||||
}
|
||||
} finally {
|
||||
isFlushing = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_flushAllWithoutAsserting() {
|
||||
// Returns false if no work was flushed.
|
||||
if (isFlushing) {
|
||||
throw new Error('Already flushing work.');
|
||||
}
|
||||
|
||||
if (scheduledCallback !== null) {
|
||||
var cb = scheduledCallback;
|
||||
isFlushing = true;
|
||||
|
||||
try {
|
||||
var hasMoreWork = true;
|
||||
|
||||
do {
|
||||
hasMoreWork = cb(true, currentMockTime);
|
||||
} while (hasMoreWork);
|
||||
|
||||
if (!hasMoreWork) {
|
||||
scheduledCallback = null;
|
||||
}
|
||||
|
||||
return true;
|
||||
} finally {
|
||||
isFlushing = false;
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_clearLog() {
|
||||
if (yieldedValues === null) {
|
||||
return [];
|
||||
}
|
||||
|
||||
var values = yieldedValues;
|
||||
yieldedValues = null;
|
||||
return values;
|
||||
}
|
||||
|
||||
function unstable_flushAll() {
|
||||
if (yieldedValues !== null) {
|
||||
throw new Error('Log is not empty. Assert on the log of yielded values before ' + 'flushing additional work.');
|
||||
}
|
||||
|
||||
unstable_flushAllWithoutAsserting();
|
||||
|
||||
if (yieldedValues !== null) {
|
||||
throw new Error('While flushing work, something yielded a value. Use an ' + 'assertion helper to assert on the log of yielded values, e.g. ' + 'expect(Scheduler).toFlushAndYield([...])');
|
||||
}
|
||||
}
|
||||
|
||||
function log(value) {
|
||||
// eslint-disable-next-line react-internal/no-production-logging
|
||||
if (console.log.name === 'disabledLog' || disableYieldValue) {
|
||||
// If console.log has been patched, we assume we're in render
|
||||
// replaying and we ignore any values yielding in the second pass.
|
||||
return;
|
||||
}
|
||||
|
||||
if (yieldedValues === null) {
|
||||
yieldedValues = [value];
|
||||
} else {
|
||||
yieldedValues.push(value);
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_advanceTime(ms) {
|
||||
// eslint-disable-next-line react-internal/no-production-logging
|
||||
if (console.log.name === 'disabledLog' || disableYieldValue) {
|
||||
// If console.log has been patched, we assume we're in render
|
||||
// replaying and we ignore any time advancing in the second pass.
|
||||
return;
|
||||
}
|
||||
|
||||
currentMockTime += ms;
|
||||
|
||||
if (scheduledTimeout !== null && timeoutTime <= currentMockTime) {
|
||||
scheduledTimeout(currentMockTime);
|
||||
timeoutTime = -1;
|
||||
scheduledTimeout = null;
|
||||
}
|
||||
}
|
||||
|
||||
function requestPaint() {
|
||||
needsPaint = true;
|
||||
}
|
||||
var unstable_Profiling = null;
|
||||
|
||||
exports.log = log;
|
||||
exports.reset = reset;
|
||||
exports.unstable_IdlePriority = IdlePriority;
|
||||
exports.unstable_ImmediatePriority = ImmediatePriority;
|
||||
exports.unstable_LowPriority = LowPriority;
|
||||
exports.unstable_NormalPriority = NormalPriority;
|
||||
exports.unstable_Profiling = unstable_Profiling;
|
||||
exports.unstable_UserBlockingPriority = UserBlockingPriority;
|
||||
exports.unstable_advanceTime = unstable_advanceTime;
|
||||
exports.unstable_cancelCallback = unstable_cancelCallback;
|
||||
exports.unstable_clearLog = unstable_clearLog;
|
||||
exports.unstable_continueExecution = unstable_continueExecution;
|
||||
exports.unstable_flushAll = unstable_flushAll;
|
||||
exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
|
||||
exports.unstable_flushExpired = unstable_flushExpired;
|
||||
exports.unstable_flushNumberOfYields = unstable_flushNumberOfYields;
|
||||
exports.unstable_flushUntilNextPaint = unstable_flushUntilNextPaint;
|
||||
exports.unstable_forceFrameRate = forceFrameRate;
|
||||
exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
|
||||
exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
|
||||
exports.unstable_hasPendingWork = unstable_hasPendingWork;
|
||||
exports.unstable_next = unstable_next;
|
||||
exports.unstable_now = getCurrentTime;
|
||||
exports.unstable_pauseExecution = unstable_pauseExecution;
|
||||
exports.unstable_requestPaint = requestPaint;
|
||||
exports.unstable_runWithPriority = unstable_runWithPriority;
|
||||
exports.unstable_scheduleCallback = unstable_scheduleCallback;
|
||||
exports.unstable_setDisableYieldValue = setDisableYieldValue;
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = unstable_wrapCallback;
|
||||
})();
|
||||
}
|
||||
Vendored
+417
@@ -0,0 +1,417 @@
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
* @noflow
|
||||
* @nolint
|
||||
* @preventMunge
|
||||
* @generated SignedSource<<87e7b57a62257e3d246f6aac3f6ce7c3>>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
a: for (; 0 < index; ) {
|
||||
var parentIndex = (index - 1) >>> 1,
|
||||
parent = heap[parentIndex];
|
||||
if (0 < compare(parent, node))
|
||||
(heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
function peek(heap) {
|
||||
return 0 === heap.length ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (0 === heap.length) return null;
|
||||
var first = heap[0],
|
||||
last = heap.pop();
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
a: for (
|
||||
var index = 0, length = heap.length, halfLength = length >>> 1;
|
||||
index < halfLength;
|
||||
|
||||
) {
|
||||
var leftIndex = 2 * (index + 1) - 1,
|
||||
left = heap[leftIndex],
|
||||
rightIndex = leftIndex + 1,
|
||||
right = heap[rightIndex];
|
||||
if (0 > compare(left, last))
|
||||
rightIndex < length && 0 > compare(right, left)
|
||||
? ((heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex))
|
||||
: ((heap[index] = left),
|
||||
(heap[leftIndex] = last),
|
||||
(index = leftIndex));
|
||||
else if (rightIndex < length && 0 > compare(right, last))
|
||||
(heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
return first;
|
||||
}
|
||||
function compare(a, b) {
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return 0 !== diff ? diff : a.id - b.id;
|
||||
}
|
||||
var taskQueue = [],
|
||||
timerQueue = [],
|
||||
taskIdCounter = 1,
|
||||
currentTask = null,
|
||||
currentPriorityLevel = 3,
|
||||
isPerformingWork = !1,
|
||||
isHostCallbackScheduled = !1,
|
||||
isHostTimeoutScheduled = !1,
|
||||
currentMockTime = 0,
|
||||
scheduledCallback = null,
|
||||
scheduledTimeout = null,
|
||||
timeoutTime = -1,
|
||||
yieldedValues = null,
|
||||
expectedNumberOfYields = -1,
|
||||
didStop = !1,
|
||||
isFlushing = !1,
|
||||
needsPaint = !1,
|
||||
shouldYieldForPaint = !1,
|
||||
disableYieldValue = !1;
|
||||
function advanceTimers(currentTime) {
|
||||
for (var timer = peek(timerQueue); null !== timer; ) {
|
||||
if (null === timer.callback) pop(timerQueue);
|
||||
else if (timer.startTime <= currentTime)
|
||||
pop(timerQueue),
|
||||
(timer.sortIndex = timer.expirationTime),
|
||||
push(taskQueue, timer);
|
||||
else break;
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = !1;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
(isHostCallbackScheduled = !0), (scheduledCallback = flushWork);
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
((currentTime = firstTimer.startTime - currentTime),
|
||||
(scheduledTimeout = handleTimeout),
|
||||
(timeoutTime = currentMockTime + currentTime));
|
||||
}
|
||||
}
|
||||
function flushWork(hasTimeRemaining, initialTime) {
|
||||
isHostCallbackScheduled = !1;
|
||||
isHostTimeoutScheduled &&
|
||||
((isHostTimeoutScheduled = !1),
|
||||
(scheduledTimeout = null),
|
||||
(timeoutTime = -1));
|
||||
isPerformingWork = !0;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
try {
|
||||
a: {
|
||||
advanceTimers(initialTime);
|
||||
for (
|
||||
currentTask = peek(taskQueue);
|
||||
null !== currentTask &&
|
||||
(!(currentTask.expirationTime > initialTime) ||
|
||||
(hasTimeRemaining && !shouldYieldToHost()));
|
||||
|
||||
) {
|
||||
var callback = currentTask.callback;
|
||||
if ("function" === typeof callback) {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var continuationCallback = callback(
|
||||
currentTask.expirationTime <= initialTime
|
||||
);
|
||||
initialTime = currentMockTime;
|
||||
if ("function" === typeof continuationCallback) {
|
||||
if (
|
||||
((currentTask.callback = continuationCallback),
|
||||
advanceTimers(initialTime),
|
||||
shouldYieldForPaint)
|
||||
) {
|
||||
var JSCompiler_inline_result = (needsPaint = !0);
|
||||
break a;
|
||||
}
|
||||
} else
|
||||
currentTask === peek(taskQueue) && pop(taskQueue),
|
||||
advanceTimers(initialTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) JSCompiler_inline_result = !0;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
if (null !== firstTimer) {
|
||||
var ms = firstTimer.startTime - initialTime;
|
||||
scheduledTimeout = handleTimeout;
|
||||
timeoutTime = currentMockTime + ms;
|
||||
}
|
||||
JSCompiler_inline_result = !1;
|
||||
}
|
||||
}
|
||||
return JSCompiler_inline_result;
|
||||
} finally {
|
||||
(currentTask = null),
|
||||
(currentPriorityLevel = previousPriorityLevel),
|
||||
(isPerformingWork = !1);
|
||||
}
|
||||
}
|
||||
function shouldYieldToHost() {
|
||||
return (0 === expectedNumberOfYields && null === yieldedValues) ||
|
||||
(-1 !== expectedNumberOfYields &&
|
||||
null !== yieldedValues &&
|
||||
yieldedValues.length >= expectedNumberOfYields) ||
|
||||
(shouldYieldForPaint && needsPaint)
|
||||
? (didStop = !0)
|
||||
: !1;
|
||||
}
|
||||
function unstable_flushAllWithoutAsserting() {
|
||||
if (isFlushing) throw Error("Already flushing work.");
|
||||
if (null !== scheduledCallback) {
|
||||
var cb = scheduledCallback;
|
||||
isFlushing = !0;
|
||||
try {
|
||||
var hasMoreWork = !0;
|
||||
do hasMoreWork = cb(!0, currentMockTime);
|
||||
while (hasMoreWork);
|
||||
hasMoreWork || (scheduledCallback = null);
|
||||
return !0;
|
||||
} finally {
|
||||
isFlushing = !1;
|
||||
}
|
||||
} else return !1;
|
||||
}
|
||||
exports.log = function (value) {
|
||||
"disabledLog" === console.log.name ||
|
||||
disableYieldValue ||
|
||||
(null === yieldedValues
|
||||
? (yieldedValues = [value])
|
||||
: yieldedValues.push(value));
|
||||
};
|
||||
exports.reset = function () {
|
||||
if (isFlushing) throw Error("Cannot reset while already flushing work.");
|
||||
currentMockTime = 0;
|
||||
scheduledTimeout = scheduledCallback = null;
|
||||
timeoutTime = -1;
|
||||
yieldedValues = null;
|
||||
expectedNumberOfYields = -1;
|
||||
needsPaint = isFlushing = didStop = !1;
|
||||
};
|
||||
exports.unstable_IdlePriority = 5;
|
||||
exports.unstable_ImmediatePriority = 1;
|
||||
exports.unstable_LowPriority = 4;
|
||||
exports.unstable_NormalPriority = 3;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = 2;
|
||||
exports.unstable_advanceTime = function (ms) {
|
||||
"disabledLog" === console.log.name ||
|
||||
disableYieldValue ||
|
||||
((currentMockTime += ms),
|
||||
null !== scheduledTimeout &&
|
||||
timeoutTime <= currentMockTime &&
|
||||
(scheduledTimeout(currentMockTime),
|
||||
(timeoutTime = -1),
|
||||
(scheduledTimeout = null)));
|
||||
};
|
||||
exports.unstable_cancelCallback = function (task) {
|
||||
task.callback = null;
|
||||
};
|
||||
exports.unstable_clearLog = function () {
|
||||
if (null === yieldedValues) return [];
|
||||
var values = yieldedValues;
|
||||
yieldedValues = null;
|
||||
return values;
|
||||
};
|
||||
exports.unstable_continueExecution = function () {
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0), (scheduledCallback = flushWork));
|
||||
};
|
||||
exports.unstable_flushAll = function () {
|
||||
if (null !== yieldedValues)
|
||||
throw Error(
|
||||
"Log is not empty. Assert on the log of yielded values before flushing additional work."
|
||||
);
|
||||
unstable_flushAllWithoutAsserting();
|
||||
if (null !== yieldedValues)
|
||||
throw Error(
|
||||
"While flushing work, something yielded a value. Use an assertion helper to assert on the log of yielded values, e.g. expect(Scheduler).toFlushAndYield([...])"
|
||||
);
|
||||
};
|
||||
exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
|
||||
exports.unstable_flushExpired = function () {
|
||||
if (isFlushing) throw Error("Already flushing work.");
|
||||
if (null !== scheduledCallback) {
|
||||
isFlushing = !0;
|
||||
try {
|
||||
scheduledCallback(!1, currentMockTime) || (scheduledCallback = null);
|
||||
} finally {
|
||||
isFlushing = !1;
|
||||
}
|
||||
}
|
||||
};
|
||||
exports.unstable_flushNumberOfYields = function (count) {
|
||||
if (isFlushing) throw Error("Already flushing work.");
|
||||
if (null !== scheduledCallback) {
|
||||
var cb = scheduledCallback;
|
||||
expectedNumberOfYields = count;
|
||||
isFlushing = !0;
|
||||
try {
|
||||
count = !0;
|
||||
do count = cb(!0, currentMockTime);
|
||||
while (count && !didStop);
|
||||
count || (scheduledCallback = null);
|
||||
} finally {
|
||||
(expectedNumberOfYields = -1), (isFlushing = didStop = !1);
|
||||
}
|
||||
}
|
||||
};
|
||||
exports.unstable_flushUntilNextPaint = function () {
|
||||
if (isFlushing) throw Error("Already flushing work.");
|
||||
if (null !== scheduledCallback) {
|
||||
var cb = scheduledCallback;
|
||||
shouldYieldForPaint = !0;
|
||||
needsPaint = !1;
|
||||
isFlushing = !0;
|
||||
try {
|
||||
var hasMoreWork = !0;
|
||||
do hasMoreWork = cb(!0, currentMockTime);
|
||||
while (hasMoreWork && !didStop);
|
||||
hasMoreWork || (scheduledCallback = null);
|
||||
} finally {
|
||||
isFlushing = didStop = shouldYieldForPaint = !1;
|
||||
}
|
||||
}
|
||||
return !1;
|
||||
};
|
||||
exports.unstable_forceFrameRate = function () {};
|
||||
exports.unstable_getCurrentPriorityLevel = function () {
|
||||
return currentPriorityLevel;
|
||||
};
|
||||
exports.unstable_getFirstCallbackNode = function () {
|
||||
return peek(taskQueue);
|
||||
};
|
||||
exports.unstable_hasPendingWork = function () {
|
||||
return null !== scheduledCallback;
|
||||
};
|
||||
exports.unstable_next = function (eventHandler) {
|
||||
switch (currentPriorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
var priorityLevel = 3;
|
||||
break;
|
||||
default:
|
||||
priorityLevel = currentPriorityLevel;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_now = function () {
|
||||
return currentMockTime;
|
||||
};
|
||||
exports.unstable_pauseExecution = function () {};
|
||||
exports.unstable_requestPaint = function () {
|
||||
needsPaint = !0;
|
||||
};
|
||||
exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
break;
|
||||
default:
|
||||
priorityLevel = 3;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_scheduleCallback = function (
|
||||
priorityLevel,
|
||||
callback,
|
||||
options
|
||||
) {
|
||||
var currentTime = currentMockTime;
|
||||
"object" === typeof options && null !== options
|
||||
? ((options = options.delay),
|
||||
(options =
|
||||
"number" === typeof options && 0 < options
|
||||
? currentTime + options
|
||||
: currentTime))
|
||||
: (options = currentTime);
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
var timeout = -1;
|
||||
break;
|
||||
case 2:
|
||||
timeout = 250;
|
||||
break;
|
||||
case 5:
|
||||
timeout = 1073741823;
|
||||
break;
|
||||
case 4:
|
||||
timeout = 1e4;
|
||||
break;
|
||||
default:
|
||||
timeout = 5e3;
|
||||
}
|
||||
timeout = options + timeout;
|
||||
priorityLevel = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: options,
|
||||
expirationTime: timeout,
|
||||
sortIndex: -1
|
||||
};
|
||||
options > currentTime
|
||||
? ((priorityLevel.sortIndex = options),
|
||||
push(timerQueue, priorityLevel),
|
||||
null === peek(taskQueue) &&
|
||||
priorityLevel === peek(timerQueue) &&
|
||||
(isHostTimeoutScheduled
|
||||
? ((scheduledTimeout = null), (timeoutTime = -1))
|
||||
: (isHostTimeoutScheduled = !0),
|
||||
(scheduledTimeout = handleTimeout),
|
||||
(timeoutTime = currentMockTime + (options - currentTime))))
|
||||
: ((priorityLevel.sortIndex = timeout),
|
||||
push(taskQueue, priorityLevel),
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0), (scheduledCallback = flushWork)));
|
||||
return priorityLevel;
|
||||
};
|
||||
exports.unstable_setDisableYieldValue = function (newValue) {
|
||||
disableYieldValue = newValue;
|
||||
};
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = function (callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
};
|
||||
+1
-1
@@ -1 +1 @@
|
||||
0a0a3af75a740d0920ebf7f4affaf8d1ce8c107f
|
||||
46abd7b1deb42d23b65480432609a2f8c5014cde
|
||||
|
||||
Reference in New Issue
Block a user