{"body":"The new Fiber Scheduler has been running in Facebook for several days\r\nwithout issues. Let's switch to it.","commit":{"authorName":"Andrew Clark","shortRevision":"9055e31e5c","authorEmail":"git@andrewclark.io","subject":"Replace old Fiber Scheduler with new one (#15387)","authoredAt":"2019-04-11T19:15:34-07:00","revision":"9055e31e5c82d03f0a365c459f7bc79e402dbef5"},"patch":"diff --git a\/package.json b\/package.json\nindex 92beff532f..5824c7298a 100644\n--- a\/package.json\n+++ b\/package.json\n@@ -102,7 +102,6 @@\n \"test\": \"cross-env NODE_ENV=development jest --config .\/scripts\/jest\/config.source.js\",\n \"test-persistent\": \"cross-env NODE_ENV=development jest --config .\/scripts\/jest\/config.source-persistent.js\",\n \"test-fire\": \"cross-env NODE_ENV=development jest --config .\/scripts\/jest\/config.source-fire.js\",\n- \"test-new-scheduler\": \"cross-env NODE_ENV=development jest --config .\/scripts\/jest\/config.source-new-scheduler.js\",\n \"test-prod\": \"cross-env NODE_ENV=production jest --config .\/scripts\/jest\/config.source.js\",\n \"test-fire-prod\": \"cross-env NODE_ENV=production jest --config .\/scripts\/jest\/config.source-fire.js\",\n \"test-prod-build\": \"yarn test-build-prod\",\ndiff --git a\/packages\/react-dom\/src\/__tests__\/ReactDOMHooks-test.internal.js b\/packages\/react-dom\/src\/__tests__\/ReactDOMHooks-test.js\nsimilarity index 79%\nrename from packages\/react-dom\/src\/__tests__\/ReactDOMHooks-test.internal.js\nrename to packages\/react-dom\/src\/__tests__\/ReactDOMHooks-test.js\nindex 7d58d22f41..360cfa9f9a 100644\n--- a\/packages\/react-dom\/src\/__tests__\/ReactDOMHooks-test.internal.js\n+++ b\/packages\/react-dom\/src\/__tests__\/ReactDOMHooks-test.js\n@@ -9,8 +9,6 @@\n \n 'use strict';\n \n-let ReactFeatureFlags;\n-let enableNewScheduler;\n let React;\n let ReactDOM;\n let Scheduler;\n@@ -21,8 +19,6 @@ describe('ReactDOMHooks', () => {\n beforeEach(() => {\n jest.resetModules();\n \n- ReactFeatureFlags = require('shared\/ReactFeatureFlags');\n- enableNewScheduler = ReactFeatureFlags.enableNewScheduler;\n React = require('react');\n ReactDOM = require('react-dom');\n Scheduler = require('scheduler');\n@@ -101,30 +97,15 @@ describe('ReactDOMHooks', () => {\n }\n \n ReactDOM.render(, container);\n-\n- if (enableNewScheduler) {\n- \/\/ The old behavior was accidental; in the new scheduler, flushing passive\n- \/\/ effects also flushes synchronous work, even inside batchedUpdates.\n- ReactDOM.unstable_batchedUpdates(() => {\n- _set(0); \/\/ Forces the effect to be flushed\n- expect(otherContainer.textContent).toBe('A');\n- ReactDOM.render(, otherContainer);\n- expect(otherContainer.textContent).toBe('A');\n- });\n- expect(otherContainer.textContent).toBe('B');\n- expect(calledA).toBe(true);\n- expect(calledB).toBe(true);\n- } else {\n- ReactDOM.unstable_batchedUpdates(() => {\n- _set(0); \/\/ Forces the effect to be flushed\n- expect(otherContainer.textContent).toBe('');\n- ReactDOM.render(, otherContainer);\n- expect(otherContainer.textContent).toBe('');\n- });\n- expect(otherContainer.textContent).toBe('B');\n- expect(calledA).toBe(false); \/\/ It was in a batch\n- expect(calledB).toBe(true);\n- }\n+ ReactDOM.unstable_batchedUpdates(() => {\n+ _set(0); \/\/ Forces the effect to be flushed\n+ expect(otherContainer.textContent).toBe('A');\n+ ReactDOM.render(, otherContainer);\n+ expect(otherContainer.textContent).toBe('A');\n+ });\n+ expect(otherContainer.textContent).toBe('B');\n+ expect(calledA).toBe(true);\n+ expect(calledB).toBe(true);\n });\n \n it('should not bail out when an update is scheduled from within an event handler', () => {\ndiff --git a\/packages\/react-dom\/unstable-new-scheduler.fb.js b\/packages\/react-dom\/unstable-new-scheduler.fb.js\ndeleted file mode 100644\nindex ea901748d6..0000000000\n--- a\/packages\/react-dom\/unstable-new-scheduler.fb.js\n+++ \/dev\/null\n@@ -1,14 +0,0 @@\n-\/**\n- * Copyright (c) Facebook, Inc. and its affiliates.\n- *\n- * This source code is licensed under the MIT license found in the\n- * LICENSE file in the root directory of this source tree.\n- *\/\n-\n-'use strict';\n-\n-const ReactDOMFB = require('.\/src\/client\/ReactDOMFB');\n-\n-\/\/ TODO: decide on the top-level export form.\n-\/\/ This is hacky but makes it work with both Rollup and Jest.\n-module.exports = ReactDOMFB.default || ReactDOMFB;\ndiff --git a\/packages\/react-dom\/unstable-new-scheduler.js b\/packages\/react-dom\/unstable-new-scheduler.js\ndeleted file mode 100644\nindex 2a016ba16e..0000000000\n--- a\/packages\/react-dom\/unstable-new-scheduler.js\n+++ \/dev\/null\n@@ -1,16 +0,0 @@\n-\/**\n- * Copyright (c) Facebook, Inc. and its affiliates.\n- *\n- * This source code is licensed under the MIT license found in the\n- * LICENSE file in the root directory of this source tree.\n- *\n- * @flow\n- *\/\n-\n-'use strict';\n-\n-const ReactDOM = require('.\/src\/client\/ReactDOM');\n-\n-\/\/ TODO: decide on the top-level export form.\n-\/\/ This is hacky but makes it work with both Rollup and Jest.\n-module.exports = ReactDOM.default || ReactDOM;\ndiff --git a\/packages\/react-reconciler\/src\/ReactFiberPendingPriority.js b\/packages\/react-reconciler\/src\/ReactFiberPendingPriority.js\ndeleted file mode 100644\nindex 43e241d3a2..0000000000\n--- a\/packages\/react-reconciler\/src\/ReactFiberPendingPriority.js\n+++ \/dev\/null\n@@ -1,265 +0,0 @@\n-\/**\n- * Copyright (c) Facebook, Inc. and its affiliates.\n- *\n- * This source code is licensed under the MIT license found in the\n- * LICENSE file in the root directory of this source tree.\n- *\n- * @flow\n- *\/\n-\n-import type {FiberRoot} from '.\/ReactFiberRoot';\n-import type {ExpirationTime} from '.\/ReactFiberExpirationTime';\n-\n-import {NoWork} from '.\/ReactFiberExpirationTime';\n-\n-\/\/ TODO: Offscreen updates should never suspend. However, a promise that\n-\/\/ suspended inside an offscreen subtree should be able to ping at the priority\n-\/\/ of the outer render.\n-\n-export function markPendingPriorityLevel(\n- root: FiberRoot,\n- expirationTime: ExpirationTime,\n-): void {\n- \/\/ If there's a gap between completing a failed root and retrying it,\n- \/\/ additional updates may be scheduled. Clear `didError`, in case the update\n- \/\/ is sufficient to fix the error.\n- root.didError = false;\n-\n- \/\/ Update the latest and earliest pending times\n- const earliestPendingTime = root.earliestPendingTime;\n- if (earliestPendingTime === NoWork) {\n- \/\/ No other pending updates.\n- root.earliestPendingTime = root.latestPendingTime = expirationTime;\n- } else {\n- if (earliestPendingTime < expirationTime) {\n- \/\/ This is the earliest pending update.\n- root.earliestPendingTime = expirationTime;\n- } else {\n- const latestPendingTime = root.latestPendingTime;\n- if (latestPendingTime > expirationTime) {\n- \/\/ This is the latest pending update\n- root.latestPendingTime = expirationTime;\n- }\n- }\n- }\n- findNextExpirationTimeToWorkOn(expirationTime, root);\n-}\n-\n-export function markCommittedPriorityLevels(\n- root: FiberRoot,\n- earliestRemainingTime: ExpirationTime,\n-): void {\n- root.didError = false;\n-\n- if (earliestRemainingTime === NoWork) {\n- \/\/ Fast path. There's no remaining work. Clear everything.\n- root.earliestPendingTime = NoWork;\n- root.latestPendingTime = NoWork;\n- root.earliestSuspendedTime = NoWork;\n- root.latestSuspendedTime = NoWork;\n- root.latestPingedTime = NoWork;\n- findNextExpirationTimeToWorkOn(NoWork, root);\n- return;\n- }\n-\n- if (earliestRemainingTime < root.latestPingedTime) {\n- root.latestPingedTime = NoWork;\n- }\n-\n- \/\/ Let's see if the previous latest known pending level was just flushed.\n- const latestPendingTime = root.latestPendingTime;\n- if (latestPendingTime !== NoWork) {\n- if (latestPendingTime > earliestRemainingTime) {\n- \/\/ We've flushed all the known pending levels.\n- root.earliestPendingTime = root.latestPendingTime = NoWork;\n- } else {\n- const earliestPendingTime = root.earliestPendingTime;\n- if (earliestPendingTime > earliestRemainingTime) {\n- \/\/ We've flushed the earliest known pending level. Set this to the\n- \/\/ latest pending time.\n- root.earliestPendingTime = root.latestPendingTime;\n- }\n- }\n- }\n-\n- \/\/ Now let's handle the earliest remaining level in the whole tree. We need to\n- \/\/ decide whether to treat it as a pending level or as suspended. Check\n- \/\/ it falls within the range of known suspended levels.\n-\n- const earliestSuspendedTime = root.earliestSuspendedTime;\n- if (earliestSuspendedTime === NoWork) {\n- \/\/ There's no suspended work. Treat the earliest remaining level as a\n- \/\/ pending level.\n- markPendingPriorityLevel(root, earliestRemainingTime);\n- findNextExpirationTimeToWorkOn(NoWork, root);\n- return;\n- }\n-\n- const latestSuspendedTime = root.latestSuspendedTime;\n- if (earliestRemainingTime < latestSuspendedTime) {\n- \/\/ The earliest remaining level is later than all the suspended work. That\n- \/\/ means we've flushed all the suspended work.\n- root.earliestSuspendedTime = NoWork;\n- root.latestSuspendedTime = NoWork;\n- root.latestPingedTime = NoWork;\n-\n- \/\/ There's no suspended work. Treat the earliest remaining level as a\n- \/\/ pending level.\n- markPendingPriorityLevel(root, earliestRemainingTime);\n- findNextExpirationTimeToWorkOn(NoWork, root);\n- return;\n- }\n-\n- if (earliestRemainingTime > earliestSuspendedTime) {\n- \/\/ The earliest remaining time is earlier than all the suspended work.\n- \/\/ Treat it as a pending update.\n- markPendingPriorityLevel(root, earliestRemainingTime);\n- findNextExpirationTimeToWorkOn(NoWork, root);\n- return;\n- }\n-\n- \/\/ The earliest remaining time falls within the range of known suspended\n- \/\/ levels. We should treat this as suspended work.\n- findNextExpirationTimeToWorkOn(NoWork, root);\n-}\n-\n-export function hasLowerPriorityWork(\n- root: FiberRoot,\n- erroredExpirationTime: ExpirationTime,\n-): boolean {\n- const latestPendingTime = root.latestPendingTime;\n- const latestSuspendedTime = root.latestSuspendedTime;\n- const latestPingedTime = root.latestPingedTime;\n- return (\n- (latestPendingTime !== NoWork &&\n- latestPendingTime < erroredExpirationTime) ||\n- (latestSuspendedTime !== NoWork &&\n- latestSuspendedTime < erroredExpirationTime) ||\n- (latestPingedTime !== NoWork && latestPingedTime < erroredExpirationTime)\n- );\n-}\n-\n-export function isPriorityLevelSuspended(\n- root: FiberRoot,\n- expirationTime: ExpirationTime,\n-): boolean {\n- const earliestSuspendedTime = root.earliestSuspendedTime;\n- const latestSuspendedTime = root.latestSuspendedTime;\n- return (\n- earliestSuspendedTime !== NoWork &&\n- expirationTime <= earliestSuspendedTime &&\n- expirationTime >= latestSuspendedTime\n- );\n-}\n-\n-export function markSuspendedPriorityLevel(\n- root: FiberRoot,\n- suspendedTime: ExpirationTime,\n-): void {\n- root.didError = false;\n- clearPing(root, suspendedTime);\n-\n- \/\/ First, check the known pending levels and update them if needed.\n- const earliestPendingTime = root.earliestPendingTime;\n- const latestPendingTime = root.latestPendingTime;\n- if (earliestPendingTime === suspendedTime) {\n- if (latestPendingTime === suspendedTime) {\n- \/\/ Both known pending levels were suspended. Clear them.\n- root.earliestPendingTime = root.latestPendingTime = NoWork;\n- } else {\n- \/\/ The earliest pending level was suspended. Clear by setting it to the\n- \/\/ latest pending level.\n- root.earliestPendingTime = latestPendingTime;\n- }\n- } else if (latestPendingTime === suspendedTime) {\n- \/\/ The latest pending level was suspended. Clear by setting it to the\n- \/\/ latest pending level.\n- root.latestPendingTime = earliestPendingTime;\n- }\n-\n- \/\/ Finally, update the known suspended levels.\n- const earliestSuspendedTime = root.earliestSuspendedTime;\n- const latestSuspendedTime = root.latestSuspendedTime;\n- if (earliestSuspendedTime === NoWork) {\n- \/\/ No other suspended levels.\n- root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;\n- } else {\n- if (earliestSuspendedTime < suspendedTime) {\n- \/\/ This is the earliest suspended level.\n- root.earliestSuspendedTime = suspendedTime;\n- } else if (latestSuspendedTime > suspendedTime) {\n- \/\/ This is the latest suspended level\n- root.latestSuspendedTime = suspendedTime;\n- }\n- }\n-\n- findNextExpirationTimeToWorkOn(suspendedTime, root);\n-}\n-\n-export function markPingedPriorityLevel(\n- root: FiberRoot,\n- pingedTime: ExpirationTime,\n-): void {\n- root.didError = false;\n-\n- \/\/ TODO: When we add back resuming, we need to ensure the progressed work\n- \/\/ is thrown out and not reused during the restarted render. One way to\n- \/\/ invalidate the progressed work is to restart at expirationTime + 1.\n- const latestPingedTime = root.latestPingedTime;\n- if (latestPingedTime === NoWork || latestPingedTime > pingedTime) {\n- root.latestPingedTime = pingedTime;\n- }\n- findNextExpirationTimeToWorkOn(pingedTime, root);\n-}\n-\n-function clearPing(root, completedTime) {\n- const latestPingedTime = root.latestPingedTime;\n- if (latestPingedTime >= completedTime) {\n- root.latestPingedTime = NoWork;\n- }\n-}\n-\n-export function didExpireAtExpirationTime(\n- root: FiberRoot,\n- currentTime: ExpirationTime,\n-): void {\n- const expirationTime = root.expirationTime;\n- if (expirationTime !== NoWork && currentTime <= expirationTime) {\n- \/\/ The root has expired. Flush all work up to the current time.\n- root.nextExpirationTimeToWorkOn = currentTime;\n- }\n-}\n-\n-function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {\n- const earliestSuspendedTime = root.earliestSuspendedTime;\n- const latestSuspendedTime = root.latestSuspendedTime;\n- const earliestPendingTime = root.earliestPendingTime;\n- const latestPingedTime = root.latestPingedTime;\n-\n- \/\/ Work on the earliest pending time. Failing that, work on the latest\n- \/\/ pinged time.\n- let nextExpirationTimeToWorkOn =\n- earliestPendingTime !== NoWork ? earliestPendingTime : latestPingedTime;\n-\n- \/\/ If there is no pending or pinged work, check if there's suspended work\n- \/\/ that's lower priority than what we just completed.\n- if (\n- nextExpirationTimeToWorkOn === NoWork &&\n- (completedExpirationTime === NoWork ||\n- latestSuspendedTime < completedExpirationTime)\n- ) {\n- \/\/ The lowest priority suspended work is the work most likely to be\n- \/\/ committed next. Let's start rendering it again, so that if it times out,\n- \/\/ it's ready to commit.\n- nextExpirationTimeToWorkOn = latestSuspendedTime;\n- }\n-\n- let expirationTime = nextExpirationTimeToWorkOn;\n- if (expirationTime !== NoWork && earliestSuspendedTime > expirationTime) {\n- \/\/ Expire using the earliest known expiration time.\n- expirationTime = earliestSuspendedTime;\n- }\n-\n- root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;\n- root.expirationTime = expirationTime;\n-}\ndiff --git a\/packages\/react-reconciler\/src\/ReactFiberRoot.js b\/packages\/react-reconciler\/src\/ReactFiberRoot.js\nindex 2b085604ce..38563ae253 100644\n--- a\/packages\/react-reconciler\/src\/ReactFiberRoot.js\n+++ b\/packages\/react-reconciler\/src\/ReactFiberRoot.js\n@@ -16,10 +16,7 @@ import type {Interaction} from 'scheduler\/src\/Tracing';\n import {noTimeout} from '.\/ReactFiberHostConfig';\n import {createHostRootFiber} from '.\/ReactFiber';\n import {NoWork} from '.\/ReactFiberExpirationTime';\n-import {\n- enableSchedulerTracing,\n- enableNewScheduler,\n-} from 'shared\/ReactFeatureFlags';\n+import {enableSchedulerTracing} from 'shared\/ReactFeatureFlags';\n import {unstable_getThreadID} from 'scheduler\/tracing';\n \n \/\/ TODO: This should be lifted into the renderer.\n@@ -40,31 +37,11 @@ type BaseFiberRootProperties = {|\n \/\/ The currently active root fiber. This is the mutable root of the tree.\n current: Fiber,\n \n- \/\/ The following priority levels are used to distinguish between 1)\n- \/\/ uncommitted work, 2) uncommitted work that is suspended, and 3) uncommitted\n- \/\/ work that may be unsuspended. We choose not to track each individual\n- \/\/ pending level, trading granularity for performance.\n- \/\/\n- \/\/ The earliest and latest priority levels that are suspended from committing.\n- earliestSuspendedTime: ExpirationTime,\n- latestSuspendedTime: ExpirationTime,\n- \/\/ The earliest and latest priority levels that are not known to be suspended.\n- earliestPendingTime: ExpirationTime,\n- latestPendingTime: ExpirationTime,\n- \/\/ The latest priority level that was pinged by a resolved promise and can\n- \/\/ be retried.\n- latestPingedTime: ExpirationTime,\n-\n pingCache:\n | WeakMap>\n | Map>\n | null,\n \n- \/\/ If an error is thrown, and there are no more updates in the queue, we try\n- \/\/ rendering from the root one more time, synchronously, before handling\n- \/\/ the error.\n- didError: boolean,\n-\n pendingCommitExpirationTime: ExpirationTime,\n \/\/ A finished work-in-progress HostRoot that's ready to be committed.\n finishedWork: Fiber | null,\n@@ -76,22 +53,19 @@ type BaseFiberRootProperties = {|\n pendingContext: Object | null,\n \/\/ Determines if we should attempt to hydrate on the initial mount\n +hydrate: boolean,\n- \/\/ Remaining expiration time on this root.\n- \/\/ TODO: Lift this into the renderer\n- nextExpirationTimeToWorkOn: ExpirationTime,\n- expirationTime: ExpirationTime,\n \/\/ List of top-level batches. This list indicates whether a commit should be\n \/\/ deferred. Also contains completion callbacks.\n \/\/ TODO: Lift this into the renderer\n firstBatch: Batch | null,\n- \/\/ Linked-list of roots\n- nextScheduledRoot: FiberRoot | null,\n-\n- \/\/ New Scheduler fields\n+ \/\/ Node returned by Scheduler.scheduleCallback\n callbackNode: *,\n+ \/\/ Expiration of the callback associated with this root\n callbackExpirationTime: ExpirationTime,\n+ \/\/ The earliest pending expiration time that exists in the tree\n firstPendingTime: ExpirationTime,\n+ \/\/ The latest pending expiration time that exists in the tree\n lastPendingTime: ExpirationTime,\n+ \/\/ The time at which a suspended component pinged the root to render again\n pingTime: ExpirationTime,\n |};\n \n@@ -127,24 +101,11 @@ function FiberRootNode(containerInfo, hydrate) {\n this.pendingContext = null;\n this.hydrate = hydrate;\n this.firstBatch = null;\n-\n- if (enableNewScheduler) {\n- this.callbackNode = null;\n- this.callbackExpirationTime = NoWork;\n- this.firstPendingTime = NoWork;\n- this.lastPendingTime = NoWork;\n- this.pingTime = NoWork;\n- } else {\n- this.earliestPendingTime = NoWork;\n- this.latestPendingTime = NoWork;\n- this.earliestSuspendedTime = NoWork;\n- this.latestSuspendedTime = NoWork;\n- this.latestPingedTime = NoWork;\n- this.didError = false;\n- this.nextExpirationTimeToWorkOn = NoWork;\n- this.expirationTime = NoWork;\n- this.nextScheduledRoot = null;\n- }\n+ this.callbackNode = null;\n+ this.callbackExpirationTime = NoWork;\n+ this.firstPendingTime = NoWork;\n+ this.lastPendingTime = NoWork;\n+ this.pingTime = NoWork;\n \n if (enableSchedulerTracing) {\n this.interactionThreadID = unstable_getThreadID();\ndiff --git a\/packages\/react-reconciler\/src\/ReactFiberScheduler.js b\/packages\/react-reconciler\/src\/ReactFiberScheduler.js\nindex f58aaa7913..9c1065a568 100644\n--- a\/packages\/react-reconciler\/src\/ReactFiberScheduler.js\n+++ b\/packages\/react-reconciler\/src\/ReactFiberScheduler.js\n@@ -7,136 +7,2238 @@\n * @flow\n *\/\n \n-import {enableNewScheduler} from 'shared\/ReactFeatureFlags';\n+import type {Fiber} from '.\/ReactFiber';\n+import type {FiberRoot} from '.\/ReactFiberRoot';\n+import type {ExpirationTime} from '.\/ReactFiberExpirationTime';\n+import type {\n+ ReactPriorityLevel,\n+ SchedulerCallback,\n+} from '.\/SchedulerWithReactIntegration';\n+import type {Interaction} from 'scheduler\/src\/Tracing';\n \n import {\n- requestCurrentTime as requestCurrentTime_old,\n- computeExpirationForFiber as computeExpirationForFiber_old,\n- captureCommitPhaseError as captureCommitPhaseError_old,\n- onUncaughtError as onUncaughtError_old,\n- markRenderEventTime as markRenderEventTime_old,\n- renderDidSuspend as renderDidSuspend_old,\n- renderDidError as renderDidError_old,\n- pingSuspendedRoot as pingSuspendedRoot_old,\n- retryTimedOutBoundary as retryTimedOutBoundary_old,\n- resolveRetryThenable as resolveRetryThenable_old,\n- markLegacyErrorBoundaryAsFailed as markLegacyErrorBoundaryAsFailed_old,\n- isAlreadyFailedLegacyErrorBoundary as isAlreadyFailedLegacyErrorBoundary_old,\n- scheduleWork as scheduleWork_old,\n- flushRoot as flushRoot_old,\n- batchedUpdates as batchedUpdates_old,\n- unbatchedUpdates as unbatchedUpdates_old,\n- flushSync as flushSync_old,\n- flushControlled as flushControlled_old,\n- deferredUpdates as deferredUpdates_old,\n- syncUpdates as syncUpdates_old,\n- interactiveUpdates as interactiveUpdates_old,\n- flushInteractiveUpdates as flushInteractiveUpdates_old,\n- computeUniqueAsyncExpiration as computeUniqueAsyncExpiration_old,\n- flushPassiveEffects as flushPassiveEffects_old,\n- warnIfNotCurrentlyActingUpdatesInDev as warnIfNotCurrentlyActingUpdatesInDev_old,\n-} from '.\/ReactFiberScheduler.old';\n+ warnAboutDeprecatedLifecycles,\n+ enableUserTimingAPI,\n+ enableSuspenseServerRenderer,\n+ replayFailedUnitOfWorkWithInvokeGuardedCallback,\n+ enableProfilerTimer,\n+ disableYielding,\n+ enableSchedulerTracing,\n+} from 'shared\/ReactFeatureFlags';\n+import ReactSharedInternals from 'shared\/ReactSharedInternals';\n+import invariant from 'shared\/invariant';\n+import warning from 'shared\/warning';\n \n import {\n- requestCurrentTime as requestCurrentTime_new,\n- computeExpirationForFiber as computeExpirationForFiber_new,\n- captureCommitPhaseError as captureCommitPhaseError_new,\n- onUncaughtError as onUncaughtError_new,\n- markRenderEventTime as markRenderEventTime_new,\n- renderDidSuspend as renderDidSuspend_new,\n- renderDidError as renderDidError_new,\n- pingSuspendedRoot as pingSuspendedRoot_new,\n- retryTimedOutBoundary as retryTimedOutBoundary_new,\n- resolveRetryThenable as resolveRetryThenable_new,\n- markLegacyErrorBoundaryAsFailed as markLegacyErrorBoundaryAsFailed_new,\n- isAlreadyFailedLegacyErrorBoundary as isAlreadyFailedLegacyErrorBoundary_new,\n- scheduleWork as scheduleWork_new,\n- flushRoot as flushRoot_new,\n- batchedUpdates as batchedUpdates_new,\n- unbatchedUpdates as unbatchedUpdates_new,\n- flushSync as flushSync_new,\n- flushControlled as flushControlled_new,\n- deferredUpdates as deferredUpdates_new,\n- syncUpdates as syncUpdates_new,\n- interactiveUpdates as interactiveUpdates_new,\n- flushInteractiveUpdates as flushInteractiveUpdates_new,\n- computeUniqueAsyncExpiration as computeUniqueAsyncExpiration_new,\n- flushPassiveEffects as flushPassiveEffects_new,\n- warnIfNotCurrentlyActingUpdatesInDev as warnIfNotCurrentlyActingUpdatesInDev_new,\n-} from '.\/ReactFiberScheduler.new';\n-\n-export const requestCurrentTime = enableNewScheduler\n- ? requestCurrentTime_new\n- : requestCurrentTime_old;\n-export const computeExpirationForFiber = enableNewScheduler\n- ? computeExpirationForFiber_new\n- : computeExpirationForFiber_old;\n-export const captureCommitPhaseError = enableNewScheduler\n- ? captureCommitPhaseError_new\n- : captureCommitPhaseError_old;\n-export const onUncaughtError = enableNewScheduler\n- ? onUncaughtError_new\n- : onUncaughtError_old;\n-export const markRenderEventTime = enableNewScheduler\n- ? markRenderEventTime_new\n- : markRenderEventTime_old;\n-export const renderDidSuspend = enableNewScheduler\n- ? renderDidSuspend_new\n- : renderDidSuspend_old;\n-export const renderDidError = enableNewScheduler\n- ? renderDidError_new\n- : renderDidError_old;\n-export const pingSuspendedRoot = enableNewScheduler\n- ? pingSuspendedRoot_new\n- : pingSuspendedRoot_old;\n-export const retryTimedOutBoundary = enableNewScheduler\n- ? retryTimedOutBoundary_new\n- : retryTimedOutBoundary_old;\n-export const resolveRetryThenable = enableNewScheduler\n- ? resolveRetryThenable_new\n- : resolveRetryThenable_old;\n-export const markLegacyErrorBoundaryAsFailed = enableNewScheduler\n- ? markLegacyErrorBoundaryAsFailed_new\n- : markLegacyErrorBoundaryAsFailed_old;\n-export const isAlreadyFailedLegacyErrorBoundary = enableNewScheduler\n- ? isAlreadyFailedLegacyErrorBoundary_new\n- : isAlreadyFailedLegacyErrorBoundary_old;\n-export const scheduleWork = enableNewScheduler\n- ? scheduleWork_new\n- : scheduleWork_old;\n-export const flushRoot = enableNewScheduler ? flushRoot_new : flushRoot_old;\n-export const batchedUpdates = enableNewScheduler\n- ? batchedUpdates_new\n- : batchedUpdates_old;\n-export const unbatchedUpdates = enableNewScheduler\n- ? unbatchedUpdates_new\n- : unbatchedUpdates_old;\n-export const flushSync = enableNewScheduler ? flushSync_new : flushSync_old;\n-export const flushControlled = enableNewScheduler\n- ? flushControlled_new\n- : flushControlled_old;\n-export const deferredUpdates = enableNewScheduler\n- ? deferredUpdates_new\n- : deferredUpdates_old;\n-export const syncUpdates = enableNewScheduler\n- ? syncUpdates_new\n- : syncUpdates_old;\n-export const interactiveUpdates = enableNewScheduler\n- ? interactiveUpdates_new\n- : interactiveUpdates_old;\n-export const flushInteractiveUpdates = enableNewScheduler\n- ? flushInteractiveUpdates_new\n- : flushInteractiveUpdates_old;\n-export const computeUniqueAsyncExpiration = enableNewScheduler\n- ? computeUniqueAsyncExpiration_new\n- : computeUniqueAsyncExpiration_old;\n-export const flushPassiveEffects = enableNewScheduler\n- ? flushPassiveEffects_new\n- : flushPassiveEffects_old;\n-export const warnIfNotCurrentlyActingUpdatesInDev = enableNewScheduler\n- ? warnIfNotCurrentlyActingUpdatesInDev_new\n- : warnIfNotCurrentlyActingUpdatesInDev_old;\n+ scheduleCallback,\n+ cancelCallback,\n+ getCurrentPriorityLevel,\n+ runWithPriority,\n+ shouldYield,\n+ now,\n+ ImmediatePriority,\n+ UserBlockingPriority,\n+ NormalPriority,\n+ LowPriority,\n+ IdlePriority,\n+ flushImmediateQueue,\n+} from '.\/SchedulerWithReactIntegration';\n+\n+import {__interactionsRef, __subscriberRef} from 'scheduler\/tracing';\n+\n+import {\n+ prepareForCommit,\n+ resetAfterCommit,\n+ scheduleTimeout,\n+ cancelTimeout,\n+ noTimeout,\n+} from '.\/ReactFiberHostConfig';\n+\n+import {createWorkInProgress, assignFiberPropertiesInDEV} from '.\/ReactFiber';\n+import {NoContext, ConcurrentMode, ProfileMode} from '.\/ReactTypeOfMode';\n+import {\n+ HostRoot,\n+ ClassComponent,\n+ SuspenseComponent,\n+ DehydratedSuspenseComponent,\n+ FunctionComponent,\n+ ForwardRef,\n+ MemoComponent,\n+ SimpleMemoComponent,\n+} from 'shared\/ReactWorkTags';\n+import {\n+ NoEffect,\n+ PerformedWork,\n+ Placement,\n+ Update,\n+ PlacementAndUpdate,\n+ Deletion,\n+ Ref,\n+ ContentReset,\n+ Snapshot,\n+ Callback,\n+ Passive,\n+ Incomplete,\n+ HostEffectMask,\n+} from 'shared\/ReactSideEffectTags';\n+import {\n+ NoWork,\n+ Sync,\n+ Never,\n+ msToExpirationTime,\n+ expirationTimeToMs,\n+ computeInteractiveExpiration,\n+ computeAsyncExpiration,\n+ inferPriorityFromExpirationTime,\n+ LOW_PRIORITY_EXPIRATION,\n+} from '.\/ReactFiberExpirationTime';\n+import {beginWork as originalBeginWork} from '.\/ReactFiberBeginWork';\n+import {completeWork} from '.\/ReactFiberCompleteWork';\n+import {\n+ throwException,\n+ unwindWork,\n+ unwindInterruptedWork,\n+ createRootErrorUpdate,\n+ createClassErrorUpdate,\n+} from '.\/ReactFiberUnwindWork';\n+import {\n+ commitBeforeMutationLifeCycles as commitBeforeMutationEffectOnFiber,\n+ commitLifeCycles as commitLayoutEffectOnFiber,\n+ commitPassiveHookEffects,\n+ commitPlacement,\n+ commitWork,\n+ commitDeletion,\n+ commitDetachRef,\n+ commitAttachRef,\n+ commitResetTextContent,\n+} from '.\/ReactFiberCommitWork';\n+import {enqueueUpdate} from '.\/ReactUpdateQueue';\n+\/\/ TODO: Ahaha Andrew is bad at spellling\n+import {resetContextDependences as resetContextDependencies} from '.\/ReactFiberNewContext';\n+import {resetHooks, ContextOnlyDispatcher} from '.\/ReactFiberHooks';\n+import {createCapturedValue} from '.\/ReactCapturedValue';\n+\n+import {\n+ recordCommitTime,\n+ startProfilerTimer,\n+ stopProfilerTimerIfRunningAndRecordDelta,\n+} from '.\/ReactProfilerTimer';\n+\n+\/\/ DEV stuff\n+import warningWithoutStack from 'shared\/warningWithoutStack';\n+import getComponentName from 'shared\/getComponentName';\n+import ReactStrictModeWarnings from '.\/ReactStrictModeWarnings';\n+import {\n+ phase as ReactCurrentDebugFiberPhaseInDEV,\n+ resetCurrentFiber as resetCurrentDebugFiberInDEV,\n+ setCurrentFiber as setCurrentDebugFiberInDEV,\n+ getStackByFiberInDevAndProd,\n+} from '.\/ReactCurrentFiber';\n+import {\n+ recordEffect,\n+ recordScheduleUpdate,\n+ startRequestCallbackTimer,\n+ stopRequestCallbackTimer,\n+ startWorkTimer,\n+ stopWorkTimer,\n+ stopFailedWorkTimer,\n+ startWorkLoopTimer,\n+ stopWorkLoopTimer,\n+ startCommitTimer,\n+ stopCommitTimer,\n+ startCommitSnapshotEffectsTimer,\n+ stopCommitSnapshotEffectsTimer,\n+ startCommitHostEffectsTimer,\n+ stopCommitHostEffectsTimer,\n+ startCommitLifeCyclesTimer,\n+ stopCommitLifeCyclesTimer,\n+} from '.\/ReactDebugFiberPerf';\n+import {\n+ invokeGuardedCallback,\n+ hasCaughtError,\n+ clearCaughtError,\n+} from 'shared\/ReactErrorUtils';\n+import {onCommitRoot} from '.\/ReactFiberDevToolsHook';\n+\n+const ceil = Math.ceil;\n+\n+const {\n+ ReactCurrentDispatcher,\n+ ReactCurrentOwner,\n+ ReactShouldWarnActingUpdates,\n+} = ReactSharedInternals;\n+\n+type WorkPhase = 0 | 1 | 2 | 3 | 4 | 5;\n+const NotWorking = 0;\n+const BatchedPhase = 1;\n+const LegacyUnbatchedPhase = 2;\n+const FlushSyncPhase = 3;\n+const RenderPhase = 4;\n+const CommitPhase = 5;\n+\n+type RootExitStatus = 0 | 1 | 2 | 3;\n+const RootIncomplete = 0;\n+const RootErrored = 1;\n+const RootSuspended = 2;\n+const RootCompleted = 3;\n \n export type Thenable = {\n- then(resolve: () => mixed, reject?: () => mixed): void | Thenable,\n+ then(resolve: () => mixed, reject?: () => mixed): Thenable | void,\n };\n+\n+\/\/ The phase of work we're currently in\n+let workPhase: WorkPhase = NotWorking;\n+\/\/ The root we're working on\n+let workInProgressRoot: FiberRoot | null = null;\n+\/\/ The fiber we're working on\n+let workInProgress: Fiber | null = null;\n+\/\/ The expiration time we're rendering\n+let renderExpirationTime: ExpirationTime = NoWork;\n+\/\/ Whether to root completed, errored, suspended, etc.\n+let workInProgressRootExitStatus: RootExitStatus = RootIncomplete;\n+\/\/ Most recent event time among processed updates during this render.\n+\/\/ This is conceptually a time stamp but expressed in terms of an ExpirationTime\n+\/\/ because we deal mostly with expiration times in the hot path, so this avoids\n+\/\/ the conversion happening in the hot path.\n+let workInProgressRootMostRecentEventTime: ExpirationTime = Sync;\n+\n+let nextEffect: Fiber | null = null;\n+let hasUncaughtError = false;\n+let firstUncaughtError = null;\n+let legacyErrorBoundariesThatAlreadyFailed: Set | null = null;\n+\n+let rootDoesHavePassiveEffects: boolean = false;\n+let rootWithPendingPassiveEffects: FiberRoot | null = null;\n+let pendingPassiveEffectsExpirationTime: ExpirationTime = NoWork;\n+\n+let rootsWithPendingDiscreteUpdates: Map<\n+ FiberRoot,\n+ ExpirationTime,\n+> | null = null;\n+\n+\/\/ Use these to prevent an infinite loop of nested updates\n+const NESTED_UPDATE_LIMIT = 50;\n+let nestedUpdateCount: number = 0;\n+let rootWithNestedUpdates: FiberRoot | null = null;\n+\n+const NESTED_PASSIVE_UPDATE_LIMIT = 50;\n+let nestedPassiveUpdateCount: number = 0;\n+\n+let interruptedBy: Fiber | null = null;\n+\n+\/\/ Expiration times are computed by adding to the current time (the start\n+\/\/ time). However, if two updates are scheduled within the same event, we\n+\/\/ should treat their start times as simultaneous, even if the actual clock\n+\/\/ time has advanced between the first and second call.\n+\n+\/\/ In other words, because expiration times determine how updates are batched,\n+\/\/ we want all updates of like priority that occur within the same event to\n+\/\/ receive the same expiration time. Otherwise we get tearing.\n+let initialTimeMs: number = now();\n+let currentEventTime: ExpirationTime = NoWork;\n+\n+export function requestCurrentTime() {\n+ if (workPhase === RenderPhase || workPhase === CommitPhase) {\n+ \/\/ We're inside React, so it's fine to read the actual time.\n+ return msToExpirationTime(now() - initialTimeMs);\n+ }\n+ \/\/ We're not inside React, so we may be in the middle of a browser event.\n+ if (currentEventTime !== NoWork) {\n+ \/\/ Use the same start time for all updates until we enter React again.\n+ return currentEventTime;\n+ }\n+ \/\/ This is the first update since React yielded. Compute a new start time.\n+ currentEventTime = msToExpirationTime(now() - initialTimeMs);\n+ return currentEventTime;\n+}\n+\n+export function computeExpirationForFiber(\n+ currentTime: ExpirationTime,\n+ fiber: Fiber,\n+): ExpirationTime {\n+ if ((fiber.mode & ConcurrentMode) === NoContext) {\n+ return Sync;\n+ }\n+\n+ if (workPhase === RenderPhase) {\n+ \/\/ Use whatever time we're already rendering\n+ return renderExpirationTime;\n+ }\n+\n+ \/\/ Compute an expiration time based on the Scheduler priority.\n+ let expirationTime;\n+ const priorityLevel = getCurrentPriorityLevel();\n+ switch (priorityLevel) {\n+ case ImmediatePriority:\n+ expirationTime = Sync;\n+ break;\n+ case UserBlockingPriority:\n+ \/\/ TODO: Rename this to computeUserBlockingExpiration\n+ expirationTime = computeInteractiveExpiration(currentTime);\n+ break;\n+ case NormalPriority:\n+ case LowPriority: \/\/ TODO: Handle LowPriority\n+ \/\/ TODO: Rename this to... something better.\n+ expirationTime = computeAsyncExpiration(currentTime);\n+ break;\n+ case IdlePriority:\n+ expirationTime = Never;\n+ break;\n+ default:\n+ invariant(false, 'Expected a valid priority level');\n+ }\n+\n+ \/\/ If we're in the middle of rendering a tree, do not update at the same\n+ \/\/ expiration time that is already rendering.\n+ if (workInProgressRoot !== null && expirationTime === renderExpirationTime) {\n+ \/\/ This is a trick to move this update into a separate batch\n+ expirationTime -= 1;\n+ }\n+\n+ return expirationTime;\n+}\n+\n+let lastUniqueAsyncExpiration = NoWork;\n+export function computeUniqueAsyncExpiration(): ExpirationTime {\n+ const currentTime = requestCurrentTime();\n+ let result = computeAsyncExpiration(currentTime);\n+ if (result <= lastUniqueAsyncExpiration) {\n+ \/\/ Since we assume the current time monotonically increases, we only hit\n+ \/\/ this branch when computeUniqueAsyncExpiration is fired multiple times\n+ \/\/ within a 200ms window (or whatever the async bucket size is).\n+ result -= 1;\n+ }\n+ lastUniqueAsyncExpiration = result;\n+ return result;\n+}\n+\n+export function scheduleUpdateOnFiber(\n+ fiber: Fiber,\n+ expirationTime: ExpirationTime,\n+) {\n+ checkForNestedUpdates();\n+ warnAboutInvalidUpdatesOnClassComponentsInDEV(fiber);\n+\n+ const root = markUpdateTimeFromFiberToRoot(fiber, expirationTime);\n+ if (root === null) {\n+ warnAboutUpdateOnUnmountedFiberInDEV(fiber);\n+ return;\n+ }\n+\n+ root.pingTime = NoWork;\n+\n+ checkForInterruption(fiber, expirationTime);\n+ recordScheduleUpdate();\n+\n+ if (expirationTime === Sync) {\n+ if (workPhase === LegacyUnbatchedPhase) {\n+ \/\/ This is a legacy edge case. The initial mount of a ReactDOM.render-ed\n+ \/\/ root inside of batchedUpdates should be synchronous, but layout updates\n+ \/\/ should be deferred until the end of the batch.\n+ let callback = renderRoot(root, Sync, true);\n+ while (callback !== null) {\n+ callback = callback(true);\n+ }\n+ } else {\n+ scheduleCallbackForRoot(root, ImmediatePriority, Sync);\n+ if (workPhase === NotWorking) {\n+ \/\/ Flush the synchronous work now, wnless we're already working or inside\n+ \/\/ a batch. This is intentionally inside scheduleUpdateOnFiber instead of\n+ \/\/ scheduleCallbackForFiber to preserve the ability to schedule a callback\n+ \/\/ without immediately flushing it. We only do this for user-initated\n+ \/\/ updates, to preserve historical behavior of sync mode.\n+ flushImmediateQueue();\n+ }\n+ }\n+ } else {\n+ \/\/ TODO: computeExpirationForFiber also reads the priority. Pass the\n+ \/\/ priority as an argument to that function and this one.\n+ const priorityLevel = getCurrentPriorityLevel();\n+ if (priorityLevel === UserBlockingPriority) {\n+ \/\/ This is the result of a discrete event. Track the lowest priority\n+ \/\/ discrete update per root so we can flush them early, if needed.\n+ if (rootsWithPendingDiscreteUpdates === null) {\n+ rootsWithPendingDiscreteUpdates = new Map([[root, expirationTime]]);\n+ } else {\n+ const lastDiscreteTime = rootsWithPendingDiscreteUpdates.get(root);\n+ if (\n+ lastDiscreteTime === undefined ||\n+ lastDiscreteTime > expirationTime\n+ ) {\n+ rootsWithPendingDiscreteUpdates.set(root, expirationTime);\n+ }\n+ }\n+ }\n+ scheduleCallbackForRoot(root, priorityLevel, expirationTime);\n+ }\n+}\n+export const scheduleWork = scheduleUpdateOnFiber;\n+\n+\/\/ This is split into a separate function so we can mark a fiber with pending\n+\/\/ work without treating it as a typical update that originates from an event;\n+\/\/ e.g. retrying a Suspense boundary isn't an update, but it does schedule work\n+\/\/ on a fiber.\n+function markUpdateTimeFromFiberToRoot(fiber, expirationTime) {\n+ \/\/ Update the source fiber's expiration time\n+ if (fiber.expirationTime < expirationTime) {\n+ fiber.expirationTime = expirationTime;\n+ }\n+ let alternate = fiber.alternate;\n+ if (alternate !== null && alternate.expirationTime < expirationTime) {\n+ alternate.expirationTime = expirationTime;\n+ }\n+ \/\/ Walk the parent path to the root and update the child expiration time.\n+ let node = fiber.return;\n+ let root = null;\n+ if (node === null && fiber.tag === HostRoot) {\n+ root = fiber.stateNode;\n+ } else {\n+ while (node !== null) {\n+ alternate = node.alternate;\n+ if (node.childExpirationTime < expirationTime) {\n+ node.childExpirationTime = expirationTime;\n+ if (\n+ alternate !== null &&\n+ alternate.childExpirationTime < expirationTime\n+ ) {\n+ alternate.childExpirationTime = expirationTime;\n+ }\n+ } else if (\n+ alternate !== null &&\n+ alternate.childExpirationTime < expirationTime\n+ ) {\n+ alternate.childExpirationTime = expirationTime;\n+ }\n+ if (node.return === null && node.tag === HostRoot) {\n+ root = node.stateNode;\n+ break;\n+ }\n+ node = node.return;\n+ }\n+ }\n+\n+ if (root !== null) {\n+ \/\/ Update the first and last pending expiration times in this root\n+ const firstPendingTime = root.firstPendingTime;\n+ if (expirationTime > firstPendingTime) {\n+ root.firstPendingTime = expirationTime;\n+ }\n+ const lastPendingTime = root.lastPendingTime;\n+ if (lastPendingTime === NoWork || expirationTime < lastPendingTime) {\n+ root.lastPendingTime = expirationTime;\n+ }\n+ }\n+\n+ return root;\n+}\n+\n+\/\/ Use this function, along with runRootCallback, to ensure that only a single\n+\/\/ callback per root is scheduled. It's still possible to call renderRoot\n+\/\/ directly, but scheduling via this function helps avoid excessive callbacks.\n+\/\/ It works by storing the callback node and expiration time on the root. When a\n+\/\/ new callback comes in, it compares the expiration time to determine if it\n+\/\/ should cancel the previous one. It also relies on commitRoot scheduling a\n+\/\/ callback to render the next level, because that means we don't need a\n+\/\/ separate callback per expiration time.\n+function scheduleCallbackForRoot(\n+ root: FiberRoot,\n+ priorityLevel: ReactPriorityLevel,\n+ expirationTime: ExpirationTime,\n+) {\n+ const existingCallbackExpirationTime = root.callbackExpirationTime;\n+ if (existingCallbackExpirationTime < expirationTime) {\n+ \/\/ New callback has higher priority than the existing one.\n+ const existingCallbackNode = root.callbackNode;\n+ if (existingCallbackNode !== null) {\n+ cancelCallback(existingCallbackNode);\n+ }\n+ root.callbackExpirationTime = expirationTime;\n+ const options =\n+ expirationTime === Sync\n+ ? null\n+ : {timeout: expirationTimeToMs(expirationTime)};\n+ root.callbackNode = scheduleCallback(\n+ priorityLevel,\n+ runRootCallback.bind(\n+ null,\n+ root,\n+ renderRoot.bind(null, root, expirationTime),\n+ ),\n+ options,\n+ );\n+ if (\n+ enableUserTimingAPI &&\n+ expirationTime !== Sync &&\n+ workPhase !== RenderPhase &&\n+ workPhase !== CommitPhase\n+ ) {\n+ \/\/ Scheduled an async callback, and we're not already working. Add an\n+ \/\/ entry to the flamegraph that shows we're waiting for a callback\n+ \/\/ to fire.\n+ startRequestCallbackTimer();\n+ }\n+ }\n+\n+ const timeoutHandle = root.timeoutHandle;\n+ if (timeoutHandle !== noTimeout) {\n+ \/\/ The root previous suspended and scheduled a timeout to commit a fallback\n+ \/\/ state. Now that we have additional work, cancel the timeout.\n+ root.timeoutHandle = noTimeout;\n+ \/\/ $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above\n+ cancelTimeout(timeoutHandle);\n+ }\n+\n+ \/\/ Add the current set of interactions to the pending set associated with\n+ \/\/ this root.\n+ schedulePendingInteraction(root, expirationTime);\n+}\n+\n+function runRootCallback(root, callback, isSync) {\n+ const prevCallbackNode = root.callbackNode;\n+ let continuation = null;\n+ try {\n+ continuation = callback(isSync);\n+ if (continuation !== null) {\n+ return runRootCallback.bind(null, root, continuation);\n+ } else {\n+ return null;\n+ }\n+ } finally {\n+ \/\/ If the callback exits without returning a continuation, remove the\n+ \/\/ corresponding callback node from the root. Unless the callback node\n+ \/\/ has changed, which implies that it was already cancelled by a high\n+ \/\/ priority update.\n+ if (continuation === null && prevCallbackNode === root.callbackNode) {\n+ root.callbackNode = null;\n+ root.callbackExpirationTime = NoWork;\n+ }\n+ }\n+}\n+\n+export function flushRoot(root: FiberRoot, expirationTime: ExpirationTime) {\n+ if (workPhase === RenderPhase || workPhase === CommitPhase) {\n+ invariant(\n+ false,\n+ 'work.commit(): Cannot commit while already rendering. This likely ' +\n+ 'means you attempted to commit from inside a lifecycle method.',\n+ );\n+ }\n+ scheduleCallback(\n+ ImmediatePriority,\n+ renderRoot.bind(null, root, expirationTime),\n+ );\n+ flushImmediateQueue();\n+}\n+\n+export function flushInteractiveUpdates() {\n+ if (workPhase === RenderPhase || workPhase === CommitPhase) {\n+ \/\/ Can't synchronously flush interactive updates if React is already\n+ \/\/ working. This is currently a no-op.\n+ \/\/ TODO: Should we fire a warning? This happens if you synchronously invoke\n+ \/\/ an input event inside an effect, like with `element.click()`.\n+ return;\n+ }\n+ flushPendingDiscreteUpdates();\n+}\n+\n+function resolveLocksOnRoot(root: FiberRoot, expirationTime: ExpirationTime) {\n+ const firstBatch = root.firstBatch;\n+ if (\n+ firstBatch !== null &&\n+ firstBatch._defer &&\n+ firstBatch._expirationTime >= expirationTime\n+ ) {\n+ root.finishedWork = root.current.alternate;\n+ root.pendingCommitExpirationTime = expirationTime;\n+ scheduleCallback(NormalPriority, () => {\n+ firstBatch._onComplete();\n+ return null;\n+ });\n+ return true;\n+ } else {\n+ return false;\n+ }\n+}\n+\n+export function deferredUpdates(fn: () => A): A {\n+ \/\/ TODO: Remove in favor of Scheduler.next\n+ return runWithPriority(NormalPriority, fn);\n+}\n+\n+export function interactiveUpdates(\n+ fn: (A, B, C) => R,\n+ a: A,\n+ b: B,\n+ c: C,\n+): R {\n+ if (workPhase === NotWorking) {\n+ \/\/ TODO: Remove this call. Instead of doing this automatically, the caller\n+ \/\/ should explicitly call flushInteractiveUpdates.\n+ flushPendingDiscreteUpdates();\n+ }\n+ return runWithPriority(UserBlockingPriority, fn.bind(null, a, b, c));\n+}\n+\n+export function syncUpdates(\n+ fn: (A, B, C) => R,\n+ a: A,\n+ b: B,\n+ c: C,\n+): R {\n+ return runWithPriority(ImmediatePriority, fn.bind(null, a, b, c));\n+}\n+\n+function flushPendingDiscreteUpdates() {\n+ if (rootsWithPendingDiscreteUpdates !== null) {\n+ \/\/ For each root with pending discrete updates, schedule a callback to\n+ \/\/ immediately flush them.\n+ const roots = rootsWithPendingDiscreteUpdates;\n+ rootsWithPendingDiscreteUpdates = null;\n+ roots.forEach((expirationTime, root) => {\n+ scheduleCallback(\n+ ImmediatePriority,\n+ renderRoot.bind(null, root, expirationTime),\n+ );\n+ });\n+ \/\/ Now flush the immediate queue.\n+ flushImmediateQueue();\n+ }\n+}\n+\n+export function batchedUpdates(fn: A => R, a: A): R {\n+ if (workPhase !== NotWorking) {\n+ \/\/ We're already working, or inside a batch, so batchedUpdates is a no-op.\n+ return fn(a);\n+ }\n+ workPhase = BatchedPhase;\n+ try {\n+ return fn(a);\n+ } finally {\n+ workPhase = NotWorking;\n+ \/\/ Flush the immediate callbacks that were scheduled during this batch\n+ flushImmediateQueue();\n+ }\n+}\n+\n+export function unbatchedUpdates(fn: (a: A) => R, a: A): R {\n+ if (workPhase !== BatchedPhase && workPhase !== FlushSyncPhase) {\n+ \/\/ We're not inside batchedUpdates or flushSync, so unbatchedUpdates is\n+ \/\/ a no-op.\n+ return fn(a);\n+ }\n+ const prevWorkPhase = workPhase;\n+ workPhase = LegacyUnbatchedPhase;\n+ try {\n+ return fn(a);\n+ } finally {\n+ workPhase = prevWorkPhase;\n+ }\n+}\n+\n+export function flushSync(fn: A => R, a: A): R {\n+ if (workPhase === RenderPhase || workPhase === CommitPhase) {\n+ invariant(\n+ false,\n+ 'flushSync was called from inside a lifecycle method. It cannot be ' +\n+ 'called when React is already rendering.',\n+ );\n+ }\n+ const prevWorkPhase = workPhase;\n+ workPhase = FlushSyncPhase;\n+ try {\n+ return runWithPriority(ImmediatePriority, fn.bind(null, a));\n+ } finally {\n+ workPhase = prevWorkPhase;\n+ \/\/ Flush the immediate callbacks that were scheduled during this batch.\n+ \/\/ Note that this will happen even if batchedUpdates is higher up\n+ \/\/ the stack.\n+ flushImmediateQueue();\n+ }\n+}\n+\n+export function flushControlled(fn: () => mixed): void {\n+ const prevWorkPhase = workPhase;\n+ workPhase = BatchedPhase;\n+ try {\n+ runWithPriority(ImmediatePriority, fn);\n+ } finally {\n+ workPhase = prevWorkPhase;\n+ if (workPhase === NotWorking) {\n+ \/\/ Flush the immediate callbacks that were scheduled during this batch\n+ flushImmediateQueue();\n+ }\n+ }\n+}\n+\n+function prepareFreshStack(root, expirationTime) {\n+ root.pendingCommitExpirationTime = NoWork;\n+\n+ if (workInProgress !== null) {\n+ let interruptedWork = workInProgress.return;\n+ while (interruptedWork !== null) {\n+ unwindInterruptedWork(interruptedWork);\n+ interruptedWork = interruptedWork.return;\n+ }\n+ }\n+ workInProgressRoot = root;\n+ workInProgress = createWorkInProgress(root.current, null, expirationTime);\n+ renderExpirationTime = expirationTime;\n+ workInProgressRootExitStatus = RootIncomplete;\n+ workInProgressRootMostRecentEventTime = Sync;\n+\n+ if (__DEV__) {\n+ ReactStrictModeWarnings.discardPendingWarnings();\n+ }\n+}\n+\n+function renderRoot(\n+ root: FiberRoot,\n+ expirationTime: ExpirationTime,\n+ isSync: boolean,\n+): SchedulerCallback | null {\n+ invariant(\n+ workPhase !== RenderPhase && workPhase !== CommitPhase,\n+ 'Should not already be working.',\n+ );\n+\n+ if (enableUserTimingAPI && expirationTime !== Sync) {\n+ const didExpire = isSync;\n+ const timeoutMs = expirationTimeToMs(expirationTime);\n+ stopRequestCallbackTimer(didExpire, timeoutMs);\n+ }\n+\n+ if (root.firstPendingTime < expirationTime) {\n+ \/\/ If there's no work left at this expiration time, exit immediately. This\n+ \/\/ happens when multiple callbacks are scheduled for a single root, but an\n+ \/\/ earlier callback flushes the work of a later one.\n+ return null;\n+ }\n+\n+ if (root.pendingCommitExpirationTime === expirationTime) {\n+ \/\/ There's already a pending commit at this expiration time.\n+ root.pendingCommitExpirationTime = NoWork;\n+ return commitRoot.bind(null, root, expirationTime);\n+ }\n+\n+ flushPassiveEffects();\n+\n+ \/\/ If the root or expiration time have changed, throw out the existing stack\n+ \/\/ and prepare a fresh one. Otherwise we'll continue where we left off.\n+ if (root !== workInProgressRoot || expirationTime !== renderExpirationTime) {\n+ prepareFreshStack(root, expirationTime);\n+ startWorkOnPendingInteraction(root, expirationTime);\n+ }\n+\n+ \/\/ If we have a work-in-progress fiber, it means there's still work to do\n+ \/\/ in this root.\n+ if (workInProgress !== null) {\n+ const prevWorkPhase = workPhase;\n+ workPhase = RenderPhase;\n+ let prevDispatcher = ReactCurrentDispatcher.current;\n+ if (prevDispatcher === null) {\n+ \/\/ The React isomorphic package does not include a default dispatcher.\n+ \/\/ Instead the first renderer will lazily attach one, in order to give\n+ \/\/ nicer error messages.\n+ prevDispatcher = ContextOnlyDispatcher;\n+ }\n+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;\n+ let prevInteractions: Set | null = null;\n+ if (enableSchedulerTracing) {\n+ prevInteractions = __interactionsRef.current;\n+ __interactionsRef.current = root.memoizedInteractions;\n+ }\n+\n+ startWorkLoopTimer(workInProgress);\n+\n+ \/\/ TODO: Fork renderRoot into renderRootSync and renderRootAsync\n+ if (isSync) {\n+ if (expirationTime !== Sync) {\n+ \/\/ An async update expired. There may be other expired updates on\n+ \/\/ this root. We should render all the expired work in a\n+ \/\/ single batch.\n+ const currentTime = requestCurrentTime();\n+ if (currentTime < expirationTime) {\n+ \/\/ Restart at the current time.\n+ workPhase = prevWorkPhase;\n+ resetContextDependencies();\n+ ReactCurrentDispatcher.current = prevDispatcher;\n+ if (enableSchedulerTracing) {\n+ __interactionsRef.current = ((prevInteractions: any): Set<\n+ Interaction,\n+ >);\n+ }\n+ return renderRoot.bind(null, root, currentTime);\n+ }\n+ }\n+ } else {\n+ \/\/ Since we know we're in a React event, we can clear the current\n+ \/\/ event time. The next update will compute a new event time.\n+ currentEventTime = NoWork;\n+ }\n+\n+ do {\n+ try {\n+ if (isSync) {\n+ workLoopSync();\n+ } else {\n+ workLoop();\n+ }\n+ break;\n+ } catch (thrownValue) {\n+ \/\/ Reset module-level state that was set during the render phase.\n+ resetContextDependencies();\n+ resetHooks();\n+\n+ const sourceFiber = workInProgress;\n+ if (sourceFiber === null || sourceFiber.return === null) {\n+ \/\/ Expected to be working on a non-root fiber. This is a fatal error\n+ \/\/ because there's no ancestor that can handle it; the root is\n+ \/\/ supposed to capture all errors that weren't caught by an error\n+ \/\/ boundary.\n+ prepareFreshStack(root, expirationTime);\n+ workPhase = prevWorkPhase;\n+ throw thrownValue;\n+ }\n+\n+ if (enableProfilerTimer && sourceFiber.mode & ProfileMode) {\n+ \/\/ Record the time spent rendering before an error was thrown. This\n+ \/\/ avoids inaccurate Profiler durations in the case of a\n+ \/\/ suspended render.\n+ stopProfilerTimerIfRunningAndRecordDelta(sourceFiber, true);\n+ }\n+\n+ const returnFiber = sourceFiber.return;\n+ throwException(\n+ root,\n+ returnFiber,\n+ sourceFiber,\n+ thrownValue,\n+ renderExpirationTime,\n+ );\n+ workInProgress = completeUnitOfWork(sourceFiber);\n+ }\n+ } while (true);\n+\n+ workPhase = prevWorkPhase;\n+ resetContextDependencies();\n+ ReactCurrentDispatcher.current = prevDispatcher;\n+ if (enableSchedulerTracing) {\n+ __interactionsRef.current = ((prevInteractions: any): Set);\n+ }\n+\n+ if (workInProgress !== null) {\n+ \/\/ There's still work left over. Return a continuation.\n+ stopInterruptedWorkLoopTimer();\n+ if (expirationTime !== Sync) {\n+ startRequestCallbackTimer();\n+ }\n+ return renderRoot.bind(null, root, expirationTime);\n+ }\n+ }\n+\n+ \/\/ We now have a consistent tree. The next step is either to commit it, or, if\n+ \/\/ something suspended, wait to commit it after a timeout.\n+ stopFinishedWorkLoopTimer();\n+\n+ const isLocked = resolveLocksOnRoot(root, expirationTime);\n+ if (isLocked) {\n+ \/\/ This root has a lock that prevents it from committing. Exit. If we begin\n+ \/\/ work on the root again, without any intervening updates, it will finish\n+ \/\/ without doing additional work.\n+ return null;\n+ }\n+\n+ \/\/ Set this to null to indicate there's no in-progress render.\n+ workInProgressRoot = null;\n+\n+ switch (workInProgressRootExitStatus) {\n+ case RootIncomplete: {\n+ invariant(false, 'Should have a work-in-progress.');\n+ }\n+ \/\/ Flow knows about invariant, so it compains if I add a break statement,\n+ \/\/ but eslint doesn't know about invariant, so it complains if I do.\n+ \/\/ eslint-disable-next-line no-fallthrough\n+ case RootErrored: {\n+ \/\/ An error was thrown. First check if there is lower priority work\n+ \/\/ scheduled on this root.\n+ const lastPendingTime = root.lastPendingTime;\n+ if (root.lastPendingTime < expirationTime) {\n+ \/\/ There's lower priority work. Before raising the error, try rendering\n+ \/\/ at the lower priority to see if it fixes it. Use a continuation to\n+ \/\/ maintain the existing priority and position in the queue.\n+ return renderRoot.bind(null, root, lastPendingTime);\n+ }\n+ if (!isSync) {\n+ \/\/ If we're rendering asynchronously, it's possible the error was\n+ \/\/ caused by tearing due to a mutation during an event. Try rendering\n+ \/\/ one more time without yiedling to events.\n+ prepareFreshStack(root, expirationTime);\n+ scheduleCallback(\n+ ImmediatePriority,\n+ renderRoot.bind(null, root, expirationTime),\n+ );\n+ return null;\n+ }\n+ \/\/ If we're already rendering synchronously, commit the root in its\n+ \/\/ errored state.\n+ return commitRoot.bind(null, root, expirationTime);\n+ }\n+ case RootSuspended: {\n+ if (!isSync) {\n+ const lastPendingTime = root.lastPendingTime;\n+ if (root.lastPendingTime < expirationTime) {\n+ \/\/ There's lower priority work. It might be unsuspended. Try rendering\n+ \/\/ at that level.\n+ return renderRoot.bind(null, root, lastPendingTime);\n+ }\n+ \/\/ If workInProgressRootMostRecentEventTime is Sync, that means we didn't\n+ \/\/ track any event times. That can happen if we retried but nothing switched\n+ \/\/ from fallback to content. There's no reason to delay doing no work.\n+ if (workInProgressRootMostRecentEventTime !== Sync) {\n+ let msUntilTimeout = computeMsUntilTimeout(\n+ workInProgressRootMostRecentEventTime,\n+ expirationTime,\n+ );\n+ \/\/ Don't bother with a very short suspense time.\n+ if (msUntilTimeout > 10) {\n+ \/\/ The render is suspended, it hasn't timed out, and there's no lower\n+ \/\/ priority work to do. Instead of committing the fallback\n+ \/\/ immediately, wait for more data to arrive.\n+ root.timeoutHandle = scheduleTimeout(\n+ commitRoot.bind(null, root, expirationTime),\n+ msUntilTimeout,\n+ );\n+ return null;\n+ }\n+ }\n+ }\n+ \/\/ The work expired. Commit immediately.\n+ return commitRoot.bind(null, root, expirationTime);\n+ }\n+ case RootCompleted: {\n+ \/\/ The work completed. Ready to commit.\n+ return commitRoot.bind(null, root, expirationTime);\n+ }\n+ default: {\n+ invariant(false, 'Unknown root exit status.');\n+ }\n+ }\n+}\n+\n+export function markRenderEventTime(expirationTime: ExpirationTime): void {\n+ if (expirationTime < workInProgressRootMostRecentEventTime) {\n+ workInProgressRootMostRecentEventTime = expirationTime;\n+ }\n+}\n+\n+export function renderDidSuspend(): void {\n+ if (workInProgressRootExitStatus === RootIncomplete) {\n+ workInProgressRootExitStatus = RootSuspended;\n+ }\n+}\n+\n+export function renderDidError() {\n+ if (\n+ workInProgressRootExitStatus === RootIncomplete ||\n+ workInProgressRootExitStatus === RootSuspended\n+ ) {\n+ workInProgressRootExitStatus = RootErrored;\n+ }\n+}\n+\n+function inferTimeFromExpirationTime(expirationTime: ExpirationTime): number {\n+ \/\/ We don't know exactly when the update was scheduled, but we can infer an\n+ \/\/ approximate start time from the expiration time.\n+ const earliestExpirationTimeMs = expirationTimeToMs(expirationTime);\n+ return earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION + initialTimeMs;\n+}\n+\n+function workLoopSync() {\n+ \/\/ Already timed out, so perform work without checking if we need to yield.\n+ while (workInProgress !== null) {\n+ workInProgress = performUnitOfWork(workInProgress);\n+ }\n+}\n+\n+function workLoop() {\n+ \/\/ Perform work until Scheduler asks us to yield\n+ while (workInProgress !== null && !shouldYield()) {\n+ workInProgress = performUnitOfWork(workInProgress);\n+ }\n+}\n+\n+function performUnitOfWork(unitOfWork: Fiber): Fiber | null {\n+ \/\/ The current, flushed, state of this fiber is the alternate. Ideally\n+ \/\/ nothing should rely on this, but relying on it here means that we don't\n+ \/\/ need an additional field on the work in progress.\n+ const current = unitOfWork.alternate;\n+\n+ startWorkTimer(unitOfWork);\n+ setCurrentDebugFiberInDEV(unitOfWork);\n+\n+ let next;\n+ if (enableProfilerTimer && (unitOfWork.mode & ProfileMode) !== NoContext) {\n+ startProfilerTimer(unitOfWork);\n+ next = beginWork(current, unitOfWork, renderExpirationTime);\n+ stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);\n+ } else {\n+ next = beginWork(current, unitOfWork, renderExpirationTime);\n+ }\n+\n+ resetCurrentDebugFiberInDEV();\n+ unitOfWork.memoizedProps = unitOfWork.pendingProps;\n+ if (next === null) {\n+ \/\/ If this doesn't spawn new work, complete the current work.\n+ next = completeUnitOfWork(unitOfWork);\n+ }\n+\n+ ReactCurrentOwner.current = null;\n+ return next;\n+}\n+\n+function completeUnitOfWork(unitOfWork: Fiber): Fiber | null {\n+ \/\/ Attempt to complete the current unit of work, then move to the next\n+ \/\/ sibling. If there are no more siblings, return to the parent fiber.\n+ workInProgress = unitOfWork;\n+ do {\n+ \/\/ The current, flushed, state of this fiber is the alternate. Ideally\n+ \/\/ nothing should rely on this, but relying on it here means that we don't\n+ \/\/ need an additional field on the work in progress.\n+ const current = workInProgress.alternate;\n+ const returnFiber = workInProgress.return;\n+\n+ \/\/ Check if the work completed or if something threw.\n+ if ((workInProgress.effectTag & Incomplete) === NoEffect) {\n+ setCurrentDebugFiberInDEV(workInProgress);\n+ let next;\n+ if (\n+ !enableProfilerTimer ||\n+ (workInProgress.mode & ProfileMode) === NoContext\n+ ) {\n+ next = completeWork(current, workInProgress, renderExpirationTime);\n+ } else {\n+ startProfilerTimer(workInProgress);\n+ next = completeWork(current, workInProgress, renderExpirationTime);\n+ \/\/ Update render duration assuming we didn't error.\n+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);\n+ }\n+ stopWorkTimer(workInProgress);\n+ resetCurrentDebugFiberInDEV();\n+ resetChildExpirationTime(workInProgress);\n+\n+ if (next !== null) {\n+ \/\/ Completing this fiber spawned new work. Work on that next.\n+ return next;\n+ }\n+\n+ if (\n+ returnFiber !== null &&\n+ \/\/ Do not append effects to parents if a sibling failed to complete\n+ (returnFiber.effectTag & Incomplete) === NoEffect\n+ ) {\n+ \/\/ Append all the effects of the subtree and this fiber onto the effect\n+ \/\/ list of the parent. The completion order of the children affects the\n+ \/\/ side-effect order.\n+ if (returnFiber.firstEffect === null) {\n+ returnFiber.firstEffect = workInProgress.firstEffect;\n+ }\n+ if (workInProgress.lastEffect !== null) {\n+ if (returnFiber.lastEffect !== null) {\n+ returnFiber.lastEffect.nextEffect = workInProgress.firstEffect;\n+ }\n+ returnFiber.lastEffect = workInProgress.lastEffect;\n+ }\n+\n+ \/\/ If this fiber had side-effects, we append it AFTER the children's\n+ \/\/ side-effects. We can perform certain side-effects earlier if needed,\n+ \/\/ by doing multiple passes over the effect list. We don't want to\n+ \/\/ schedule our own side-effect on our own list because if end up\n+ \/\/ reusing children we'll schedule this effect onto itself since we're\n+ \/\/ at the end.\n+ const effectTag = workInProgress.effectTag;\n+\n+ \/\/ Skip both NoWork and PerformedWork tags when creating the effect\n+ \/\/ list. PerformedWork effect is read by React DevTools but shouldn't be\n+ \/\/ committed.\n+ if (effectTag > PerformedWork) {\n+ if (returnFiber.lastEffect !== null) {\n+ returnFiber.lastEffect.nextEffect = workInProgress;\n+ } else {\n+ returnFiber.firstEffect = workInProgress;\n+ }\n+ returnFiber.lastEffect = workInProgress;\n+ }\n+ }\n+ } else {\n+ \/\/ This fiber did not complete because something threw. Pop values off\n+ \/\/ the stack without entering the complete phase. If this is a boundary,\n+ \/\/ capture values if possible.\n+ const next = unwindWork(workInProgress, renderExpirationTime);\n+\n+ \/\/ Because this fiber did not complete, don't reset its expiration time.\n+\n+ if (\n+ enableProfilerTimer &&\n+ (workInProgress.mode & ProfileMode) !== NoContext\n+ ) {\n+ \/\/ Record the render duration for the fiber that errored.\n+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);\n+\n+ \/\/ Include the time spent working on failed children before continuing.\n+ let actualDuration = workInProgress.actualDuration;\n+ let child = workInProgress.child;\n+ while (child !== null) {\n+ actualDuration += child.actualDuration;\n+ child = child.sibling;\n+ }\n+ workInProgress.actualDuration = actualDuration;\n+ }\n+\n+ if (next !== null) {\n+ \/\/ If completing this work spawned new work, do that next. We'll come\n+ \/\/ back here again.\n+ \/\/ Since we're restarting, remove anything that is not a host effect\n+ \/\/ from the effect tag.\n+ \/\/ TODO: The name stopFailedWorkTimer is misleading because Suspense\n+ \/\/ also captures and restarts.\n+ stopFailedWorkTimer(workInProgress);\n+ next.effectTag &= HostEffectMask;\n+ return next;\n+ }\n+ stopWorkTimer(workInProgress);\n+\n+ if (returnFiber !== null) {\n+ \/\/ Mark the parent fiber as incomplete and clear its effect list.\n+ returnFiber.firstEffect = returnFiber.lastEffect = null;\n+ returnFiber.effectTag |= Incomplete;\n+ }\n+ }\n+\n+ const siblingFiber = workInProgress.sibling;\n+ if (siblingFiber !== null) {\n+ \/\/ If there is more work to do in this returnFiber, do that next.\n+ return siblingFiber;\n+ }\n+ \/\/ Otherwise, return to the parent\n+ workInProgress = returnFiber;\n+ } while (workInProgress !== null);\n+\n+ \/\/ We've reached the root.\n+ if (workInProgressRootExitStatus === RootIncomplete) {\n+ workInProgressRootExitStatus = RootCompleted;\n+ }\n+ return null;\n+}\n+\n+function resetChildExpirationTime(completedWork: Fiber) {\n+ if (\n+ renderExpirationTime !== Never &&\n+ completedWork.childExpirationTime === Never\n+ ) {\n+ \/\/ The children of this component are hidden. Don't bubble their\n+ \/\/ expiration times.\n+ return;\n+ }\n+\n+ let newChildExpirationTime = NoWork;\n+\n+ \/\/ Bubble up the earliest expiration time.\n+ if (enableProfilerTimer && (completedWork.mode & ProfileMode) !== NoContext) {\n+ \/\/ In profiling mode, resetChildExpirationTime is also used to reset\n+ \/\/ profiler durations.\n+ let actualDuration = completedWork.actualDuration;\n+ let treeBaseDuration = completedWork.selfBaseDuration;\n+\n+ \/\/ When a fiber is cloned, its actualDuration is reset to 0. This value will\n+ \/\/ only be updated if work is done on the fiber (i.e. it doesn't bailout).\n+ \/\/ When work is done, it should bubble to the parent's actualDuration. If\n+ \/\/ the fiber has not been cloned though, (meaning no work was done), then\n+ \/\/ this value will reflect the amount of time spent working on a previous\n+ \/\/ render. In that case it should not bubble. We determine whether it was\n+ \/\/ cloned by comparing the child pointer.\n+ const shouldBubbleActualDurations =\n+ completedWork.alternate === null ||\n+ completedWork.child !== completedWork.alternate.child;\n+\n+ let child = completedWork.child;\n+ while (child !== null) {\n+ const childUpdateExpirationTime = child.expirationTime;\n+ const childChildExpirationTime = child.childExpirationTime;\n+ if (childUpdateExpirationTime > newChildExpirationTime) {\n+ newChildExpirationTime = childUpdateExpirationTime;\n+ }\n+ if (childChildExpirationTime > newChildExpirationTime) {\n+ newChildExpirationTime = childChildExpirationTime;\n+ }\n+ if (shouldBubbleActualDurations) {\n+ actualDuration += child.actualDuration;\n+ }\n+ treeBaseDuration += child.treeBaseDuration;\n+ child = child.sibling;\n+ }\n+ completedWork.actualDuration = actualDuration;\n+ completedWork.treeBaseDuration = treeBaseDuration;\n+ } else {\n+ let child = completedWork.child;\n+ while (child !== null) {\n+ const childUpdateExpirationTime = child.expirationTime;\n+ const childChildExpirationTime = child.childExpirationTime;\n+ if (childUpdateExpirationTime > newChildExpirationTime) {\n+ newChildExpirationTime = childUpdateExpirationTime;\n+ }\n+ if (childChildExpirationTime > newChildExpirationTime) {\n+ newChildExpirationTime = childChildExpirationTime;\n+ }\n+ child = child.sibling;\n+ }\n+ }\n+\n+ completedWork.childExpirationTime = newChildExpirationTime;\n+}\n+\n+function commitRoot(root, expirationTime) {\n+ runWithPriority(\n+ ImmediatePriority,\n+ commitRootImpl.bind(null, root, expirationTime),\n+ );\n+ \/\/ If there are passive effects, schedule a callback to flush them. This goes\n+ \/\/ outside commitRootImpl so that it inherits the priority of the render.\n+ if (rootWithPendingPassiveEffects !== null) {\n+ const priorityLevel = getCurrentPriorityLevel();\n+ scheduleCallback(priorityLevel, () => {\n+ flushPassiveEffects();\n+ return null;\n+ });\n+ }\n+ return null;\n+}\n+\n+function commitRootImpl(root, expirationTime) {\n+ flushPassiveEffects();\n+ flushRenderPhaseStrictModeWarningsInDEV();\n+\n+ invariant(\n+ workPhase !== RenderPhase && workPhase !== CommitPhase,\n+ 'Should not already be working.',\n+ );\n+ const finishedWork = root.current.alternate;\n+ invariant(finishedWork !== null, 'Should have a work-in-progress root.');\n+\n+ \/\/ commitRoot never returns a continuation; it always finishes synchronously.\n+ \/\/ So we can clear these now to allow a new callback to be scheduled.\n+ root.callbackNode = null;\n+ root.callbackExpirationTime = NoWork;\n+\n+ startCommitTimer();\n+\n+ \/\/ Update the first and last pending times on this root. The new first\n+ \/\/ pending time is whatever is left on the root fiber.\n+ const updateExpirationTimeBeforeCommit = finishedWork.expirationTime;\n+ const childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;\n+ const firstPendingTimeBeforeCommit =\n+ childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit\n+ ? childExpirationTimeBeforeCommit\n+ : updateExpirationTimeBeforeCommit;\n+ root.firstPendingTime = firstPendingTimeBeforeCommit;\n+ if (firstPendingTimeBeforeCommit < root.lastPendingTime) {\n+ \/\/ This usually means we've finished all the work, but it can also happen\n+ \/\/ when something gets downprioritized during render, like a hidden tree.\n+ root.lastPendingTime = firstPendingTimeBeforeCommit;\n+ }\n+\n+ if (root === workInProgressRoot) {\n+ \/\/ We can reset these now that they are finished.\n+ workInProgressRoot = null;\n+ workInProgress = null;\n+ renderExpirationTime = NoWork;\n+ } else {\n+ \/\/ This indicates that the last root we worked on is not the same one that\n+ \/\/ we're committing now. This most commonly happens when a suspended root\n+ \/\/ times out.\n+ }\n+\n+ \/\/ Get the list of effects.\n+ let firstEffect;\n+ if (finishedWork.effectTag > PerformedWork) {\n+ \/\/ A fiber's effect list consists only of its children, not itself. So if\n+ \/\/ the root has an effect, we need to add it to the end of the list. The\n+ \/\/ resulting list is the set that would belong to the root's parent, if it\n+ \/\/ had one; that is, all the effects in the tree including the root.\n+ if (finishedWork.lastEffect !== null) {\n+ finishedWork.lastEffect.nextEffect = finishedWork;\n+ firstEffect = finishedWork.firstEffect;\n+ } else {\n+ firstEffect = finishedWork;\n+ }\n+ } else {\n+ \/\/ There is no effect on the root.\n+ firstEffect = finishedWork.firstEffect;\n+ }\n+\n+ if (firstEffect !== null) {\n+ const prevWorkPhase = workPhase;\n+ workPhase = CommitPhase;\n+ let prevInteractions: Set | null = null;\n+ if (enableSchedulerTracing) {\n+ prevInteractions = __interactionsRef.current;\n+ __interactionsRef.current = root.memoizedInteractions;\n+ }\n+\n+ \/\/ Reset this to null before calling lifecycles\n+ ReactCurrentOwner.current = null;\n+\n+ \/\/ The commit phase is broken into several sub-phases. We do a separate pass\n+ \/\/ of the effect list for each phase: all mutation effects come before all\n+ \/\/ layout effects, and so on.\n+\n+ \/\/ The first phase a \"before mutation\" phase. We use this phase to read the\n+ \/\/ state of the host tree right before we mutate it. This is where\n+ \/\/ getSnapshotBeforeUpdate is called.\n+ startCommitSnapshotEffectsTimer();\n+ prepareForCommit(root.containerInfo);\n+ nextEffect = firstEffect;\n+ do {\n+ if (__DEV__) {\n+ invokeGuardedCallback(null, commitBeforeMutationEffects, null);\n+ if (hasCaughtError()) {\n+ invariant(nextEffect !== null, 'Should be working on an effect.');\n+ const error = clearCaughtError();\n+ captureCommitPhaseError(nextEffect, error);\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+ } else {\n+ try {\n+ commitBeforeMutationEffects();\n+ } catch (error) {\n+ invariant(nextEffect !== null, 'Should be working on an effect.');\n+ captureCommitPhaseError(nextEffect, error);\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+ }\n+ } while (nextEffect !== null);\n+ stopCommitSnapshotEffectsTimer();\n+\n+ if (enableProfilerTimer) {\n+ \/\/ Mark the current commit time to be shared by all Profilers in this\n+ \/\/ batch. This enables them to be grouped later.\n+ recordCommitTime();\n+ }\n+\n+ \/\/ The next phase is the mutation phase, where we mutate the host tree.\n+ startCommitHostEffectsTimer();\n+ nextEffect = firstEffect;\n+ do {\n+ if (__DEV__) {\n+ invokeGuardedCallback(null, commitMutationEffects, null);\n+ if (hasCaughtError()) {\n+ invariant(nextEffect !== null, 'Should be working on an effect.');\n+ const error = clearCaughtError();\n+ captureCommitPhaseError(nextEffect, error);\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+ } else {\n+ try {\n+ commitMutationEffects();\n+ } catch (error) {\n+ invariant(nextEffect !== null, 'Should be working on an effect.');\n+ captureCommitPhaseError(nextEffect, error);\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+ }\n+ } while (nextEffect !== null);\n+ stopCommitHostEffectsTimer();\n+ resetAfterCommit(root.containerInfo);\n+\n+ \/\/ The work-in-progress tree is now the current tree. This must come after\n+ \/\/ the mutation phase, so that the previous tree is still current during\n+ \/\/ componentWillUnmount, but before the layout phase, so that the finished\n+ \/\/ work is current during componentDidMount\/Update.\n+ root.current = finishedWork;\n+\n+ \/\/ The next phase is the layout phase, where we call effects that read\n+ \/\/ the host tree after it's been mutated. The idiomatic use case for this is\n+ \/\/ layout, but class component lifecycles also fire here for legacy reasons.\n+ startCommitLifeCyclesTimer();\n+ nextEffect = firstEffect;\n+ do {\n+ if (__DEV__) {\n+ invokeGuardedCallback(\n+ null,\n+ commitLayoutEffects,\n+ null,\n+ root,\n+ expirationTime,\n+ );\n+ if (hasCaughtError()) {\n+ invariant(nextEffect !== null, 'Should be working on an effect.');\n+ const error = clearCaughtError();\n+ captureCommitPhaseError(nextEffect, error);\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+ } else {\n+ try {\n+ commitLayoutEffects(root, expirationTime);\n+ } catch (error) {\n+ invariant(nextEffect !== null, 'Should be working on an effect.');\n+ captureCommitPhaseError(nextEffect, error);\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+ }\n+ } while (nextEffect !== null);\n+ stopCommitLifeCyclesTimer();\n+\n+ nextEffect = null;\n+\n+ if (enableSchedulerTracing) {\n+ __interactionsRef.current = ((prevInteractions: any): Set);\n+ }\n+ workPhase = prevWorkPhase;\n+ } else {\n+ \/\/ No effects.\n+ root.current = finishedWork;\n+ \/\/ Measure these anyway so the flamegraph explicitly shows that there were\n+ \/\/ no effects.\n+ \/\/ TODO: Maybe there's a better way to report this.\n+ startCommitSnapshotEffectsTimer();\n+ stopCommitSnapshotEffectsTimer();\n+ if (enableProfilerTimer) {\n+ recordCommitTime();\n+ }\n+ startCommitHostEffectsTimer();\n+ stopCommitHostEffectsTimer();\n+ startCommitLifeCyclesTimer();\n+ stopCommitLifeCyclesTimer();\n+ }\n+\n+ stopCommitTimer();\n+\n+ if (rootDoesHavePassiveEffects) {\n+ \/\/ This commit has passive effects. Stash a reference to them. But don't\n+ \/\/ schedule a callback until after flushing layout work.\n+ rootDoesHavePassiveEffects = false;\n+ rootWithPendingPassiveEffects = root;\n+ pendingPassiveEffectsExpirationTime = expirationTime;\n+ } else {\n+ if (enableSchedulerTracing) {\n+ \/\/ If there are no passive effects, then we can complete the pending\n+ \/\/ interactions. Otherwise, we'll wait until after the passive effects\n+ \/\/ are flushed.\n+ finishPendingInteractions(root, expirationTime);\n+ }\n+ }\n+\n+ \/\/ Check if there's remaining work on this root\n+ const remainingExpirationTime = root.firstPendingTime;\n+ if (remainingExpirationTime !== NoWork) {\n+ const currentTime = requestCurrentTime();\n+ const priorityLevel = inferPriorityFromExpirationTime(\n+ currentTime,\n+ remainingExpirationTime,\n+ );\n+ scheduleCallbackForRoot(root, priorityLevel, remainingExpirationTime);\n+ } else {\n+ \/\/ If there's no remaining work, we can clear the set of already failed\n+ \/\/ error boundaries.\n+ legacyErrorBoundariesThatAlreadyFailed = null;\n+ }\n+\n+ onCommitRoot(finishedWork.stateNode);\n+\n+ if (remainingExpirationTime === Sync) {\n+ \/\/ Count the number of times the root synchronously re-renders without\n+ \/\/ finishing. If there are too many, it indicates an infinite update loop.\n+ if (root === rootWithNestedUpdates) {\n+ nestedUpdateCount++;\n+ } else {\n+ nestedUpdateCount = 0;\n+ rootWithNestedUpdates = root;\n+ }\n+ } else {\n+ nestedUpdateCount = 0;\n+ }\n+\n+ if (hasUncaughtError) {\n+ hasUncaughtError = false;\n+ const error = firstUncaughtError;\n+ firstUncaughtError = null;\n+ throw error;\n+ }\n+\n+ if (workPhase === LegacyUnbatchedPhase) {\n+ \/\/ This is a legacy edge case. We just committed the initial mount of\n+ \/\/ a ReactDOM.render-ed root inside of batchedUpdates. The commit fired\n+ \/\/ synchronously, but layout updates should be deferred until the end\n+ \/\/ of the batch.\n+ return null;\n+ }\n+\n+ \/\/ If layout work was scheduled, flush it now.\n+ flushImmediateQueue();\n+ return null;\n+}\n+\n+function commitBeforeMutationEffects() {\n+ while (nextEffect !== null) {\n+ if ((nextEffect.effectTag & Snapshot) !== NoEffect) {\n+ setCurrentDebugFiberInDEV(nextEffect);\n+ recordEffect();\n+\n+ const current = nextEffect.alternate;\n+ commitBeforeMutationEffectOnFiber(current, nextEffect);\n+\n+ resetCurrentDebugFiberInDEV();\n+ }\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+}\n+\n+function commitMutationEffects() {\n+ \/\/ TODO: Should probably move the bulk of this function to commitWork.\n+ while (nextEffect !== null) {\n+ setCurrentDebugFiberInDEV(nextEffect);\n+\n+ const effectTag = nextEffect.effectTag;\n+\n+ if (effectTag & ContentReset) {\n+ commitResetTextContent(nextEffect);\n+ }\n+\n+ if (effectTag & Ref) {\n+ const current = nextEffect.alternate;\n+ if (current !== null) {\n+ commitDetachRef(current);\n+ }\n+ }\n+\n+ \/\/ The following switch statement is only concerned about placement,\n+ \/\/ updates, and deletions. To avoid needing to add a case for every possible\n+ \/\/ bitmap value, we remove the secondary effects from the effect tag and\n+ \/\/ switch on that value.\n+ let primaryEffectTag = effectTag & (Placement | Update | Deletion);\n+ switch (primaryEffectTag) {\n+ case Placement: {\n+ commitPlacement(nextEffect);\n+ \/\/ Clear the \"placement\" from effect tag so that we know that this is\n+ \/\/ inserted, before any life-cycles like componentDidMount gets called.\n+ \/\/ TODO: findDOMNode doesn't rely on this any more but isMounted does\n+ \/\/ and isMounted is deprecated anyway so we should be able to kill this.\n+ nextEffect.effectTag &= ~Placement;\n+ break;\n+ }\n+ case PlacementAndUpdate: {\n+ \/\/ Placement\n+ commitPlacement(nextEffect);\n+ \/\/ Clear the \"placement\" from effect tag so that we know that this is\n+ \/\/ inserted, before any life-cycles like componentDidMount gets called.\n+ nextEffect.effectTag &= ~Placement;\n+\n+ \/\/ Update\n+ const current = nextEffect.alternate;\n+ commitWork(current, nextEffect);\n+ break;\n+ }\n+ case Update: {\n+ const current = nextEffect.alternate;\n+ commitWork(current, nextEffect);\n+ break;\n+ }\n+ case Deletion: {\n+ commitDeletion(nextEffect);\n+ break;\n+ }\n+ }\n+\n+ \/\/ TODO: Only record a mutation effect if primaryEffectTag is non-zero.\n+ recordEffect();\n+\n+ resetCurrentDebugFiberInDEV();\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+}\n+\n+function commitLayoutEffects(\n+ root: FiberRoot,\n+ committedExpirationTime: ExpirationTime,\n+) {\n+ \/\/ TODO: Should probably move the bulk of this function to commitWork.\n+ while (nextEffect !== null) {\n+ setCurrentDebugFiberInDEV(nextEffect);\n+\n+ const effectTag = nextEffect.effectTag;\n+\n+ if (effectTag & (Update | Callback)) {\n+ recordEffect();\n+ const current = nextEffect.alternate;\n+ commitLayoutEffectOnFiber(\n+ root,\n+ current,\n+ nextEffect,\n+ committedExpirationTime,\n+ );\n+ }\n+\n+ if (effectTag & Ref) {\n+ recordEffect();\n+ commitAttachRef(nextEffect);\n+ }\n+\n+ if (effectTag & Passive) {\n+ rootDoesHavePassiveEffects = true;\n+ }\n+\n+ resetCurrentDebugFiberInDEV();\n+ nextEffect = nextEffect.nextEffect;\n+ }\n+}\n+\n+export function flushPassiveEffects() {\n+ if (rootWithPendingPassiveEffects === null) {\n+ return false;\n+ }\n+ const root = rootWithPendingPassiveEffects;\n+ const expirationTime = pendingPassiveEffectsExpirationTime;\n+ rootWithPendingPassiveEffects = null;\n+ pendingPassiveEffectsExpirationTime = NoWork;\n+\n+ let prevInteractions: Set | null = null;\n+ if (enableSchedulerTracing) {\n+ prevInteractions = __interactionsRef.current;\n+ __interactionsRef.current = root.memoizedInteractions;\n+ }\n+\n+ invariant(\n+ workPhase !== RenderPhase && workPhase !== CommitPhase,\n+ 'Cannot flush passive effects while already rendering.',\n+ );\n+ const prevWorkPhase = workPhase;\n+ workPhase = CommitPhase;\n+\n+ \/\/ Note: This currently assumes there are no passive effects on the root\n+ \/\/ fiber, because the root is not part of its own effect list. This could\n+ \/\/ change in the future.\n+ let effect = root.current.firstEffect;\n+ while (effect !== null) {\n+ if (__DEV__) {\n+ setCurrentDebugFiberInDEV(effect);\n+ invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);\n+ if (hasCaughtError()) {\n+ invariant(effect !== null, 'Should be working on an effect.');\n+ const error = clearCaughtError();\n+ captureCommitPhaseError(effect, error);\n+ }\n+ resetCurrentDebugFiberInDEV();\n+ } else {\n+ try {\n+ commitPassiveHookEffects(effect);\n+ } catch (error) {\n+ invariant(effect !== null, 'Should be working on an effect.');\n+ captureCommitPhaseError(effect, error);\n+ }\n+ }\n+ effect = effect.nextEffect;\n+ }\n+\n+ if (enableSchedulerTracing) {\n+ __interactionsRef.current = ((prevInteractions: any): Set);\n+ finishPendingInteractions(root, expirationTime);\n+ }\n+\n+ workPhase = prevWorkPhase;\n+ flushImmediateQueue();\n+\n+ \/\/ If additional passive effects were scheduled, increment a counter. If this\n+ \/\/ exceeds the limit, we'll fire a warning.\n+ nestedPassiveUpdateCount =\n+ rootWithPendingPassiveEffects === null ? 0 : nestedPassiveUpdateCount + 1;\n+\n+ return true;\n+}\n+\n+export function isAlreadyFailedLegacyErrorBoundary(instance: mixed): boolean {\n+ return (\n+ legacyErrorBoundariesThatAlreadyFailed !== null &&\n+ legacyErrorBoundariesThatAlreadyFailed.has(instance)\n+ );\n+}\n+\n+export function markLegacyErrorBoundaryAsFailed(instance: mixed) {\n+ if (legacyErrorBoundariesThatAlreadyFailed === null) {\n+ legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);\n+ } else {\n+ legacyErrorBoundariesThatAlreadyFailed.add(instance);\n+ }\n+}\n+\n+function prepareToThrowUncaughtError(error: mixed) {\n+ if (!hasUncaughtError) {\n+ hasUncaughtError = true;\n+ firstUncaughtError = error;\n+ }\n+}\n+export const onUncaughtError = prepareToThrowUncaughtError;\n+\n+function captureCommitPhaseErrorOnRoot(\n+ rootFiber: Fiber,\n+ sourceFiber: Fiber,\n+ error: mixed,\n+) {\n+ const errorInfo = createCapturedValue(error, sourceFiber);\n+ const update = createRootErrorUpdate(rootFiber, errorInfo, Sync);\n+ enqueueUpdate(rootFiber, update);\n+ const root = markUpdateTimeFromFiberToRoot(rootFiber, Sync);\n+ if (root !== null) {\n+ scheduleCallbackForRoot(root, ImmediatePriority, Sync);\n+ }\n+}\n+\n+export function captureCommitPhaseError(sourceFiber: Fiber, error: mixed) {\n+ if (sourceFiber.tag === HostRoot) {\n+ \/\/ Error was thrown at the root. There is no parent, so the root\n+ \/\/ itself should capture it.\n+ captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);\n+ return;\n+ }\n+\n+ let fiber = sourceFiber.return;\n+ while (fiber !== null) {\n+ if (fiber.tag === HostRoot) {\n+ captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);\n+ return;\n+ } else if (fiber.tag === ClassComponent) {\n+ const ctor = fiber.type;\n+ const instance = fiber.stateNode;\n+ if (\n+ typeof ctor.getDerivedStateFromError === 'function' ||\n+ (typeof instance.componentDidCatch === 'function' &&\n+ !isAlreadyFailedLegacyErrorBoundary(instance))\n+ ) {\n+ const errorInfo = createCapturedValue(error, sourceFiber);\n+ const update = createClassErrorUpdate(\n+ fiber,\n+ errorInfo,\n+ \/\/ TODO: This is always sync\n+ Sync,\n+ );\n+ enqueueUpdate(fiber, update);\n+ const root = markUpdateTimeFromFiberToRoot(fiber, Sync);\n+ if (root !== null) {\n+ scheduleCallbackForRoot(root, ImmediatePriority, Sync);\n+ }\n+ return;\n+ }\n+ }\n+ fiber = fiber.return;\n+ }\n+}\n+\n+export function pingSuspendedRoot(\n+ root: FiberRoot,\n+ thenable: Thenable,\n+ suspendedTime: ExpirationTime,\n+) {\n+ const pingCache = root.pingCache;\n+ if (pingCache !== null) {\n+ \/\/ The thenable resolved, so we no longer need to memoize, because it will\n+ \/\/ never be thrown again.\n+ pingCache.delete(thenable);\n+ }\n+\n+ if (workInProgressRoot === root && renderExpirationTime === suspendedTime) {\n+ \/\/ Received a ping at the same priority level at which we're currently\n+ \/\/ rendering. Restart from the root. Don't need to schedule a ping because\n+ \/\/ we're already working on this tree.\n+ prepareFreshStack(root, renderExpirationTime);\n+ return;\n+ }\n+\n+ const lastPendingTime = root.lastPendingTime;\n+ if (lastPendingTime < suspendedTime) {\n+ \/\/ The root is no longer suspended at this time.\n+ return;\n+ }\n+\n+ const pingTime = root.pingTime;\n+ if (pingTime !== NoWork && pingTime < suspendedTime) {\n+ \/\/ There's already a lower priority ping scheduled.\n+ return;\n+ }\n+\n+ \/\/ Mark the time at which this ping was scheduled.\n+ root.pingTime = suspendedTime;\n+\n+ const currentTime = requestCurrentTime();\n+ const priorityLevel = inferPriorityFromExpirationTime(\n+ currentTime,\n+ suspendedTime,\n+ );\n+ scheduleCallbackForRoot(root, priorityLevel, suspendedTime);\n+}\n+\n+export function retryTimedOutBoundary(boundaryFiber: Fiber) {\n+ \/\/ The boundary fiber (a Suspense component) previously timed out and was\n+ \/\/ rendered in its fallback state. One of the promises that suspended it has\n+ \/\/ resolved, which means at least part of the tree was likely unblocked. Try\n+ \/\/ rendering again, at a new expiration time.\n+ const currentTime = requestCurrentTime();\n+ const retryTime = computeExpirationForFiber(currentTime, boundaryFiber);\n+ \/\/ TODO: Special case idle priority?\n+ const priorityLevel = inferPriorityFromExpirationTime(currentTime, retryTime);\n+ const root = markUpdateTimeFromFiberToRoot(boundaryFiber, retryTime);\n+ if (root !== null) {\n+ scheduleCallbackForRoot(root, priorityLevel, retryTime);\n+ }\n+}\n+\n+export function resolveRetryThenable(boundaryFiber: Fiber, thenable: Thenable) {\n+ let retryCache: WeakSet | Set | null;\n+ if (enableSuspenseServerRenderer) {\n+ switch (boundaryFiber.tag) {\n+ case SuspenseComponent:\n+ retryCache = boundaryFiber.stateNode;\n+ break;\n+ case DehydratedSuspenseComponent:\n+ retryCache = boundaryFiber.memoizedState;\n+ break;\n+ default:\n+ invariant(\n+ false,\n+ 'Pinged unknown suspense boundary type. ' +\n+ 'This is probably a bug in React.',\n+ );\n+ }\n+ } else {\n+ retryCache = boundaryFiber.stateNode;\n+ }\n+\n+ if (retryCache !== null) {\n+ \/\/ The thenable resolved, so we no longer need to memoize, because it will\n+ \/\/ never be thrown again.\n+ retryCache.delete(thenable);\n+ }\n+\n+ retryTimedOutBoundary(boundaryFiber);\n+}\n+\n+\/\/ Computes the next Just Noticeable Difference (JND) boundary.\n+\/\/ The theory is that a person can't tell the difference between small differences in time.\n+\/\/ Therefore, if we wait a bit longer than necessary that won't translate to a noticeable\n+\/\/ difference in the experience. However, waiting for longer might mean that we can avoid\n+\/\/ showing an intermediate loading state. The longer we have already waited, the harder it\n+\/\/ is to tell small differences in time. Therefore, the longer we've already waited,\n+\/\/ the longer we can wait additionally. At some point we have to give up though.\n+\/\/ We pick a train model where the next boundary commits at a consistent schedule.\n+\/\/ These particular numbers are vague estimates. We expect to adjust them based on research.\n+function jnd(timeElapsed: number) {\n+ return timeElapsed < 120\n+ ? 120\n+ : timeElapsed < 480\n+ ? 480\n+ : timeElapsed < 1080\n+ ? 1080\n+ : timeElapsed < 1920\n+ ? 1920\n+ : timeElapsed < 3000\n+ ? 3000\n+ : timeElapsed < 4320\n+ ? 4320\n+ : ceil(timeElapsed \/ 1960) * 1960;\n+}\n+\n+function computeMsUntilTimeout(\n+ mostRecentEventTime: ExpirationTime,\n+ committedExpirationTime: ExpirationTime,\n+) {\n+ if (disableYielding) {\n+ \/\/ Timeout immediately when yielding is disabled.\n+ return 0;\n+ }\n+\n+ const eventTimeMs: number = inferTimeFromExpirationTime(mostRecentEventTime);\n+ const currentTimeMs: number = now();\n+ const timeElapsed = currentTimeMs - eventTimeMs;\n+\n+ let msUntilTimeout = jnd(timeElapsed) - timeElapsed;\n+\n+ \/\/ Compute the time until this render pass would expire.\n+ const timeUntilExpirationMs =\n+ expirationTimeToMs(committedExpirationTime) + initialTimeMs - currentTimeMs;\n+\n+ \/\/ Clamp the timeout to the expiration time.\n+ \/\/ TODO: Once the event time is exact instead of inferred from expiration time\n+ \/\/ we don't need this.\n+ if (timeUntilExpirationMs < msUntilTimeout) {\n+ msUntilTimeout = timeUntilExpirationMs;\n+ }\n+\n+ \/\/ This is the value that is passed to `setTimeout`.\n+ return msUntilTimeout;\n+}\n+\n+function checkForNestedUpdates() {\n+ if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {\n+ nestedUpdateCount = 0;\n+ rootWithNestedUpdates = null;\n+ invariant(\n+ false,\n+ 'Maximum update depth exceeded. This can happen when a component ' +\n+ 'repeatedly calls setState inside componentWillUpdate or ' +\n+ 'componentDidUpdate. React limits the number of nested updates to ' +\n+ 'prevent infinite loops.',\n+ );\n+ }\n+\n+ if (__DEV__) {\n+ if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {\n+ nestedPassiveUpdateCount = 0;\n+ warning(\n+ false,\n+ 'Maximum update depth exceeded. This can happen when a component ' +\n+ \"calls setState inside useEffect, but useEffect either doesn't \" +\n+ 'have a dependency array, or one of the dependencies changes on ' +\n+ 'every render.',\n+ );\n+ }\n+ }\n+}\n+\n+function flushRenderPhaseStrictModeWarningsInDEV() {\n+ if (__DEV__) {\n+ ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();\n+ ReactStrictModeWarnings.flushLegacyContextWarning();\n+\n+ if (warnAboutDeprecatedLifecycles) {\n+ ReactStrictModeWarnings.flushPendingDeprecationWarnings();\n+ }\n+ }\n+}\n+\n+function stopFinishedWorkLoopTimer() {\n+ const didCompleteRoot = true;\n+ stopWorkLoopTimer(interruptedBy, didCompleteRoot);\n+ interruptedBy = null;\n+}\n+\n+function stopInterruptedWorkLoopTimer() {\n+ \/\/ TODO: Track which fiber caused the interruption.\n+ const didCompleteRoot = false;\n+ stopWorkLoopTimer(interruptedBy, didCompleteRoot);\n+ interruptedBy = null;\n+}\n+\n+function checkForInterruption(\n+ fiberThatReceivedUpdate: Fiber,\n+ updateExpirationTime: ExpirationTime,\n+) {\n+ if (\n+ enableUserTimingAPI &&\n+ workInProgressRoot !== null &&\n+ updateExpirationTime > renderExpirationTime\n+ ) {\n+ interruptedBy = fiberThatReceivedUpdate;\n+ }\n+}\n+\n+let didWarnStateUpdateForUnmountedComponent: Set | null = null;\n+function warnAboutUpdateOnUnmountedFiberInDEV(fiber) {\n+ if (__DEV__) {\n+ const tag = fiber.tag;\n+ if (\n+ tag !== HostRoot &&\n+ tag !== ClassComponent &&\n+ tag !== FunctionComponent &&\n+ tag !== ForwardRef &&\n+ tag !== MemoComponent &&\n+ tag !== SimpleMemoComponent\n+ ) {\n+ \/\/ Only warn for user-defined components, not internal ones like Suspense.\n+ return;\n+ }\n+ \/\/ We show the whole stack but dedupe on the top component's name because\n+ \/\/ the problematic code almost always lies inside that component.\n+ const componentName = getComponentName(fiber.type) || 'ReactComponent';\n+ if (didWarnStateUpdateForUnmountedComponent !== null) {\n+ if (didWarnStateUpdateForUnmountedComponent.has(componentName)) {\n+ return;\n+ }\n+ didWarnStateUpdateForUnmountedComponent.add(componentName);\n+ } else {\n+ didWarnStateUpdateForUnmountedComponent = new Set([componentName]);\n+ }\n+ warningWithoutStack(\n+ false,\n+ \"Can't perform a React state update on an unmounted component. This \" +\n+ 'is a no-op, but it indicates a memory leak in your application. To ' +\n+ 'fix, cancel all subscriptions and asynchronous tasks in %s.%s',\n+ tag === ClassComponent\n+ ? 'the componentWillUnmount method'\n+ : 'a useEffect cleanup function',\n+ getStackByFiberInDevAndProd(fiber),\n+ );\n+ }\n+}\n+\n+let beginWork;\n+if (__DEV__ && replayFailedUnitOfWorkWithInvokeGuardedCallback) {\n+ let dummyFiber = null;\n+ beginWork = (current, unitOfWork, expirationTime) => {\n+ \/\/ If a component throws an error, we replay it again in a synchronously\n+ \/\/ dispatched event, so that the debugger will treat it as an uncaught\n+ \/\/ error See ReactErrorUtils for more information.\n+\n+ \/\/ Before entering the begin phase, copy the work-in-progress onto a dummy\n+ \/\/ fiber. If beginWork throws, we'll use this to reset the state.\n+ const originalWorkInProgressCopy = assignFiberPropertiesInDEV(\n+ dummyFiber,\n+ unitOfWork,\n+ );\n+ try {\n+ return originalBeginWork(current, unitOfWork, expirationTime);\n+ } catch (originalError) {\n+ if (\n+ originalError !== null &&\n+ typeof originalError === 'object' &&\n+ typeof originalError.then === 'function'\n+ ) {\n+ \/\/ Don't replay promises. Treat everything else like an error.\n+ throw originalError;\n+ }\n+\n+ \/\/ Keep this code in sync with renderRoot; any changes here must have\n+ \/\/ corresponding changes there.\n+ resetContextDependencies();\n+ resetHooks();\n+\n+ \/\/ Unwind the failed stack frame\n+ unwindInterruptedWork(unitOfWork);\n+\n+ \/\/ Restore the original properties of the fiber.\n+ assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);\n+\n+ if (enableProfilerTimer && unitOfWork.mode & ProfileMode) {\n+ \/\/ Reset the profiler timer.\n+ startProfilerTimer(unitOfWork);\n+ }\n+\n+ \/\/ Run beginWork again.\n+ invokeGuardedCallback(\n+ null,\n+ originalBeginWork,\n+ null,\n+ current,\n+ unitOfWork,\n+ expirationTime,\n+ );\n+\n+ if (hasCaughtError()) {\n+ const replayError = clearCaughtError();\n+ \/\/ `invokeGuardedCallback` sometimes sets an expando `_suppressLogging`.\n+ \/\/ Rethrow this error instead of the original one.\n+ throw replayError;\n+ } else {\n+ \/\/ This branch is reachable if the render phase is impure.\n+ throw originalError;\n+ }\n+ }\n+ };\n+} else {\n+ beginWork = originalBeginWork;\n+}\n+\n+let didWarnAboutUpdateInRender = false;\n+let didWarnAboutUpdateInGetChildContext = false;\n+function warnAboutInvalidUpdatesOnClassComponentsInDEV(fiber) {\n+ if (__DEV__) {\n+ if (fiber.tag === ClassComponent) {\n+ switch (ReactCurrentDebugFiberPhaseInDEV) {\n+ case 'getChildContext':\n+ if (didWarnAboutUpdateInGetChildContext) {\n+ return;\n+ }\n+ warningWithoutStack(\n+ false,\n+ 'setState(...): Cannot call setState() inside getChildContext()',\n+ );\n+ didWarnAboutUpdateInGetChildContext = true;\n+ break;\n+ case 'render':\n+ if (didWarnAboutUpdateInRender) {\n+ return;\n+ }\n+ warningWithoutStack(\n+ false,\n+ 'Cannot update during an existing state transition (such as ' +\n+ 'within `render`). Render methods should be a pure function of ' +\n+ 'props and state.',\n+ );\n+ didWarnAboutUpdateInRender = true;\n+ break;\n+ }\n+ }\n+ }\n+}\n+\n+function warnIfNotCurrentlyActingUpdatesInDEV(fiber: Fiber): void {\n+ if (__DEV__) {\n+ if (\n+ workPhase === NotWorking &&\n+ ReactShouldWarnActingUpdates.current === false\n+ ) {\n+ warningWithoutStack(\n+ false,\n+ 'An update to %s inside a test was not wrapped in act(...).\\n\\n' +\n+ 'When testing, code that causes React state updates should be ' +\n+ 'wrapped into act(...):\\n\\n' +\n+ 'act(() => {\\n' +\n+ ' \/* fire events that update state *\/\\n' +\n+ '});\\n' +\n+ '\/* assert on the output *\/\\n\\n' +\n+ \"This ensures that you're testing the behavior the user would see \" +\n+ 'in the browser.' +\n+ ' Learn more at https:\/\/fb.me\/react-wrap-tests-with-act' +\n+ '%s',\n+ getComponentName(fiber.type),\n+ getStackByFiberInDevAndProd(fiber),\n+ );\n+ }\n+ }\n+}\n+\n+export const warnIfNotCurrentlyActingUpdatesInDev = warnIfNotCurrentlyActingUpdatesInDEV;\n+\n+function computeThreadID(root, expirationTime) {\n+ \/\/ Interaction threads are unique per root and expiration time.\n+ return expirationTime * 1000 + root.interactionThreadID;\n+}\n+\n+function schedulePendingInteraction(root, expirationTime) {\n+ \/\/ This is called when work is scheduled on a root. It sets up a pending\n+ \/\/ interaction, which is completed once the work commits.\n+ if (!enableSchedulerTracing) {\n+ return;\n+ }\n+\n+ const interactions = __interactionsRef.current;\n+ if (interactions.size > 0) {\n+ const pendingInteractionMap = root.pendingInteractionMap;\n+ const pendingInteractions = pendingInteractionMap.get(expirationTime);\n+ if (pendingInteractions != null) {\n+ interactions.forEach(interaction => {\n+ if (!pendingInteractions.has(interaction)) {\n+ \/\/ Update the pending async work count for previously unscheduled interaction.\n+ interaction.__count++;\n+ }\n+\n+ pendingInteractions.add(interaction);\n+ });\n+ } else {\n+ pendingInteractionMap.set(expirationTime, new Set(interactions));\n+\n+ \/\/ Update the pending async work count for the current interactions.\n+ interactions.forEach(interaction => {\n+ interaction.__count++;\n+ });\n+ }\n+\n+ const subscriber = __subscriberRef.current;\n+ if (subscriber !== null) {\n+ const threadID = computeThreadID(root, expirationTime);\n+ subscriber.onWorkScheduled(interactions, threadID);\n+ }\n+ }\n+}\n+\n+function startWorkOnPendingInteraction(root, expirationTime) {\n+ \/\/ This is called when new work is started on a root.\n+ if (!enableSchedulerTracing) {\n+ return;\n+ }\n+\n+ \/\/ Determine which interactions this batch of work currently includes, So that\n+ \/\/ we can accurately attribute time spent working on it, And so that cascading\n+ \/\/ work triggered during the render phase will be associated with it.\n+ const interactions: Set = new Set();\n+ root.pendingInteractionMap.forEach(\n+ (scheduledInteractions, scheduledExpirationTime) => {\n+ if (scheduledExpirationTime >= expirationTime) {\n+ scheduledInteractions.forEach(interaction =>\n+ interactions.add(interaction),\n+ );\n+ }\n+ },\n+ );\n+\n+ \/\/ Store the current set of interactions on the FiberRoot for a few reasons:\n+ \/\/ We can re-use it in hot functions like renderRoot() without having to\n+ \/\/ recalculate it. We will also use it in commitWork() to pass to any Profiler\n+ \/\/ onRender() hooks. This also provides DevTools with a way to access it when\n+ \/\/ the onCommitRoot() hook is called.\n+ root.memoizedInteractions = interactions;\n+\n+ if (interactions.size > 0) {\n+ const subscriber = __subscriberRef.current;\n+ if (subscriber !== null) {\n+ const threadID = computeThreadID(root, expirationTime);\n+ try {\n+ subscriber.onWorkStarted(interactions, threadID);\n+ } catch (error) {\n+ \/\/ If the subscriber throws, rethrow it in a separate task\n+ scheduleCallback(ImmediatePriority, () => {\n+ throw error;\n+ });\n+ }\n+ }\n+ }\n+}\n+\n+function finishPendingInteractions(root, committedExpirationTime) {\n+ if (!enableSchedulerTracing) {\n+ return;\n+ }\n+\n+ const earliestRemainingTimeAfterCommit = root.firstPendingTime;\n+\n+ let subscriber;\n+\n+ try {\n+ subscriber = __subscriberRef.current;\n+ if (subscriber !== null && root.memoizedInteractions.size > 0) {\n+ const threadID = computeThreadID(root, committedExpirationTime);\n+ subscriber.onWorkStopped(root.memoizedInteractions, threadID);\n+ }\n+ } catch (error) {\n+ \/\/ If the subscriber throws, rethrow it in a separate task\n+ scheduleCallback(ImmediatePriority, () => {\n+ throw error;\n+ });\n+ } finally {\n+ \/\/ Clear completed interactions from the pending Map.\n+ \/\/ Unless the render was suspended or cascading work was scheduled,\n+ \/\/ In which case– leave pending interactions until the subsequent render.\n+ const pendingInteractionMap = root.pendingInteractionMap;\n+ pendingInteractionMap.forEach(\n+ (scheduledInteractions, scheduledExpirationTime) => {\n+ \/\/ Only decrement the pending interaction count if we're done.\n+ \/\/ If there's still work at the current priority,\n+ \/\/ That indicates that we are waiting for suspense data.\n+ if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {\n+ pendingInteractionMap.delete(scheduledExpirationTime);\n+\n+ scheduledInteractions.forEach(interaction => {\n+ interaction.__count--;\n+\n+ if (subscriber !== null && interaction.__count === 0) {\n+ try {\n+ subscriber.onInteractionScheduledWorkCompleted(interaction);\n+ } catch (error) {\n+ \/\/ If the subscriber throws, rethrow it in a separate task\n+ scheduleCallback(ImmediatePriority, () => {\n+ throw error;\n+ });\n+ }\n+ }\n+ });\n+ }\n+ },\n+ );\n+ }\n+}\ndiff --git a\/packages\/react-reconciler\/src\/ReactFiberScheduler.new.js b\/packages\/react-reconciler\/src\/ReactFiberScheduler.new.js\ndeleted file mode 100644\nindex 9c1065a568..0000000000\n--- a\/packages\/react-reconciler\/src\/ReactFiberScheduler.new.js\n+++ \/dev\/null\n@@ -1,2244 +0,0 @@\n-\/**\n- * Copyright (c) Facebook, Inc. and its affiliates.\n- *\n- * This source code is licensed under the MIT license found in the\n- * LICENSE file in the root directory of this source tree.\n- *\n- * @flow\n- *\/\n-\n-import type {Fiber} from '.\/ReactFiber';\n-import type {FiberRoot} from '.\/ReactFiberRoot';\n-import type {ExpirationTime} from '.\/ReactFiberExpirationTime';\n-import type {\n- ReactPriorityLevel,\n- SchedulerCallback,\n-} from '.\/SchedulerWithReactIntegration';\n-import type {Interaction} from 'scheduler\/src\/Tracing';\n-\n-import {\n- warnAboutDeprecatedLifecycles,\n- enableUserTimingAPI,\n- enableSuspenseServerRenderer,\n- replayFailedUnitOfWorkWithInvokeGuardedCallback,\n- enableProfilerTimer,\n- disableYielding,\n- enableSchedulerTracing,\n-} from 'shared\/ReactFeatureFlags';\n-import ReactSharedInternals from 'shared\/ReactSharedInternals';\n-import invariant from 'shared\/invariant';\n-import warning from 'shared\/warning';\n-\n-import {\n- scheduleCallback,\n- cancelCallback,\n- getCurrentPriorityLevel,\n- runWithPriority,\n- shouldYield,\n- now,\n- ImmediatePriority,\n- UserBlockingPriority,\n- NormalPriority,\n- LowPriority,\n- IdlePriority,\n- flushImmediateQueue,\n-} from '.\/SchedulerWithReactIntegration';\n-\n-import {__interactionsRef, __subscriberRef} from 'scheduler\/tracing';\n-\n-import {\n- prepareForCommit,\n- resetAfterCommit,\n- scheduleTimeout,\n- cancelTimeout,\n- noTimeout,\n-} from '.\/ReactFiberHostConfig';\n-\n-import {createWorkInProgress, assignFiberPropertiesInDEV} from '.\/ReactFiber';\n-import {NoContext, ConcurrentMode, ProfileMode} from '.\/ReactTypeOfMode';\n-import {\n- HostRoot,\n- ClassComponent,\n- SuspenseComponent,\n- DehydratedSuspenseComponent,\n- FunctionComponent,\n- ForwardRef,\n- MemoComponent,\n- SimpleMemoComponent,\n-} from 'shared\/ReactWorkTags';\n-import {\n- NoEffect,\n- PerformedWork,\n- Placement,\n- Update,\n- PlacementAndUpdate,\n- Deletion,\n- Ref,\n- ContentReset,\n- Snapshot,\n- Callback,\n- Passive,\n- Incomplete,\n- HostEffectMask,\n-} from 'shared\/ReactSideEffectTags';\n-import {\n- NoWork,\n- Sync,\n- Never,\n- msToExpirationTime,\n- expirationTimeToMs,\n- computeInteractiveExpiration,\n- computeAsyncExpiration,\n- inferPriorityFromExpirationTime,\n- LOW_PRIORITY_EXPIRATION,\n-} from '.\/ReactFiberExpirationTime';\n-import {beginWork as originalBeginWork} from '.\/ReactFiberBeginWork';\n-import {completeWork} from '.\/ReactFiberCompleteWork';\n-import {\n- throwException,\n- unwindWork,\n- unwindInterruptedWork,\n- createRootErrorUpdate,\n- createClassErrorUpdate,\n-} from '.\/ReactFiberUnwindWork';\n-import {\n- commitBeforeMutationLifeCycles as commitBeforeMutationEffectOnFiber,\n- commitLifeCycles as commitLayoutEffectOnFiber,\n- commitPassiveHookEffects,\n- commitPlacement,\n- commitWork,\n- commitDeletion,\n- commitDetachRef,\n- commitAttachRef,\n- commitResetTextContent,\n-} from '.\/ReactFiberCommitWork';\n-import {enqueueUpdate} from '.\/ReactUpdateQueue';\n-\/\/ TODO: Ahaha Andrew is bad at spellling\n-import {resetContextDependences as resetContextDependencies} from '.\/ReactFiberNewContext';\n-import {resetHooks, ContextOnlyDispatcher} from '.\/ReactFiberHooks';\n-import {createCapturedValue} from '.\/ReactCapturedValue';\n-\n-import {\n- recordCommitTime,\n- startProfilerTimer,\n- stopProfilerTimerIfRunningAndRecordDelta,\n-} from '.\/ReactProfilerTimer';\n-\n-\/\/ DEV stuff\n-import warningWithoutStack from 'shared\/warningWithoutStack';\n-import getComponentName from 'shared\/getComponentName';\n-import ReactStrictModeWarnings from '.\/ReactStrictModeWarnings';\n-import {\n- phase as ReactCurrentDebugFiberPhaseInDEV,\n- resetCurrentFiber as resetCurrentDebugFiberInDEV,\n- setCurrentFiber as setCurrentDebugFiberInDEV,\n- getStackByFiberInDevAndProd,\n-} from '.\/ReactCurrentFiber';\n-import {\n- recordEffect,\n- recordScheduleUpdate,\n- startRequestCallbackTimer,\n- stopRequestCallbackTimer,\n- startWorkTimer,\n- stopWorkTimer,\n- stopFailedWorkTimer,\n- startWorkLoopTimer,\n- stopWorkLoopTimer,\n- startCommitTimer,\n- stopCommitTimer,\n- startCommitSnapshotEffectsTimer,\n- stopCommitSnapshotEffectsTimer,\n- startCommitHostEffectsTimer,\n- stopCommitHostEffectsTimer,\n- startCommitLifeCyclesTimer,\n- stopCommitLifeCyclesTimer,\n-} from '.\/ReactDebugFiberPerf';\n-import {\n- invokeGuardedCallback,\n- hasCaughtError,\n- clearCaughtError,\n-} from 'shared\/ReactErrorUtils';\n-import {onCommitRoot} from '.\/ReactFiberDevToolsHook';\n-\n-const ceil = Math.ceil;\n-\n-const {\n- ReactCurrentDispatcher,\n- ReactCurrentOwner,\n- ReactShouldWarnActingUpdates,\n-} = ReactSharedInternals;\n-\n-type WorkPhase = 0 | 1 | 2 | 3 | 4 | 5;\n-const NotWorking = 0;\n-const BatchedPhase = 1;\n-const LegacyUnbatchedPhase = 2;\n-const FlushSyncPhase = 3;\n-const RenderPhase = 4;\n-const CommitPhase = 5;\n-\n-type RootExitStatus = 0 | 1 | 2 | 3;\n-const RootIncomplete = 0;\n-const RootErrored = 1;\n-const RootSuspended = 2;\n-const RootCompleted = 3;\n-\n-export type Thenable = {\n- then(resolve: () => mixed, reject?: () => mixed): Thenable | void,\n-};\n-\n-\/\/ The phase of work we're currently in\n-let workPhase: WorkPhase = NotWorking;\n-\/\/ The root we're working on\n-let workInProgressRoot: FiberRoot | null = null;\n-\/\/ The fiber we're working on\n-let workInProgress: Fiber | null = null;\n-\/\/ The expiration time we're rendering\n-let renderExpirationTime: ExpirationTime = NoWork;\n-\/\/ Whether to root completed, errored, suspended, etc.\n-let workInProgressRootExitStatus: RootExitStatus = RootIncomplete;\n-\/\/ Most recent event time among processed updates during this render.\n-\/\/ This is conceptually a time stamp but expressed in terms of an ExpirationTime\n-\/\/ because we deal mostly with expiration times in the hot path, so this avoids\n-\/\/ the conversion happening in the hot path.\n-let workInProgressRootMostRecentEventTime: ExpirationTime = Sync;\n-\n-let nextEffect: Fiber | null = null;\n-let hasUncaughtError = false;\n-let firstUncaughtError = null;\n-let legacyErrorBoundariesThatAlreadyFailed: Set | null = null;\n-\n-let rootDoesHavePassiveEffects: boolean = false;\n-let rootWithPendingPassiveEffects: FiberRoot | null = null;\n-let pendingPassiveEffectsExpirationTime: ExpirationTime = NoWork;\n-\n-let rootsWithPendingDiscreteUpdates: Map<\n- FiberRoot,\n- ExpirationTime,\n-> | null = null;\n-\n-\/\/ Use these to prevent an infinite loop of nested updates\n-const NESTED_UPDATE_LIMIT = 50;\n-let nestedUpdateCount: number = 0;\n-let rootWithNestedUpdates: FiberRoot | null = null;\n-\n-const NESTED_PASSIVE_UPDATE_LIMIT = 50;\n-let nestedPassiveUpdateCount: number = 0;\n-\n-let interruptedBy: Fiber | null = null;\n-\n-\/\/ Expiration times are computed by adding to the current time (the start\n-\/\/ time). However, if two updates are scheduled within the same event, we\n-\/\/ should treat their start times as simultaneous, even if the actual clock\n-\/\/ time has advanced between the first and second call.\n-\n-\/\/ In other words, because expiration times determine how updates are batched,\n-\/\/ we want all updates of like priority that occur within the same event to\n-\/\/ receive the same expiration time. Otherwise we get tearing.\n-let initialTimeMs: number = now();\n-let currentEventTime: ExpirationTime = NoWork;\n-\n-export function requestCurrentTime() {\n- if (workPhase === RenderPhase || workPhase === CommitPhase) {\n- \/\/ We're inside React, so it's fine to read the actual time.\n- return msToExpirationTime(now() - initialTimeMs);\n- }\n- \/\/ We're not inside React, so we may be in the middle of a browser event.\n- if (currentEventTime !== NoWork) {\n- \/\/ Use the same start time for all updates until we enter React again.\n- return currentEventTime;\n- }\n- \/\/ This is the first update since React yielded. Compute a new start time.\n- currentEventTime = msToExpirationTime(now() - initialTimeMs);\n- return currentEventTime;\n-}\n-\n-export function computeExpirationForFiber(\n- currentTime: ExpirationTime,\n- fiber: Fiber,\n-): ExpirationTime {\n- if ((fiber.mode & ConcurrentMode) === NoContext) {\n- return Sync;\n- }\n-\n- if (workPhase === RenderPhase) {\n- \/\/ Use whatever time we're already rendering\n- return renderExpirationTime;\n- }\n-\n- \/\/ Compute an expiration time based on the Scheduler priority.\n- let expirationTime;\n- const priorityLevel = getCurrentPriorityLevel();\n- switch (priorityLevel) {\n- case ImmediatePriority:\n- expirationTime = Sync;\n- break;\n- case UserBlockingPriority:\n- \/\/ TODO: Rename this to computeUserBlockingExpiration\n- expirationTime = computeInteractiveExpiration(currentTime);\n- break;\n- case NormalPriority:\n- case LowPriority: \/\/ TODO: Handle LowPriority\n- \/\/ TODO: Rename this to... something better.\n- expirationTime = computeAsyncExpiration(currentTime);\n- break;\n- case IdlePriority:\n- expirationTime = Never;\n- break;\n- default:\n- invariant(false, 'Expected a valid priority level');\n- }\n-\n- \/\/ If we're in the middle of rendering a tree, do not update at the same\n- \/\/ expiration time that is already rendering.\n- if (workInProgressRoot !== null && expirationTime === renderExpirationTime) {\n- \/\/ This is a trick to move this update into a separate batch\n- expirationTime -= 1;\n- }\n-\n- return expirationTime;\n-}\n-\n-let lastUniqueAsyncExpiration = NoWork;\n-export function computeUniqueAsyncExpiration(): ExpirationTime {\n- const currentTime = requestCurrentTime();\n- let result = computeAsyncExpiration(currentTime);\n- if (result <= lastUniqueAsyncExpiration) {\n- \/\/ Since we assume the current time monotonically increases, we only hit\n- \/\/ this branch when computeUniqueAsyncExpiration is fired multiple times\n- \/\/ within a 200ms window (or whatever the async bucket size is).\n- result -= 1;\n- }\n- lastUniqueAsyncExpiration = result;\n- return result;\n-}\n-\n-export function scheduleUpdateOnFiber(\n- fiber: Fiber,\n- expirationTime: ExpirationTime,\n-) {\n- checkForNestedUpdates();\n- warnAboutInvalidUpdatesOnClassComponentsInDEV(fiber);\n-\n- const root = markUpdateTimeFromFiberToRoot(fiber, expirationTime);\n- if (root === null) {\n- warnAboutUpdateOnUnmountedFiberInDEV(fiber);\n- return;\n- }\n-\n- root.pingTime = NoWork;\n-\n- checkForInterruption(fiber, expirationTime);\n- recordScheduleUpdate();\n-\n- if (expirationTime === Sync) {\n- if (workPhase === LegacyUnbatchedPhase) {\n- \/\/ This is a legacy edge case. The initial mount of a ReactDOM.render-ed\n- \/\/ root inside of batchedUpdates should be synchronous, but layout updates\n- \/\/ should be deferred until the end of the batch.\n- let callback = renderRoot(root, Sync, true);\n- while (callback !== null) {\n- callback = callback(true);\n- }\n- } else {\n- scheduleCallbackForRoot(root, ImmediatePriority, Sync);\n- if (workPhase === NotWorking) {\n- \/\/ Flush the synchronous work now, wnless we're already working or inside\n- \/\/ a batch. This is intentionally inside scheduleUpdateOnFiber instead of\n- \/\/ scheduleCallbackForFiber to preserve the ability to schedule a callback\n- \/\/ without immediately flushing it. We only do this for user-initated\n- \/\/ updates, to preserve historical behavior of sync mode.\n- flushImmediateQueue();\n- }\n- }\n- } else {\n- \/\/ TODO: computeExpirationForFiber also reads the priority. Pass the\n- \/\/ priority as an argument to that function and this one.\n- const priorityLevel = getCurrentPriorityLevel();\n- if (priorityLevel === UserBlockingPriority) {\n- \/\/ This is the result of a discrete event. Track the lowest priority\n- \/\/ discrete update per root so we can flush them early, if needed.\n- if (rootsWithPendingDiscreteUpdates === null) {\n- rootsWithPendingDiscreteUpdates = new Map([[root, expirationTime]]);\n- } else {\n- const lastDiscreteTime = rootsWithPendingDiscreteUpdates.get(root);\n- if (\n- lastDiscreteTime === undefined ||\n- lastDiscreteTime > expirationTime\n- ) {\n- rootsWithPendingDiscreteUpdates.set(root, expirationTime);\n- }\n- }\n- }\n- scheduleCallbackForRoot(root, priorityLevel, expirationTime);\n- }\n-}\n-export const scheduleWork = scheduleUpdateOnFiber;\n-\n-\/\/ This is split into a separate function so we can mark a fiber with pending\n-\/\/ work without treating it as a typical update that originates from an event;\n-\/\/ e.g. retrying a Suspense boundary isn't an update, but it does schedule work\n-\/\/ on a fiber.\n-function markUpdateTimeFromFiberToRoot(fiber, expirationTime) {\n- \/\/ Update the source fiber's expiration time\n- if (fiber.expirationTime < expirationTime) {\n- fiber.expirationTime = expirationTime;\n- }\n- let alternate = fiber.alternate;\n- if (alternate !== null && alternate.expirationTime < expirationTime) {\n- alternate.expirationTime = expirationTime;\n- }\n- \/\/ Walk the parent path to the root and update the child expiration time.\n- let node = fiber.return;\n- let root = null;\n- if (node === null && fiber.tag === HostRoot) {\n- root = fiber.stateNode;\n- } else {\n- while (node !== null) {\n- alternate = node.alternate;\n- if (node.childExpirationTime < expirationTime) {\n- node.childExpirationTime = expirationTime;\n- if (\n- alternate !== null &&\n- alternate.childExpirationTime < expirationTime\n- ) {\n- alternate.childExpirationTime = expirationTime;\n- }\n- } else if (\n- alternate !== null &&\n- alternate.childExpirationTime < expirationTime\n- ) {\n- alternate.childExpirationTime = expirationTime;\n- }\n- if (node.return === null && node.tag === HostRoot) {\n- root = node.stateNode;\n- break;\n- }\n- node = node.return;\n- }\n- }\n-\n- if (root !== null) {\n- \/\/ Update the first and last pending expiration times in this root\n- const firstPendingTime = root.firstPendingTime;\n- if (expirationTime > firstPendingTime) {\n- root.firstPendingTime = expirationTime;\n- }\n- const lastPendingTime = root.lastPendingTime;\n- if (lastPendingTime === NoWork || expirationTime < lastPendingTime) {\n- root.lastPendingTime = expirationTime;\n- }\n- }\n-\n- return root;\n-}\n-\n-\/\/ Use this function, along with runRootCallback, to ensure that only a single\n-\/\/ callback per root is scheduled. It's still possible to call renderRoot\n-\/\/ directly, but scheduling via this function helps avoid excessive callbacks.\n-\/\/ It works by storing the callback node and expiration time on the root. When a\n-\/\/ new callback comes in, it compares the expiration time to determine if it\n-\/\/ should cancel the previous one. It also relies on commitRoot scheduling a\n-\/\/ callback to render the next level, because that means we don't need a\n-\/\/ separate callback per expiration time.\n-function scheduleCallbackForRoot(\n- root: FiberRoot,\n- priorityLevel: ReactPriorityLevel,\n- expirationTime: ExpirationTime,\n-) {\n- const existingCallbackExpirationTime = root.callbackExpirationTime;\n- if (existingCallbackExpirationTime < expirationTime) {\n- \/\/ New callback has higher priority than the existing one.\n- const existingCallbackNode = root.callbackNode;\n- if (existingCallbackNode !== null) {\n- cancelCallback(existingCallbackNode);\n- }\n- root.callbackExpirationTime = expirationTime;\n- const options =\n- expirationTime === Sync\n- ? null\n- : {timeout: expirationTimeToMs(expirationTime)};\n- root.callbackNode = scheduleCallback(\n- priorityLevel,\n- runRootCallback.bind(\n- null,\n- root,\n- renderRoot.bind(null, root, expirationTime),\n- ),\n- options,\n- );\n- if (\n- enableUserTimingAPI &&\n- expirationTime !== Sync &&\n- workPhase !== RenderPhase &&\n- workPhase !== CommitPhase\n- ) {\n- \/\/ Scheduled an async callback, and we're not already working. Add an\n- \/\/ entry to the flamegraph that shows we're waiting for a callback\n- \/\/ to fire.\n- startRequestCallbackTimer();\n- }\n- }\n-\n- const timeoutHandle = root.timeoutHandle;\n- if (timeoutHandle !== noTimeout) {\n- \/\/ The root previous suspended and scheduled a timeout to commit a fallback\n- \/\/ state. Now that we have additional work, cancel the timeout.\n- root.timeoutHandle = noTimeout;\n- \/\/ $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above\n- cancelTimeout(timeoutHandle);\n- }\n-\n- \/\/ Add the current set of interactions to the pending set associated with\n- \/\/ this root.\n- schedulePendingInteraction(root, expirationTime);\n-}\n-\n-function runRootCallback(root, callback, isSync) {\n- const prevCallbackNode = root.callbackNode;\n- let continuation = null;\n- try {\n- continuation = callback(isSync);\n- if (continuation !== null) {\n- return runRootCallback.bind(null, root, continuation);\n- } else {\n- return null;\n- }\n- } finally {\n- \/\/ If the callback exits without returning a continuation, remove the\n- \/\/ corresponding callback node from the root. Unless the callback node\n- \/\/ has changed, which implies that it was already cancelled by a high\n- \/\/ priority update.\n- if (continuation === null && prevCallbackNode === root.callbackNode) {\n- root.callbackNode = null;\n- root.callbackExpirationTime = NoWork;\n- }\n- }\n-}\n-\n-export function flushRoot(root: FiberRoot, expirationTime: ExpirationTime) {\n- if (workPhase === RenderPhase || workPhase === CommitPhase) {\n- invariant(\n- false,\n- 'work.commit(): Cannot commit while already rendering. This likely ' +\n- 'means you attempted to commit from inside a lifecycle method.',\n- );\n- }\n- scheduleCallback(\n- ImmediatePriority,\n- renderRoot.bind(null, root, expirationTime),\n- );\n- flushImmediateQueue();\n-}\n-\n-export function flushInteractiveUpdates() {\n- if (workPhase === RenderPhase || workPhase === CommitPhase) {\n- \/\/ Can't synchronously flush interactive updates if React is already\n- \/\/ working. This is currently a no-op.\n- \/\/ TODO: Should we fire a warning? This happens if you synchronously invoke\n- \/\/ an input event inside an effect, like with `element.click()`.\n- return;\n- }\n- flushPendingDiscreteUpdates();\n-}\n-\n-function resolveLocksOnRoot(root: FiberRoot, expirationTime: ExpirationTime) {\n- const firstBatch = root.firstBatch;\n- if (\n- firstBatch !== null &&\n- firstBatch._defer &&\n- firstBatch._expirationTime >= expirationTime\n- ) {\n- root.finishedWork = root.current.alternate;\n- root.pendingCommitExpirationTime = expirationTime;\n- scheduleCallback(NormalPriority, () => {\n- firstBatch._onComplete();\n- return null;\n- });\n- return true;\n- } else {\n- return false;\n- }\n-}\n-\n-export function deferredUpdates (fn: () => A): A {\n- \/\/ TODO: Remove in favor of Scheduler.next\n- return runWithPriority(NormalPriority, fn);\n-}\n-\n-export function interactiveUpdates(\n- fn: (A, B, C) => R,\n- a: A,\n- b: B,\n- c: C,\n-): R {\n- if (workPhase === NotWorking) {\n- \/\/ TODO: Remove this call. Instead of doing this automatically, the caller\n- \/\/ should explicitly call flushInteractiveUpdates.\n- flushPendingDiscreteUpdates();\n- }\n- return runWithPriority(UserBlockingPriority, fn.bind(null, a, b, c));\n-}\n-\n-export function syncUpdates(\n- fn: (A, B, C) => R,\n- a: A,\n- b: B,\n- c: C,\n-): R {\n- return runWithPriority(ImmediatePriority, fn.bind(null, a, b, c));\n-}\n-\n-function flushPendingDiscreteUpdates() {\n- if (rootsWithPendingDiscreteUpdates !== null) {\n- \/\/ For each root with pending discrete updates, schedule a callback to\n- \/\/ immediately flush them.\n- const roots = rootsWithPendingDiscreteUpdates;\n- rootsWithPendingDiscreteUpdates = null;\n- roots.forEach((expirationTime, root) => {\n- scheduleCallback(\n- ImmediatePriority,\n- renderRoot.bind(null, root, expirationTime),\n- );\n- });\n- \/\/ Now flush the immediate queue.\n- flushImmediateQueue();\n- }\n-}\n-\n-export function batchedUpdates(fn: A => R, a: A): R {\n- if (workPhase !== NotWorking) {\n- \/\/ We're already working, or inside a batch, so batchedUpdates is a no-op.\n- return fn(a);\n- }\n- workPhase = BatchedPhase;\n- try {\n- return fn(a);\n- } finally {\n- workPhase = NotWorking;\n- \/\/ Flush the immediate callbacks that were scheduled during this batch\n- flushImmediateQueue();\n- }\n-}\n-\n-export function unbatchedUpdates(fn: (a: A) => R, a: A): R {\n- if (workPhase !== BatchedPhase && workPhase !== FlushSyncPhase) {\n- \/\/ We're not inside batchedUpdates or flushSync, so unbatchedUpdates is\n- \/\/ a no-op.\n- return fn(a);\n- }\n- const prevWorkPhase = workPhase;\n- workPhase = LegacyUnbatchedPhase;\n- try {\n- return fn(a);\n- } finally {\n- workPhase = prevWorkPhase;\n- }\n-}\n-\n-export function flushSync(fn: A => R, a: A): R {\n- if (workPhase === RenderPhase || workPhase === CommitPhase) {\n- invariant(\n- false,\n- 'flushSync was called from inside a lifecycle method. It cannot be ' +\n- 'called when React is already rendering.',\n- );\n- }\n- const prevWorkPhase = workPhase;\n- workPhase = FlushSyncPhase;\n- try {\n- return runWithPriority(ImmediatePriority, fn.bind(null, a));\n- } finally {\n- workPhase = prevWorkPhase;\n- \/\/ Flush the immediate callbacks that were scheduled during this batch.\n- \/\/ Note that this will happen even if batchedUpdates is higher up\n- \/\/ the stack.\n- flushImmediateQueue();\n- }\n-}\n-\n-export function flushControlled(fn: () => mixed): void {\n- const prevWorkPhase = workPhase;\n- workPhase = BatchedPhase;\n- try {\n- runWithPriority(ImmediatePriority, fn);\n- } finally {\n- workPhase = prevWorkPhase;\n- if (workPhase === NotWorking) {\n- \/\/ Flush the immediate callbacks that were scheduled during this batch\n- flushImmediateQueue();\n- }\n- }\n-}\n-\n-function prepareFreshStack(root, expirationTime) {\n- root.pendingCommitExpirationTime = NoWork;\n-\n- if (workInProgress !== null) {\n- let interruptedWork = workInProgress.return;\n- while (interruptedWork !== null) {\n- unwindInterruptedWork(interruptedWork);\n- interruptedWork = interruptedWork.return;\n- }\n- }\n- workInProgressRoot = root;\n- workInProgress = createWorkInProgress(root.current, null, expirationTime);\n- renderExpirationTime = expirationTime;\n- workInProgressRootExitStatus = RootIncomplete;\n- workInProgressRootMostRecentEventTime = Sync;\n-\n- if (__DEV__) {\n- ReactStrictModeWarnings.discardPendingWarnings();\n- }\n-}\n-\n-function renderRoot(\n- root: FiberRoot,\n- expirationTime: ExpirationTime,\n- isSync: boolean,\n-): SchedulerCallback | null {\n- invariant(\n- workPhase !== RenderPhase && workPhase !== CommitPhase,\n- 'Should not already be working.',\n- );\n-\n- if (enableUserTimingAPI && expirationTime !== Sync) {\n- const didExpire = isSync;\n- const timeoutMs = expirationTimeToMs(expirationTime);\n- stopRequestCallbackTimer(didExpire, timeoutMs);\n- }\n-\n- if (root.firstPendingTime < expirationTime) {\n- \/\/ If there's no work left at this expiration time, exit immediately. This\n- \/\/ happens when multiple callbacks are scheduled for a single root, but an\n- \/\/ earlier callback flushes the work of a later one.\n- return null;\n- }\n-\n- if (root.pendingCommitExpirationTime === expirationTime) {\n- \/\/ There's already a pending commit at this expiration time.\n- root.pendingCommitExpirationTime = NoWork;\n- return commitRoot.bind(null, root, expirationTime);\n- }\n-\n- flushPassiveEffects();\n-\n- \/\/ If the root or expiration time have changed, throw out the existing stack\n- \/\/ and prepare a fresh one. Otherwise we'll continue where we left off.\n- if (root !== workInProgressRoot || expirationTime !== renderExpirationTime) {\n- prepareFreshStack(root, expirationTime);\n- startWorkOnPendingInteraction(root, expirationTime);\n- }\n-\n- \/\/ If we have a work-in-progress fiber, it means there's still work to do\n- \/\/ in this root.\n- if (workInProgress !== null) {\n- const prevWorkPhase = workPhase;\n- workPhase = RenderPhase;\n- let prevDispatcher = ReactCurrentDispatcher.current;\n- if (prevDispatcher === null) {\n- \/\/ The React isomorphic package does not include a default dispatcher.\n- \/\/ Instead the first renderer will lazily attach one, in order to give\n- \/\/ nicer error messages.\n- prevDispatcher = ContextOnlyDispatcher;\n- }\n- ReactCurrentDispatcher.current = ContextOnlyDispatcher;\n- let prevInteractions: Set | null = null;\n- if (enableSchedulerTracing) {\n- prevInteractions = __interactionsRef.current;\n- __interactionsRef.current = root.memoizedInteractions;\n- }\n-\n- startWorkLoopTimer(workInProgress);\n-\n- \/\/ TODO: Fork renderRoot into renderRootSync and renderRootAsync\n- if (isSync) {\n- if (expirationTime !== Sync) {\n- \/\/ An async update expired. There may be other expired updates on\n- \/\/ this root. We should render all the expired work in a\n- \/\/ single batch.\n- const currentTime = requestCurrentTime();\n- if (currentTime < expirationTime) {\n- \/\/ Restart at the current time.\n- workPhase = prevWorkPhase;\n- resetContextDependencies();\n- ReactCurrentDispatcher.current = prevDispatcher;\n- if (enableSchedulerTracing) {\n- __interactionsRef.current = ((prevInteractions: any): Set<\n- Interaction,\n- >);\n- }\n- return renderRoot.bind(null, root, currentTime);\n- }\n- }\n- } else {\n- \/\/ Since we know we're in a React event, we can clear the current\n- \/\/ event time. The next update will compute a new event time.\n- currentEventTime = NoWork;\n- }\n-\n- do {\n- try {\n- if (isSync) {\n- workLoopSync();\n- } else {\n- workLoop();\n- }\n- break;\n- } catch (thrownValue) {\n- \/\/ Reset module-level state that was set during the render phase.\n- resetContextDependencies();\n- resetHooks();\n-\n- const sourceFiber = workInProgress;\n- if (sourceFiber === null || sourceFiber.return === null) {\n- \/\/ Expected to be working on a non-root fiber. This is a fatal error\n- \/\/ because there's no ancestor that can handle it; the root is\n- \/\/ supposed to capture all errors that weren't caught by an error\n- \/\/ boundary.\n- prepareFreshStack(root, expirationTime);\n- workPhase = prevWorkPhase;\n- throw thrownValue;\n- }\n-\n- if (enableProfilerTimer && sourceFiber.mode & ProfileMode) {\n- \/\/ Record the time spent rendering before an error was thrown. This\n- \/\/ avoids inaccurate Profiler durations in the case of a\n- \/\/ suspended render.\n- stopProfilerTimerIfRunningAndRecordDelta(sourceFiber, true);\n- }\n-\n- const returnFiber = sourceFiber.return;\n- throwException(\n- root,\n- returnFiber,\n- sourceFiber,\n- thrownValue,\n- renderExpirationTime,\n- );\n- workInProgress = completeUnitOfWork(sourceFiber);\n- }\n- } while (true);\n-\n- workPhase = prevWorkPhase;\n- resetContextDependencies();\n- ReactCurrentDispatcher.current = prevDispatcher;\n- if (enableSchedulerTracing) {\n- __interactionsRef.current = ((prevInteractions: any): Set);\n- }\n-\n- if (workInProgress !== null) {\n- \/\/ There's still work left over. Return a continuation.\n- stopInterruptedWorkLoopTimer();\n- if (expirationTime !== Sync) {\n- startRequestCallbackTimer();\n- }\n- return renderRoot.bind(null, root, expirationTime);\n- }\n- }\n-\n- \/\/ We now have a consistent tree. The next step is either to commit it, or, if\n- \/\/ something suspended, wait to commit it after a timeout.\n- stopFinishedWorkLoopTimer();\n-\n- const isLocked = resolveLocksOnRoot(root, expirationTime);\n- if (isLocked) {\n- \/\/ This root has a lock that prevents it from committing. Exit. If we begin\n- \/\/ work on the root again, without any intervening updates, it will finish\n- \/\/ without doing additional work.\n- return null;\n- }\n-\n- \/\/ Set this to null to indicate there's no in-progress render.\n- workInProgressRoot = null;\n-\n- switch (workInProgressRootExitStatus) {\n- case RootIncomplete: {\n- invariant(false, 'Should have a work-in-progress.');\n- }\n- \/\/ Flow knows about invariant, so it compains if I add a break statement,\n- \/\/ but eslint doesn't know about invariant, so it complains if I do.\n- \/\/ eslint-disable-next-line no-fallthrough\n- case RootErrored: {\n- \/\/ An error was thrown. First check if there is lower priority work\n- \/\/ scheduled on this root.\n- const lastPendingTime = root.lastPendingTime;\n- if (root.lastPendingTime < expirationTime) {\n- \/\/ There's lower priority work. Before raising the error, try rendering\n- \/\/ at the lower priority to see if it fixes it. Use a continuation to\n- \/\/ maintain the existing priority and position in the queue.\n- return renderRoot.bind(null, root, lastPendingTime);\n- }\n- if (!isSync) {\n- \/\/ If we're rendering asynchronously, it's possible the error was\n- \/\/ caused by tearing due to a mutation during an event. Try rendering\n- \/\/ one more time without yiedling to events.\n- prepareFreshStack(root, expirationTime);\n- scheduleCallback(\n- ImmediatePriority,\n- renderRoot.bind(null, root, expirationTime),\n- );\n- return null;\n- }\n- \/\/ If we're already rendering synchronously, commit the root in its\n- \/\/ errored state.\n- return commitRoot.bind(null, root, expirationTime);\n- }\n- case RootSuspended: {\n- if (!isSync) {\n- const lastPendingTime = root.lastPendingTime;\n- if (root.lastPendingTime < expirationTime) {\n- \/\/ There's lower priority work. It might be unsuspended. Try rendering\n- \/\/ at that level.\n- return renderRoot.bind(null, root, lastPendingTime);\n- }\n- \/\/ If workInProgressRootMostRecentEventTime is Sync, that means we didn't\n- \/\/ track any event times. That can happen if we retried but nothing switched\n- \/\/ from fallback to content. There's no reason to delay doing no work.\n- if (workInProgressRootMostRecentEventTime !== Sync) {\n- let msUntilTimeout = computeMsUntilTimeout(\n- workInProgressRootMostRecentEventTime,\n- expirationTime,\n- );\n- \/\/ Don't bother with a very short suspense time.\n- if (msUntilTimeout > 10) {\n- \/\/ The render is suspended, it hasn't timed out, and there's no lower\n- \/\/ priority work to do. Instead of committing the fallback\n- \/\/ immediately, wait for more data to arrive.\n- root.timeoutHandle = scheduleTimeout(\n- commitRoot.bind(null, root, expirationTime),\n- msUntilTimeout,\n- );\n- return null;\n- }\n- }\n- }\n- \/\/ The work expired. Commit immediately.\n- return commitRoot.bind(null, root, expirationTime);\n- }\n- case RootCompleted: {\n- \/\/ The work completed. Ready to commit.\n- return commitRoot.bind(null, root, expirationTime);\n- }\n- default: {\n- invariant(false, 'Unknown root exit status.');\n- }\n- }\n-}\n-\n-export function markRenderEventTime(expirationTime: ExpirationTime): void {\n- if (expirationTime < workInProgressRootMostRecentEventTime) {\n- workInProgressRootMostRecentEventTime = expirationTime;\n- }\n-}\n-\n-export function renderDidSuspend(): void {\n- if (workInProgressRootExitStatus === RootIncomplete) {\n- workInProgressRootExitStatus = RootSuspended;\n- }\n-}\n-\n-export function renderDidError() {\n- if (\n- workInProgressRootExitStatus === RootIncomplete ||\n- workInProgressRootExitStatus === RootSuspended\n- ) {\n- workInProgressRootExitStatus = RootErrored;\n- }\n-}\n-\n-function inferTimeFromExpirationTime(expirationTime: ExpirationTime): number {\n- \/\/ We don't know exactly when the update was scheduled, but we can infer an\n- \/\/ approximate start time from the expiration time.\n- const earliestExpirationTimeMs = expirationTimeToMs(expirationTime);\n- return earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION + initialTimeMs;\n-}\n-\n-function workLoopSync() {\n- \/\/ Already timed out, so perform work without checking if we need to yield.\n- while (workInProgress !== null) {\n- workInProgress = performUnitOfWork(workInProgress);\n- }\n-}\n-\n-function workLoop() {\n- \/\/ Perform work until Scheduler asks us to yield\n- while (workInProgress !== null && !shouldYield()) {\n- workInProgress = performUnitOfWork(workInProgress);\n- }\n-}\n-\n-function performUnitOfWork(unitOfWork: Fiber): Fiber | null {\n- \/\/ The current, flushed, state of this fiber is the alternate. Ideally\n- \/\/ nothing should rely on this, but relying on it here means that we don't\n- \/\/ need an additional field on the work in progress.\n- const current = unitOfWork.alternate;\n-\n- startWorkTimer(unitOfWork);\n- setCurrentDebugFiberInDEV(unitOfWork);\n-\n- let next;\n- if (enableProfilerTimer && (unitOfWork.mode & ProfileMode) !== NoContext) {\n- startProfilerTimer(unitOfWork);\n- next = beginWork(current, unitOfWork, renderExpirationTime);\n- stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);\n- } else {\n- next = beginWork(current, unitOfWork, renderExpirationTime);\n- }\n-\n- resetCurrentDebugFiberInDEV();\n- unitOfWork.memoizedProps = unitOfWork.pendingProps;\n- if (next === null) {\n- \/\/ If this doesn't spawn new work, complete the current work.\n- next = completeUnitOfWork(unitOfWork);\n- }\n-\n- ReactCurrentOwner.current = null;\n- return next;\n-}\n-\n-function completeUnitOfWork(unitOfWork: Fiber): Fiber | null {\n- \/\/ Attempt to complete the current unit of work, then move to the next\n- \/\/ sibling. If there are no more siblings, return to the parent fiber.\n- workInProgress = unitOfWork;\n- do {\n- \/\/ The current, flushed, state of this fiber is the alternate. Ideally\n- \/\/ nothing should rely on this, but relying on it here means that we don't\n- \/\/ need an additional field on the work in progress.\n- const current = workInProgress.alternate;\n- const returnFiber = workInProgress.return;\n-\n- \/\/ Check if the work completed or if something threw.\n- if ((workInProgress.effectTag & Incomplete) === NoEffect) {\n- setCurrentDebugFiberInDEV(workInProgress);\n- let next;\n- if (\n- !enableProfilerTimer ||\n- (workInProgress.mode & ProfileMode) === NoContext\n- ) {\n- next = completeWork(current, workInProgress, renderExpirationTime);\n- } else {\n- startProfilerTimer(workInProgress);\n- next = completeWork(current, workInProgress, renderExpirationTime);\n- \/\/ Update render duration assuming we didn't error.\n- stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);\n- }\n- stopWorkTimer(workInProgress);\n- resetCurrentDebugFiberInDEV();\n- resetChildExpirationTime(workInProgress);\n-\n- if (next !== null) {\n- \/\/ Completing this fiber spawned new work. Work on that next.\n- return next;\n- }\n-\n- if (\n- returnFiber !== null &&\n- \/\/ Do not append effects to parents if a sibling failed to complete\n- (returnFiber.effectTag & Incomplete) === NoEffect\n- ) {\n- \/\/ Append all the effects of the subtree and this fiber onto the effect\n- \/\/ list of the parent. The completion order of the children affects the\n- \/\/ side-effect order.\n- if (returnFiber.firstEffect === null) {\n- returnFiber.firstEffect = workInProgress.firstEffect;\n- }\n- if (workInProgress.lastEffect !== null) {\n- if (returnFiber.lastEffect !== null) {\n- returnFiber.lastEffect.nextEffect = workInProgress.firstEffect;\n- }\n- returnFiber.lastEffect = workInProgress.lastEffect;\n- }\n-\n- \/\/ If this fiber had side-effects, we append it AFTER the children's\n- \/\/ side-effects. We can perform certain side-effects earlier if needed,\n- \/\/ by doing multiple passes over the effect list. We don't want to\n- \/\/ schedule our own side-effect on our own list because if end up\n- \/\/ reusing children we'll schedule this effect onto itself since we're\n- \/\/ at the end.\n- const effectTag = workInProgress.effectTag;\n-\n- \/\/ Skip both NoWork and PerformedWork tags when creating the effect\n- \/\/ list. PerformedWork effect is read by React DevTools but shouldn't be\n- \/\/ committed.\n- if (effectTag > PerformedWork) {\n- if (returnFiber.lastEffect !== null) {\n- returnFiber.lastEffect.nextEffect = workInProgress;\n- } else {\n- returnFiber.firstEffect = workInProgress;\n- }\n- returnFiber.lastEffect = workInProgress;\n- }\n- }\n- } else {\n- \/\/ This fiber did not complete because something threw. Pop values off\n- \/\/ the stack without entering the complete phase. If this is a boundary,\n- \/\/ capture values if possible.\n- const next = unwindWork(workInProgress, renderExpirationTime);\n-\n- \/\/ Because this fiber did not complete, don't reset its expiration time.\n-\n- if (\n- enableProfilerTimer &&\n- (workInProgress.mode & ProfileMode) !== NoContext\n- ) {\n- \/\/ Record the render duration for the fiber that errored.\n- stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);\n-\n- \/\/ Include the time spent working on failed children before continuing.\n- let actualDuration = workInProgress.actualDuration;\n- let child = workInProgress.child;\n- while (child !== null) {\n- actualDuration += child.actualDuration;\n- child = child.sibling;\n- }\n- workInProgress.actualDuration = actualDuration;\n- }\n-\n- if (next !== null) {\n- \/\/ If completing this work spawned new work, do that next. We'll come\n- \/\/ back here again.\n- \/\/ Since we're restarting, remove anything that is not a host effect\n- \/\/ from the effect tag.\n- \/\/ TODO: The name stopFailedWorkTimer is misleading because Suspense\n- \/\/ also captures and restarts.\n- stopFailedWorkTimer(workInProgress);\n- next.effectTag &= HostEffectMask;\n- return next;\n- }\n- stopWorkTimer(workInProgress);\n-\n- if (returnFiber !== null) {\n- \/\/ Mark the parent fiber as incomplete and clear its effect list.\n- returnFiber.firstEffect = returnFiber.lastEffect = null;\n- returnFiber.effectTag |= Incomplete;\n- }\n- }\n-\n- const siblingFiber = workInProgress.sibling;\n- if (siblingFiber !== null) {\n- \/\/ If there is more work to do in this returnFiber, do that next.\n- return siblingFiber;\n- }\n- \/\/ Otherwise, return to the parent\n- workInProgress = returnFiber;\n- } while (workInProgress !== null);\n-\n- \/\/ We've reached the root.\n- if (workInProgressRootExitStatus === RootIncomplete) {\n- workInProgressRootExitStatus = RootCompleted;\n- }\n- return null;\n-}\n-\n-function resetChildExpirationTime(completedWork: Fiber) {\n- if (\n- renderExpirationTime !== Never &&\n- completedWork.childExpirationTime === Never\n- ) {\n- \/\/ The children of this component are hidden. Don't bubble their\n- \/\/ expiration times.\n- return;\n- }\n-\n- let newChildExpirationTime = NoWork;\n-\n- \/\/ Bubble up the earliest expiration time.\n- if (enableProfilerTimer && (completedWork.mode & ProfileMode) !== NoContext) {\n- \/\/ In profiling mode, resetChildExpirationTime is also used to reset\n- \/\/ profiler durations.\n- let actualDuration = completedWork.actualDuration;\n- let treeBaseDuration = completedWork.selfBaseDuration;\n-\n- \/\/ When a fiber is cloned, its actualDuration is reset to 0. This value will\n- \/\/ only be updated if work is done on the fiber (i.e. it doesn't bailout).\n- \/\/ When work is done, it should bubble to the parent's actualDuration. If\n- \/\/ the fiber has not been cloned though, (meaning no work was done), then\n- \/\/ this value will reflect the amount of time spent working on a previous\n- \/\/ render. In that case it should not bubble. We determine whether it was\n- \/\/ cloned by comparing the child pointer.\n- const shouldBubbleActualDurations =\n- completedWork.alternate === null ||\n- completedWork.child !== completedWork.alternate.child;\n-\n- let child = completedWork.child;\n- while (child !== null) {\n- const childUpdateExpirationTime = child.expirationTime;\n- const childChildExpirationTime = child.childExpirationTime;\n- if (childUpdateExpirationTime > newChildExpirationTime) {\n- newChildExpirationTime = childUpdateExpirationTime;\n- }\n- if (childChildExpirationTime > newChildExpirationTime) {\n- newChildExpirationTime = childChildExpirationTime;\n- }\n- if (shouldBubbleActualDurations) {\n- actualDuration += child.actualDuration;\n- }\n- treeBaseDuration += child.treeBaseDuration;\n- child = child.sibling;\n- }\n- completedWork.actualDuration = actualDuration;\n- completedWork.treeBaseDuration = treeBaseDuration;\n- } else {\n- let child = completedWork.child;\n- while (child !== null) {\n- const childUpdateExpirationTime = child.expirationTime;\n- const childChildExpirationTime = child.childExpirationTime;\n- if (childUpdateExpirationTime > newChildExpirationTime) {\n- newChildExpirationTime = childUpdateExpirationTime;\n- }\n- if (childChildExpirationTime > newChildExpirationTime) {\n- newChildExpirationTime = childChildExpirationTime;\n- }\n- child = child.sibling;\n- }\n- }\n-\n- completedWork.childExpirationTime = newChildExpirationTime;\n-}\n-\n-function commitRoot(root, expirationTime) {\n- runWithPriority(\n- ImmediatePriority,\n- commitRootImpl.bind(null, root, expirationTime),\n- );\n- \/\/ If there are passive effects, schedule a callback to flush them. This goes\n- \/\/ outside commitRootImpl so that it inherits the priority of the render.\n- if (rootWithPendingPassiveEffects !== null) {\n- const priorityLevel = getCurrentPriorityLevel();\n- scheduleCallback(priorityLevel, () => {\n- flushPassiveEffects();\n- return null;\n- });\n- }\n- return null;\n-}\n-\n-function commitRootImpl(root, expirationTime) {\n- flushPassiveEffects();\n- flushRenderPhaseStrictModeWarningsInDEV();\n-\n- invariant(\n- workPhase !== RenderPhase && workPhase !== CommitPhase,\n- 'Should not already be working.',\n- );\n- const finishedWork = root.current.alternate;\n- invariant(finishedWork !== null, 'Should have a work-in-progress root.');\n-\n- \/\/ commitRoot never returns a continuation; it always finishes synchronously.\n- \/\/ So we can clear these now to allow a new callback to be scheduled.\n- root.callbackNode = null;\n- root.callbackExpirationTime = NoWork;\n-\n- startCommitTimer();\n-\n- \/\/ Update the first and last pending times on this root. The new first\n- \/\/ pending time is whatever is left on the root fiber.\n- const updateExpirationTimeBeforeCommit = finishedWork.expirationTime;\n- const childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;\n- const firstPendingTimeBeforeCommit =\n- childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit\n- ? childExpirationTimeBeforeCommit\n- : updateExpirationTimeBeforeCommit;\n- root.firstPendingTime = firstPendingTimeBeforeCommit;\n- if (firstPendingTimeBeforeCommit < root.lastPendingTime) {\n- \/\/ This usually means we've finished all the work, but it can also happen\n- \/\/ when something gets downprioritized during render, like a hidden tree.\n- root.lastPendingTime = firstPendingTimeBeforeCommit;\n- }\n-\n- if (root === workInProgressRoot) {\n- \/\/ We can reset these now that they are finished.\n- workInProgressRoot = null;\n- workInProgress = null;\n- renderExpirationTime = NoWork;\n- } else {\n- \/\/ This indicates that the last root we worked on is not the same one that\n- \/\/ we're committing now. This most commonly happens when a suspended root\n- \/\/ times out.\n- }\n-\n- \/\/ Get the list of effects.\n- let firstEffect;\n- if (finishedWork.effectTag > PerformedWork) {\n- \/\/ A fiber's effect list consists only of its children, not itself. So if\n- \/\/ the root has an effect, we need to add it to the end of the list. The\n- \/\/ resulting list is the set that would belong to the root's parent, if it\n- \/\/ had one; that is, all the effects in the tree including the root.\n- if (finishedWork.lastEffect !== null) {\n- finishedWork.lastEffect.nextEffect = finishedWork;\n- firstEffect = finishedWork.firstEffect;\n- } else {\n- firstEffect = finishedWork;\n- }\n- } else {\n- \/\/ There is no effect on the root.\n- firstEffect = finishedWork.firstEffect;\n- }\n-\n- if (firstEffect !== null) {\n- const prevWorkPhase = workPhase;\n- workPhase = CommitPhase;\n- let prevInteractions: Set | null = null;\n- if (enableSchedulerTracing) {\n- prevInteractions = __interactionsRef.current;\n- __interactionsRef.current = root.memoizedInteractions;\n- }\n-\n- \/\/ Reset this to null before calling lifecycles\n- ReactCurrentOwner.current = null;\n-\n- \/\/ The commit phase is broken into several sub-phases. We do a separate pass\n- \/\/ of the effect list for each phase: all mutation effects come before all\n- \/\/ layout effects, and so on.\n-\n- \/\/ The first phase a \"before mutation\" phase. We use this phase to read the\n- \/\/ state of the host tree right before we mutate it. This is where\n- \/\/ getSnapshotBeforeUpdate is called.\n- startCommitSnapshotEffectsTimer();\n- prepareForCommit(root.containerInfo);\n- nextEffect = firstEffect;\n- do {\n- if (__DEV__) {\n- invokeGuardedCallback(null, commitBeforeMutationEffects, null);\n- if (hasCaughtError()) {\n- invariant(nextEffect !== null, 'Should be working on an effect.');\n- const error = clearCaughtError();\n- captureCommitPhaseError(nextEffect, error);\n- nextEffect = nextEffect.nextEffect;\n- }\n- } else {\n- try {\n- commitBeforeMutationEffects();\n- } catch (error) {\n- invariant(nextEffect !== null, 'Should be working on an effect.');\n- captureCommitPhaseError(nextEffect, error);\n- nextEffect = nextEffect.nextEffect;\n- }\n- }\n- } while (nextEffect !== null);\n- stopCommitSnapshotEffectsTimer();\n-\n- if (enableProfilerTimer) {\n- \/\/ Mark the current commit time to be shared by all Profilers in this\n- \/\/ batch. This enables them to be grouped later.\n- recordCommitTime();\n- }\n-\n- \/\/ The next phase is the mutation phase, where we mutate the host tree.\n- startCommitHostEffectsTimer();\n- nextEffect = firstEffect;\n- do {\n- if (__DEV__) {\n- invokeGuardedCallback(null, commitMutationEffects, null);\n- if (hasCaughtError()) {\n- invariant(nextEffect !== null, 'Should be working on an effect.');\n- const error = clearCaughtError();\n- captureCommitPhaseError(nextEffect, error);\n- nextEffect = nextEffect.nextEffect;\n- }\n- } else {\n- try {\n- commitMutationEffects();\n- } catch (error) {\n- invariant(nextEffect !== null, 'Should be working on an effect.');\n- captureCommitPhaseError(nextEffect, error);\n- nextEffect = nextEffect.nextEffect;\n- }\n- }\n- } while (nextEffect !== null);\n- stopCommitHostEffectsTimer();\n- resetAfterCommit(root.containerInfo);\n-\n- \/\/ The work-in-progress tree is now the current tree. This must come after\n- \/\/ the mutation phase, so that the previous tree is still current during\n- \/\/ componentWillUnmount, but before the layout phase, so that the finished\n- \/\/ work is current during componentDidMount\/Update.\n- root.current = finishedWork;\n-\n- \/\/ The next phase is the layout phase, where we call effects that read\n- \/\/ the host tree after it's been mutated. The idiomatic use case for this is\n- \/\/ layout, but class component lifecycles also fire here for legacy reasons.\n- startCommitLifeCyclesTimer();\n- nextEffect = firstEffect;\n- do {\n- if (__DEV__) {\n- invokeGuardedCallback(\n- null,\n- commitLayoutEffects,\n- null,\n- root,\n- expirationTime,\n- );\n- if (hasCaughtError()) {\n- invariant(nextEffect !== null, 'Should be working on an effect.');\n- const error = clearCaughtError();\n- captureCommitPhaseError(nextEffect, error);\n- nextEffect = nextEffect.nextEffect;\n- }\n- } else {\n- try {\n- commitLayoutEffects(root, expirationTime);\n- } catch (error) {\n- invariant(nextEffect !== null, 'Should be working on an effect.');\n- captureCommitPhaseError(nextEffect, error);\n- nextEffect = nextEffect.nextEffect;\n- }\n- }\n- } while (nextEffect !== null);\n- stopCommitLifeCyclesTimer();\n-\n- nextEffect = null;\n-\n- if (enableSchedulerTracing) {\n- __interactionsRef.current = ((prevInteractions: any): Set);\n- }\n- workPhase = prevWorkPhase;\n- } else {\n- \/\/ No effects.\n- root.current = finishedWork;\n- \/\/ Measure these anyway so the flamegraph explicitly shows that there were\n- \/\/ no effects.\n- \/\/ TODO: Maybe there's a better way to report this.\n- startCommitSnapshotEffectsTimer();\n- stopCommitSnapshotEffectsTimer();\n- if (enableProfilerTimer) {\n- recordCommitTime();\n- }\n- startCommitHostEffectsTimer();\n- stopCommitHostEffectsTimer();\n- startCommitLifeCyclesTimer();\n- stopCommitLifeCyclesTimer();\n- }\n-\n- stopCommitTimer();\n-\n- if (rootDoesHavePassiveEffects) {\n- \/\/ This commit has passive effects. Stash a reference to them. But don't\n- \/\/ schedule a callback until after flushing layout work.\n- rootDoesHavePassiveEffects = false;\n- rootWithPendingPassiveEffects = root;\n- pendingPassiveEffectsExpirationTime = expirationTime;\n- } else {\n- if (enableSchedulerTracing) {\n- \/\/ If there are no passive effects, then we can complete the pending\n- \/\/ interactions. Otherwise, we'll wait until after the passive effects\n- \/\/ are flushed.\n- finishPendingInteractions(root, expirationTime);\n- }\n- }\n-\n- \/\/ Check if there's remaining work on this root\n- const remainingExpirationTime = root.firstPendingTime;\n- if (remainingExpirationTime !== NoWork) {\n- const currentTime = requestCurrentTime();\n- const priorityLevel = inferPriorityFromExpirationTime(\n- currentTime,\n- remainingExpirationTime,\n- );\n- scheduleCallbackForRoot(root, priorityLevel, remainingExpirationTime);\n- } else {\n- \/\/ If there's no remaining work, we can clear the set of already failed\n- \/\/ error boundaries.\n- legacyErrorBoundariesThatAlreadyFailed = null;\n- }\n-\n- onCommitRoot(finishedWork.stateNode);\n-\n- if (remainingExpirationTime === Sync) {\n- \/\/ Count the number of times the root synchronously re-renders without\n- \/\/ finishing. If there are too many, it indicates an infinite update loop.\n- if (root === rootWithNestedUpdates) {\n- nestedUpdateCount++;\n- } else {\n- nestedUpdateCount = 0;\n- rootWithNestedUpdates = root;\n- }\n- } else {\n- nestedUpdateCount = 0;\n- }\n-\n- if (hasUncaughtError) {\n- hasUncaughtError = false;\n- const error = firstUncaughtError;\n- firstUncaughtError = null;\n- throw error;\n- }\n-\n- if (workPhase === LegacyUnbatchedPhase) {\n- \/\/ This is a legacy edge case. We just committed the initial mount of\n- \/\/ a ReactDOM.render-ed root inside of batchedUpdates. The commit fired\n- \/\/ synchronously, but layout updates should be deferred until the end\n- \/\/ of the batch.\n- return null;\n- }\n-\n- \/\/ If layout work was scheduled, flush it now.\n- flushImmediateQueue();\n- return null;\n-}\n-\n-function commitBeforeMutationEffects() {\n- while (nextEffect !== null) {\n- if ((nextEffect.effectTag & Snapshot) !== NoEffect) {\n- setCurrentDebugFiberInDEV(nextEffect);\n- recordEffect();\n-\n- const current = nextEffect.alternate;\n- commitBeforeMutationEffectOnFiber(current, nextEffect);\n-\n- resetCurrentDebugFiberInDEV();\n- }\n- nextEffect = nextEffect.nextEffect;\n- }\n-}\n-\n-function commitMutationEffects() {\n- \/\/ TODO: Should probably move the bulk of this function to commitWork.\n- while (nextEffect !== null) {\n- setCurrentDebugFiberInDEV(nextEffect);\n-\n- const effectTag = nextEffect.effectTag;\n-\n- if (effectTag & ContentReset) {\n- commitResetTextContent(nextEffect);\n- }\n-\n- if (effectTag & Ref) {\n- const current = nextEffect.alternate;\n- if (current !== null) {\n- commitDetachRef(current);\n- }\n- }\n-\n- \/\/ The following switch statement is only concerned about placement,\n- \/\/ updates, and deletions. To avoid needing to add a case for every possible\n- \/\/ bitmap value, we remove the secondary effects from the effect tag and\n- \/\/ switch on that value.\n- let primaryEffectTag = effectTag & (Placement | Update | Deletion);\n- switch (primaryEffectTag) {\n- case Placement: {\n- commitPlacement(nextEffect);\n- \/\/ Clear the \"placement\" from effect tag so that we know that this is\n- \/\/ inserted, before any life-cycles like componentDidMount gets called.\n- \/\/ TODO: findDOMNode doesn't rely on this any more but isMounted does\n- \/\/ and isMounted is deprecated anyway so we should be able to kill this.\n- nextEffect.effectTag &= ~Placement;\n- break;\n- }\n- case PlacementAndUpdate: {\n- \/\/ Placement\n- commitPlacement(nextEffect);\n- \/\/ Clear the \"placement\" from effect tag so that we know that this is\n- \/\/ inserted, before any life-cycles like componentDidMount gets called.\n- nextEffect.effectTag &= ~Placement;\n-\n- \/\/ Update\n- const current = nextEffect.alternate;\n- commitWork(current, nextEffect);\n- break;\n- }\n- case Update: {\n- const current = nextEffect.alternate;\n- commitWork(current, nextEffect);\n- break;\n- }\n- case Deletion: {\n- commitDeletion(nextEffect);\n- break;\n- }\n- }\n-\n- \/\/ TODO: Only record a mutation effect if primaryEffectTag is non-zero.\n- recordEffect();\n-\n- resetCurrentDebugFiberInDEV();\n- nextEffect = nextEffect.nextEffect;\n- }\n-}\n-\n-function commitLayoutEffects(\n- root: FiberRoot,\n- committedExpirationTime: ExpirationTime,\n-) {\n- \/\/ TODO: Should probably move the bulk of this function to commitWork.\n- while (nextEffect !== null) {\n- setCurrentDebugFiberInDEV(nextEffect);\n-\n- const effectTag = nextEffect.effectTag;\n-\n- if (effectTag & (Update | Callback)) {\n- recordEffect();\n- const current = nextEffect.alternate;\n- commitLayoutEffectOnFiber(\n- root,\n- current,\n- nextEffect,\n- committedExpirationTime,\n- );\n- }\n-\n- if (effectTag & Ref) {\n- recordEffect();\n- commitAttachRef(nextEffect);\n- }\n-\n- if (effectTag & Passive) {\n- rootDoesHavePassiveEffects = true;\n- }\n-\n- resetCurrentDebugFiberInDEV();\n- nextEffect = nextEffect.nextEffect;\n- }\n-}\n-\n-export function flushPassiveEffects() {\n- if (rootWithPendingPassiveEffects === null) {\n- return false;\n- }\n- const root = rootWithPendingPassiveEffects;\n- const expirationTime = pendingPassiveEffectsExpirationTime;\n- rootWithPendingPassiveEffects = null;\n- pendingPassiveEffectsExpirationTime = NoWork;\n-\n- let prevInteractions: Set | null = null;\n- if (enableSchedulerTracing) {\n- prevInteractions = __interactionsRef.current;\n- __interactionsRef.current = root.memoizedInteractions;\n- }\n-\n- invariant(\n- workPhase !== RenderPhase && workPhase !== CommitPhase,\n- 'Cannot flush passive effects while already rendering.',\n- );\n- const prevWorkPhase = workPhase;\n- workPhase = CommitPhase;\n-\n- \/\/ Note: This currently assumes there are no passive effects on the root\n- \/\/ fiber, because the root is not part of its own effect list. This could\n- \/\/ change in the future.\n- let effect = root.current.firstEffect;\n- while (effect !== null) {\n- if (__DEV__) {\n- setCurrentDebugFiberInDEV(effect);\n- invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);\n- if (hasCaughtError()) {\n- invariant(effect !== null, 'Should be working on an effect.');\n- const error = clearCaughtError();\n- captureCommitPhaseError(effect, error);\n- }\n- resetCurrentDebugFiberInDEV();\n- } else {\n- try {\n- commitPassiveHookEffects(effect);\n- } catch (error) {\n- invariant(effect !== null, 'Should be working on an effect.');\n- captureCommitPhaseError(effect, error);\n- }\n- }\n- effect = effect.nextEffect;\n- }\n-\n- if (enableSchedulerTracing) {\n- __interactionsRef.current = ((prevInteractions: any): Set);\n- finishPendingInteractions(root, expirationTime);\n- }\n-\n- workPhase = prevWorkPhase;\n- flushImmediateQueue();\n-\n- \/\/ If additional passive effects were scheduled, increment a counter. If this\n- \/\/ exceeds the limit, we'll fire a warning.\n- nestedPassiveUpdateCount =\n- rootWithPendingPassiveEffects === null ? 0 : nestedPassiveUpdateCount + 1;\n-\n- return true;\n-}\n-\n-export function isAlreadyFailedLegacyErrorBoundary(instance: mixed): boolean {\n- return (\n- legacyErrorBoundariesThatAlreadyFailed !== null &&\n- legacyErrorBoundariesThatAlreadyFailed.has(instance)\n- );\n-}\n-\n-export function markLegacyErrorBoundaryAsFailed(instance: mixed) {\n- if (legacyErrorBoundariesThatAlreadyFailed === null) {\n- legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);\n- } else {\n- legacyErrorBoundariesThatAlreadyFailed.add(instance);\n- }\n-}\n-\n-function prepareToThrowUncaughtError(error: mixed) {\n- if (!hasUncaughtError) {\n- hasUncaughtError = true;\n- firstUncaughtError = error;\n- }\n-}\n-export const onUncaughtError = prepareToThrowUncaughtError;\n-\n-function captureCommitPhaseErrorOnRoot(\n- rootFiber: Fiber,\n- sourceFiber: Fiber,\n- error: mixed,\n-) {\n- const errorInfo = createCapturedValue(error, sourceFiber);\n- const update = createRootErrorUpdate(rootFiber, errorInfo, Sync);\n- enqueueUpdate(rootFiber, update);\n- const root = markUpdateTimeFromFiberToRoot(rootFiber, Sync);\n- if (root !== null) {\n- scheduleCallbackForRoot(root, ImmediatePriority, Sync);\n- }\n-}\n-\n-export function captureCommitPhaseError(sourceFiber: Fiber, error: mixed) {\n- if (sourceFiber.tag === HostRoot) {\n- \/\/ Error was thrown at the root. There is no parent, so the root\n- \/\/ itself should capture it.\n- captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);\n- return;\n- }\n-\n- let fiber = sourceFiber.return;\n- while (fiber !== null) {\n- if (fiber.tag === HostRoot) {\n- captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);\n- return;\n- } else if (fiber.tag === ClassComponent) {\n- const ctor = fiber.type;\n- const instance = fiber.stateNode;\n- if (\n- typeof ctor.getDerivedStateFromError === 'function' ||\n- (typeof instance.componentDidCatch === 'function' &&\n- !isAlreadyFailedLegacyErrorBoundary(instance))\n- ) {\n- const errorInfo = createCapturedValue(error, sourceFiber);\n- const update = createClassErrorUpdate(\n- fiber,\n- errorInfo,\n- \/\/ TODO: This is always sync\n- Sync,\n- );\n- enqueueUpdate(fiber, update);\n- const root = markUpdateTimeFromFiberToRoot(fiber, Sync);\n- if (root !== null) {\n- scheduleCallbackForRoot(root, ImmediatePriority, Sync);\n- }\n- return;\n- }\n- }\n- fiber = fiber.return;\n- }\n-}\n-\n-export function pingSuspendedRoot(\n- root: FiberRoot,\n- thenable: Thenable,\n- suspendedTime: ExpirationTime,\n-) {\n- const pingCache = root.pingCache;\n- if (pingCache !== null) {\n- \/\/ The thenable resolved, so we no longer need to memoize, because it will\n- \/\/ never be thrown again.\n- pingCache.delete(thenable);\n- }\n-\n- if (workInProgressRoot === root && renderExpirationTime === suspendedTime) {\n- \/\/ Received a ping at the same priority level at which we're currently\n- \/\/ rendering. Restart from the root. Don't need to schedule a ping because\n- \/\/ we're already working on this tree.\n- prepareFreshStack(root, renderExpirationTime);\n- return;\n- }\n-\n- const lastPendingTime = root.lastPendingTime;\n- if (lastPendingTime < suspendedTime) {\n- \/\/ The root is no longer suspended at this time.\n- return;\n- }\n-\n- const pingTime = root.pingTime;\n- if (pingTime !== NoWork && pingTime < suspendedTime) {\n- \/\/ There's already a lower priority ping scheduled.\n- return;\n- }\n-\n- \/\/ Mark the time at which this ping was scheduled.\n- root.pingTime = suspendedTime;\n-\n- const currentTime = requestCurrentTime();\n- const priorityLevel = inferPriorityFromExpirationTime(\n- currentTime,\n- suspendedTime,\n- );\n- scheduleCallbackForRoot(root, priorityLevel, suspendedTime);\n-}\n-\n-export function retryTimedOutBoundary(boundaryFiber: Fiber) {\n- \/\/ The boundary fiber (a Suspense component) previously timed out and was\n- \/\/ rendered in its fallback state. One of the promises that suspended it has\n- \/\/ resolved, which means at least part of the tree was likely unblocked. Try\n- \/\/ rendering again, at a new expiration time.\n- const currentTime = requestCurrentTime();\n- const retryTime = computeExpirationForFiber(currentTime, boundaryFiber);\n- \/\/ TODO: Special case idle priority?\n- const priorityLevel = inferPriorityFromExpirationTime(currentTime, retryTime);\n- const root = markUpdateTimeFromFiberToRoot(boundaryFiber, retryTime);\n- if (root !== null) {\n- scheduleCallbackForRoot(root, priorityLevel, retryTime);\n- }\n-}\n-\n-export function resolveRetryThenable(boundaryFiber: Fiber, thenable: Thenable) {\n- let retryCache: WeakSet | Set | null;\n- if (enableSuspenseServerRenderer) {\n- switch (boundaryFiber.tag) {\n- case SuspenseComponent:\n- retryCache = boundaryFiber.stateNode;\n- break;\n- case DehydratedSuspenseComponent:\n- retryCache = boundaryFiber.memoizedState;\n- break;\n- default:\n- invariant(\n- false,\n- 'Pinged unknown suspense boundary type. ' +\n- 'This is probably a bug in React.',\n- );\n- }\n- } else {\n- retryCache = boundaryFiber.stateNode;\n- }\n-\n- if (retryCache !== null) {\n- \/\/ The thenable resolved, so we no longer need to memoize, because it will\n- \/\/ never be thrown again.\n- retryCache.delete(thenable);\n- }\n-\n- retryTimedOutBoundary(boundaryFiber);\n-}\n-\n-\/\/ Computes the next Just Noticeable Difference (JND) boundary.\n-\/\/ The theory is that a person can't tell the difference between small differences in time.\n-\/\/ Therefore, if we wait a bit longer than necessary that won't translate to a noticeable\n-\/\/ difference in the experience. However, waiting for longer might mean that we can avoid\n-\/\/ showing an intermediate loading state. The longer we have already waited, the harder it\n-\/\/ is to tell small differences in time. Therefore, the longer we've already waited,\n-\/\/ the longer we can wait additionally. At some point we have to give up though.\n-\/\/ We pick a train model where the next boundary commits at a consistent schedule.\n-\/\/ These particular numbers are vague estimates. We expect to adjust them based on research.\n-function jnd(timeElapsed: number) {\n- return timeElapsed < 120\n- ? 120\n- : timeElapsed < 480\n- ? 480\n- : timeElapsed < 1080\n- ? 1080\n- : timeElapsed < 1920\n- ? 1920\n- : timeElapsed < 3000\n- ? 3000\n- : timeElapsed < 4320\n- ? 4320\n- : ceil(timeElapsed \/ 1960) * 1960;\n-}\n-\n-function computeMsUntilTimeout(\n- mostRecentEventTime: ExpirationTime,\n- committedExpirationTime: ExpirationTime,\n-) {\n- if (disableYielding) {\n- \/\/ Timeout immediately when yielding is disabled.\n- return 0;\n- }\n-\n- const eventTimeMs: number = inferTimeFromExpirationTime(mostRecentEventTime);\n- const currentTimeMs: number = now();\n- const timeElapsed = currentTimeMs - eventTimeMs;\n-\n- let msUntilTimeout = jnd(timeElapsed) - timeElapsed;\n-\n- \/\/ Compute the time until this render pass would expire.\n- const timeUntilExpirationMs =\n- expirationTimeToMs(committedExpirationTime) + initialTimeMs - currentTimeMs;\n-\n- \/\/ Clamp the timeout to the expiration time.\n- \/\/ TODO: Once the event time is exact instead of inferred from expiration time\n- \/\/ we don't need this.\n- if (timeUntilExpirationMs < msUntilTimeout) {\n- msUntilTimeout = timeUntilExpirationMs;\n- }\n-\n- \/\/ This is the value that is passed to `setTimeout`.\n- return msUntilTimeout;\n-}\n-\n-function checkForNestedUpdates() {\n- if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {\n- nestedUpdateCount = 0;\n- rootWithNestedUpdates = null;\n- invariant(\n- false,\n- 'Maximum update depth exceeded. This can happen when a component ' +\n- 'repeatedly calls setState inside componentWillUpdate or ' +\n- 'componentDidUpdate. React limits the number of nested updates to ' +\n- 'prevent infinite loops.',\n- );\n- }\n-\n- if (__DEV__) {\n- if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {\n- nestedPassiveUpdateCount = 0;\n- warning(\n- false,\n- 'Maximum update depth exceeded. This can happen when a component ' +\n- \"calls setState inside useEffect, but useEffect either doesn't \" +\n- 'have a dependency array, or one of the dependencies changes on ' +\n- 'every render.',\n- );\n- }\n- }\n-}\n-\n-function flushRenderPhaseStrictModeWarningsInDEV() {\n- if (__DEV__) {\n- ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();\n- ReactStrictModeWarnings.flushLegacyContextWarning();\n-\n- if (warnAboutDeprecatedLifecycles) {\n- ReactStrictModeWarnings.flushPendingDeprecationWarnings();\n- }\n- }\n-}\n-\n-function stopFinishedWorkLoopTimer() {\n- const didCompleteRoot = true;\n- stopWorkLoopTimer(interruptedBy, didCompleteRoot);\n- interruptedBy = null;\n-}\n-\n-function stopInterruptedWorkLoopTimer() {\n- \/\/ TODO: Track which fiber caused the interruption.\n- const didCompleteRoot = false;\n- stopWorkLoopTimer(interruptedBy, didCompleteRoot);\n- interruptedBy = null;\n-}\n-\n-function checkForInterruption(\n- fiberThatReceivedUpdate: Fiber,\n- updateExpirationTime: ExpirationTime,\n-) {\n- if (\n- enableUserTimingAPI &&\n- workInProgressRoot !== null &&\n- updateExpirationTime > renderExpirationTime\n- ) {\n- interruptedBy = fiberThatReceivedUpdate;\n- }\n-}\n-\n-let didWarnStateUpdateForUnmountedComponent: Set | null = null;\n-function warnAboutUpdateOnUnmountedFiberInDEV(fiber) {\n- if (__DEV__) {\n- const tag = fiber.tag;\n- if (\n- tag !== HostRoot &&\n- tag !== ClassComponent &&\n- tag !== FunctionComponent &&\n- tag !== ForwardRef &&\n- tag !== MemoComponent &&\n- tag !== SimpleMemoComponent\n- ) {\n- \/\/ Only warn for user-defined components, not internal ones like Suspense.\n- return;\n- }\n- \/\/ We show the whole stack but dedupe on the top component's name because\n- \/\/ the problematic code almost always lies inside that component.\n- const componentName = getComponentName(fiber.type) || 'ReactComponent';\n- if (didWarnStateUpdateForUnmountedComponent !== null) {\n- if (didWarnStateUpdateForUnmountedComponent.has(componentName)) {\n- return;\n- }\n- didWarnStateUpdateForUnmountedComponent.add(componentName);\n- } else {\n- didWarnStateUpdateForUnmountedComponent = new Set([componentName]);\n- }\n- warningWithoutStack(\n- false,\n- \"Can't perform a React state update on an unmounted component. This \" +\n- 'is a no-op, but it indicates a memory leak in your application. To ' +\n- 'fix, cancel all subscriptions and asynchronous tasks in %s.%s',\n- tag === ClassComponent\n- ? 'the componentWillUnmount method'\n- : 'a useEffect cleanup function',\n- getStackByFiberInDevAndProd(fiber),\n- );\n- }\n-}\n-\n-let beginWork;\n-if (__DEV__ && replayFailedUnitOfWorkWithInvokeGuardedCallback) {\n- let dummyFiber = null;\n- beginWork = (current, unitOfWork, expirationTime) => {\n- \/\/ If a component throws an error, we replay it again in a synchronously\n- \/\/ dispatched event, so that the debugger will treat it as an uncaught\n- \/\/ error See ReactErrorUtils for more information.\n-\n- \/\/ Before entering the begin phase, copy the work-in-progress onto a dummy\n- \/\/ fiber. If beginWork throws, we'll use this to reset the state.\n- const originalWorkInProgressCopy = assignFiberPropertiesInDEV(\n- dummyFiber,\n- unitOfWork,\n- );\n- try {\n- return originalBeginWork(current, unitOfWork, expirationTime);\n- } catch (originalError) {\n- if (\n- originalError !== null &&\n- typeof originalError === 'object' &&\n- typeof originalError.then === 'function'\n- ) {\n- \/\/ Don't replay promises. Treat everything else like an error.\n- throw originalError;\n- }\n-\n- \/\/ Keep this code in sync with renderRoot; any changes here must have\n- \/\/ corresponding changes there.\n- resetContextDependencies();\n- resetHooks();\n-\n- \/\/ Unwind the failed stack frame\n- unwindInterruptedWork(unitOfWork);\n-\n- \/\/ Restore the original properties of the fiber.\n- assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);\n-\n- if (enableProfilerTimer && unitOfWork.mode & ProfileMode) {\n- \/\/ Reset the profiler timer.\n- startProfilerTimer(unitOfWork);\n- }\n-\n- \/\/ Run beginWork again.\n- invokeGuardedCallback(\n- null,\n- originalBeginWork,\n- null,\n- current,\n- unitOfWork,\n- expirationTime,\n- );\n-\n- if (hasCaughtError()) {\n- const replayError = clearCaughtError();\n- \/\/ `invokeGuardedCallback` sometimes sets an expando `_suppressLogging`.\n- \/\/ Rethrow this error instead of the original one.\n- throw replayError;\n- } else {\n- \/\/ This branch is reachable if the render phase is impure.\n- throw originalError;\n- }\n- }\n- };\n-} else {\n- beginWork = originalBeginWork;\n-}\n-\n-let didWarnAboutUpdateInRender = false;\n-let didWarnAboutUpdateInGetChildContext = false;\n-function warnAboutInvalidUpdatesOnClassComponentsInDEV(fiber) {\n- if (__DEV__) {\n- if (fiber.tag === ClassComponent) {\n- switch (ReactCurrentDebugFiberPhaseInDEV) {\n- case 'getChildContext':\n- if (didWarnAboutUpdateInGetChildContext) {\n- return;\n- }\n- warningWithoutStack(\n- false,\n- 'setState(...): Cannot call setState() inside getChildContext()',\n- );\n- didWarnAboutUpdateInGetChildContext = true;\n- break;\n- case 'render':\n- if (didWarnAboutUpdateInRender) {\n- return;\n- }\n- warningWithoutStack(\n- false,\n- 'Cannot update during an existing state transition (such as ' +\n- 'within `render`). Render methods should be a pure function of ' +\n- 'props and state.',\n- );\n- didWarnAboutUpdateInRender = true;\n- break;\n- }\n- }\n- }\n-}\n-\n-function warnIfNotCurrentlyActingUpdatesInDEV(fiber: Fiber): void {\n- if (__DEV__) {\n- if (\n- workPhase === NotWorking &&\n- ReactShouldWarnActingUpdates.current === false\n- ) {\n- warningWithoutStack(\n- false,\n- 'An update to %s inside a test was not wrapped in act(...).\\n\\n' +\n- 'When testing, code that causes React state updates should be ' +\n- 'wrapped into act(...):\\n\\n' +\n- 'act(() => {\\n' +\n- ' \/* fire events that update state *\/\\n' +\n- '});\\n' +\n- '\/* assert on the output *\/\\n\\n' +\n- \"This ensures that you're testing the behavior the user would see \" +\n- 'in the browser.' +\n- ' Learn more at https:\/\/fb.me\/react-wrap-tests-with-act' +\n- '%s',\n- getComponentName(fiber.type),\n- getStackByFiberInDevAndProd(fiber),\n- );\n- }\n- }\n-}\n-\n-export const warnIfNotCurrentlyActingUpdatesInDev = warnIfNotCurrentlyActingUpdatesInDEV;\n-\n-function computeThreadID(root, expirationTime) {\n- \/\/ Interaction threads are unique per root and expiration time.\n- return expirationTime * 1000 + root.interactionThreadID;\n-}\n-\n-function schedulePendingInteraction(root, expirationTime) {\n- \/\/ This is called when work is scheduled on a root. It sets up a pending\n- \/\/ interaction, which is completed once the work commits.\n- if (!enableSchedulerTracing) {\n- return;\n- }\n-\n- const interactions = __interactionsRef.current;\n- if (interactions.size > 0) {\n- const pendingInteractionMap = root.pendingInteractionMap;\n- const pendingInteractions = pendingInteractionMap.get(expirationTime);\n- if (pendingInteractions != null) {\n- interactions.forEach(interaction => {\n- if (!pendingInteractions.has(interaction)) {\n- \/\/ Update the pending async work count for previously unscheduled interaction.\n- interaction.__count++;\n- }\n-\n- pendingInteractions.add(interaction);\n- });\n- } else {\n- pendingInteractionMap.set(expirationTime, new Set(interactions));\n-\n- \/\/ Update the pending async work count for the current interactions.\n- interactions.forEach(interaction => {\n- interaction.__count++;\n- });\n- }\n-\n- const subscriber = __subscriberRef.current;\n- if (subscriber !== null) {\n- const threadID = computeThreadID(root, expirationTime);\n- subscriber.onWorkScheduled(interactions, threadID);\n- }\n- }\n-}\n-\n-function startWorkOnPendingInteraction(root, expirationTime) {\n- \/\/ This is called when new work is started on a root.\n- if (!enableSchedulerTracing) {\n- return;\n- }\n-\n- \/\/ Determine which interactions this batch of work currently includes, So that\n- \/\/ we can accurately attribute time spent working on it, And so that cascading\n- \/\/ work triggered during the render phase will be associated with it.\n- const interactions: Set = new Set();\n- root.pendingInteractionMap.forEach(\n- (scheduledInteractions, scheduledExpirationTime) => {\n- if (scheduledExpirationTime >= expirationTime) {\n- scheduledInteractions.forEach(interaction =>\n- interactions.add(interaction),\n- );\n- }\n- },\n- );\n-\n- \/\/ Store the current set of interactions on the FiberRoot for a few reasons:\n- \/\/ We can re-use it in hot functions like renderRoot() without having to\n- \/\/ recalculate it. We will also use it in commitWork() to pass to any Profiler\n- \/\/ onRender() hooks. This also provides DevTools with a way to access it when\n- \/\/ the onCommitRoot() hook is called.\n- root.memoizedInteractions = interactions;\n-\n- if (interactions.size > 0) {\n- const subscriber = __subscriberRef.current;\n- if (subscriber !== null) {\n- const threadID = computeThreadID(root, expirationTime);\n- try {\n- subscriber.onWorkStarted(interactions, threadID);\n- } catch (error) {\n- \/\/ If the subscriber throws, rethrow it in a separate task\n- scheduleCallback(ImmediatePriority, () => {\n- throw error;\n- });\n- }\n- }\n- }\n-}\n-\n-function finishPendingInteractions(root, committedExpirationTime) {\n- if (!enableSchedulerTracing) {\n- return;\n- }\n-\n- const earliestRemainingTimeAfterCommit = root.firstPendingTime;\n-\n- let subscriber;\n-\n- try {\n- subscriber = __subscriberRef.current;\n- if (subscriber !== null && root.memoizedInteractions.size > 0) {\n- const threadID = computeThreadID(root, committedExpirationTime);\n- subscriber.onWorkStopped(root.memoizedInteractions, threadID);\n- }\n- } catch (error) {\n- \/\/ If the subscriber throws, rethrow it in a separate task\n- scheduleCallback(ImmediatePriority, () => {\n- throw error;\n- });\n- } finally {\n- \/\/ Clear completed interactions from the pending Map.\n- \/\/ Unless the render was suspended or cascading work was scheduled,\n- \/\/ In which case– leave pending interactions until the subsequent render.\n- const pendingInteractionMap = root.pendingInteractionMap;\n- pendingInteractionMap.forEach(\n- (scheduledInteractions, scheduledExpirationTime) => {\n- \/\/ Only decrement the pending interaction count if we're done.\n- \/\/ If there's still work at the current priority,\n- \/\/ That indicates that we are waiting for suspense data.\n- if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {\n- pendingInteractionMap.delete(scheduledExpirationTime);\n-\n- scheduledInteractions.forEach(interaction => {\n- interaction.__count--;\n-\n- if (subscriber !== null && interaction.__count === 0) {\n- try {\n- subscriber.onInteractionScheduledWorkCompleted(interaction);\n- } catch (error) {\n- \/\/ If the subscriber throws, rethrow it in a separate task\n- scheduleCallback(ImmediatePriority, () => {\n- throw error;\n- });\n- }\n- }\n- });\n- }\n- },\n- );\n- }\n-}\ndiff --git a\/packages\/react-reconciler\/src\/ReactFiberScheduler.old.js b\/packages\/react-reconciler\/src\/ReactFiberScheduler.old.js\ndeleted file mode 100644\nindex c4184fbb94..0000000000\n--- a\/packages\/react-reconciler\/src\/ReactFiberScheduler.old.js\n+++ \/dev\/null\n@@ -1,2723 +0,0 @@\n-\/**\n- * Copyright (c) Facebook, Inc. and its affiliates.\n- *\n- * This source code is licensed under the MIT license found in the\n- * LICENSE file in the root directory of this source tree.\n- *\n- * @flow\n- *\/\n-\n-import type {Fiber} from '.\/ReactFiber';\n-import type {Batch, FiberRoot} from '.\/ReactFiberRoot';\n-import type {ExpirationTime} from '.\/ReactFiberExpirationTime';\n-import type {Interaction} from 'scheduler\/src\/Tracing';\n-\n-\/\/ Intentionally not named imports because Rollup would use dynamic dispatch for\n-\/\/ CommonJS interop named imports.\n-import * as Scheduler from 'scheduler';\n-import {\n- __interactionsRef,\n- __subscriberRef,\n- unstable_wrap as Scheduler_tracing_wrap,\n-} from 'scheduler\/tracing';\n-import {\n- invokeGuardedCallback,\n- hasCaughtError,\n- clearCaughtError,\n-} from 'shared\/ReactErrorUtils';\n-import ReactSharedInternals from 'shared\/ReactSharedInternals';\n-import ReactStrictModeWarnings from '.\/ReactStrictModeWarnings';\n-import {\n- NoEffect,\n- PerformedWork,\n- Placement,\n- Update,\n- Snapshot,\n- PlacementAndUpdate,\n- Deletion,\n- ContentReset,\n- Callback,\n- DidCapture,\n- Ref,\n- Incomplete,\n- HostEffectMask,\n- Passive,\n-} from 'shared\/ReactSideEffectTags';\n-import {\n- ClassComponent,\n- HostComponent,\n- ContextProvider,\n- ForwardRef,\n- FunctionComponent,\n- HostPortal,\n- HostRoot,\n- MemoComponent,\n- SimpleMemoComponent,\n- SuspenseComponent,\n- DehydratedSuspenseComponent,\n-} from 'shared\/ReactWorkTags';\n-import {\n- enableSchedulerTracing,\n- enableProfilerTimer,\n- enableUserTimingAPI,\n- replayFailedUnitOfWorkWithInvokeGuardedCallback,\n- warnAboutDeprecatedLifecycles,\n- enableSuspenseServerRenderer,\n- disableYielding,\n-} from 'shared\/ReactFeatureFlags';\n-import getComponentName from 'shared\/getComponentName';\n-import invariant from 'shared\/invariant';\n-import warning from 'shared\/warning';\n-import warningWithoutStack from 'shared\/warningWithoutStack';\n-\n-import ReactFiberInstrumentation from '.\/ReactFiberInstrumentation';\n-import {\n- getStackByFiberInDevAndProd,\n- phase as ReactCurrentFiberPhase,\n- resetCurrentFiber,\n- setCurrentFiber,\n-} from '.\/ReactCurrentFiber';\n-import {\n- prepareForCommit,\n- resetAfterCommit,\n- scheduleTimeout,\n- cancelTimeout,\n- noTimeout,\n-} from '.\/ReactFiberHostConfig';\n-import {\n- markPendingPriorityLevel,\n- markCommittedPriorityLevels,\n- markSuspendedPriorityLevel,\n- markPingedPriorityLevel,\n- hasLowerPriorityWork,\n- isPriorityLevelSuspended,\n- didExpireAtExpirationTime,\n-} from '.\/ReactFiberPendingPriority';\n-import {\n- recordEffect,\n- recordScheduleUpdate,\n- startRequestCallbackTimer,\n- stopRequestCallbackTimer,\n- startWorkTimer,\n- stopWorkTimer,\n- stopFailedWorkTimer,\n- startWorkLoopTimer,\n- stopWorkLoopTimer,\n- startCommitTimer,\n- stopCommitTimer,\n- startCommitSnapshotEffectsTimer,\n- stopCommitSnapshotEffectsTimer,\n- startCommitHostEffectsTimer,\n- stopCommitHostEffectsTimer,\n- startCommitLifeCyclesTimer,\n- stopCommitLifeCyclesTimer,\n-} from '.\/ReactDebugFiberPerf';\n-import {createWorkInProgress, assignFiberPropertiesInDEV} from '.\/ReactFiber';\n-import {onCommitRoot} from '.\/ReactFiberDevToolsHook';\n-import {\n- NoWork,\n- Sync,\n- Never,\n- msToExpirationTime,\n- expirationTimeToMs,\n- computeAsyncExpiration,\n- computeInteractiveExpiration,\n- LOW_PRIORITY_EXPIRATION,\n-} from '.\/ReactFiberExpirationTime';\n-import {ConcurrentMode, ProfileMode} from '.\/ReactTypeOfMode';\n-import {enqueueUpdate, resetCurrentlyProcessingQueue} from '.\/ReactUpdateQueue';\n-import {createCapturedValue} from '.\/ReactCapturedValue';\n-import {\n- isContextProvider as isLegacyContextProvider,\n- popTopLevelContextObject as popTopLevelLegacyContextObject,\n- popContext as popLegacyContext,\n-} from '.\/ReactFiberContext';\n-import {popProvider, resetContextDependences} from '.\/ReactFiberNewContext';\n-import {resetHooks} from '.\/ReactFiberHooks';\n-import {popHostContext, popHostContainer} from '.\/ReactFiberHostContext';\n-import {\n- recordCommitTime,\n- startProfilerTimer,\n- stopProfilerTimerIfRunningAndRecordDelta,\n-} from '.\/ReactProfilerTimer';\n-import {\n- checkThatStackIsEmpty,\n- resetStackAfterFatalErrorInDev,\n-} from '.\/ReactFiberStack';\n-import {beginWork} from '.\/ReactFiberBeginWork';\n-import {completeWork} from '.\/ReactFiberCompleteWork';\n-import {\n- throwException,\n- unwindWork,\n- unwindInterruptedWork,\n- createRootErrorUpdate,\n- createClassErrorUpdate,\n-} from '.\/ReactFiberUnwindWork';\n-import {\n- commitBeforeMutationLifeCycles,\n- commitResetTextContent,\n- commitPlacement,\n- commitDeletion,\n- commitWork,\n- commitLifeCycles,\n- commitAttachRef,\n- commitDetachRef,\n- commitPassiveHookEffects,\n-} from '.\/ReactFiberCommitWork';\n-import {ContextOnlyDispatcher} from '.\/ReactFiberHooks';\n-\n-\/\/ Intentionally not named imports because Rollup would use dynamic dispatch for\n-\/\/ CommonJS interop named imports.\n-const {\n- unstable_scheduleCallback: scheduleCallback,\n- unstable_cancelCallback: cancelCallback,\n- unstable_shouldYield: shouldYield,\n- unstable_now: now,\n- unstable_getCurrentPriorityLevel: getCurrentPriorityLevel,\n- unstable_NormalPriority: NormalPriority,\n-} = Scheduler;\n-\n-export type Thenable = {\n- then(resolve: () => mixed, reject?: () => mixed): void | Thenable,\n-};\n-\n-const {\n- ReactCurrentDispatcher,\n- ReactCurrentOwner,\n- ReactShouldWarnActingUpdates,\n-} = ReactSharedInternals;\n-\n-let didWarnAboutStateTransition;\n-let didWarnSetStateChildContext;\n-let warnAboutUpdateOnUnmounted;\n-let warnAboutInvalidUpdates;\n-\n-if (enableSchedulerTracing) {\n- \/\/ Provide explicit error message when production+profiling bundle of e.g. react-dom\n- \/\/ is used with production (non-profiling) bundle of scheduler\/tracing\n- invariant(\n- __interactionsRef != null && __interactionsRef.current != null,\n- 'It is not supported to run the profiling version of a renderer (for example, `react-dom\/profiling`) ' +\n- 'without also replacing the `scheduler\/tracing` module with `scheduler\/tracing-profiling`. ' +\n- 'Your bundler might have a setting for aliasing both modules. ' +\n- 'Learn more at http:\/\/fb.me\/react-profiling',\n- );\n-}\n-\n-if (__DEV__) {\n- didWarnAboutStateTransition = false;\n- didWarnSetStateChildContext = false;\n- const didWarnStateUpdateForUnmountedComponent = {};\n-\n- warnAboutUpdateOnUnmounted = function(fiber: Fiber, isClass: boolean) {\n- \/\/ We show the whole stack but dedupe on the top component's name because\n- \/\/ the problematic code almost always lies inside that component.\n- const componentName = getComponentName(fiber.type) || 'ReactComponent';\n- if (didWarnStateUpdateForUnmountedComponent[componentName]) {\n- return;\n- }\n- warningWithoutStack(\n- false,\n- \"Can't perform a React state update on an unmounted component. This \" +\n- 'is a no-op, but it indicates a memory leak in your application. To ' +\n- 'fix, cancel all subscriptions and asynchronous tasks in %s.%s',\n- isClass\n- ? 'the componentWillUnmount method'\n- : 'a useEffect cleanup function',\n- getStackByFiberInDevAndProd(fiber),\n- );\n- didWarnStateUpdateForUnmountedComponent[componentName] = true;\n- };\n-\n- warnAboutInvalidUpdates = function(instance: React$Component) {\n- switch (ReactCurrentFiberPhase) {\n- case 'getChildContext':\n- if (didWarnSetStateChildContext) {\n- return;\n- }\n- warningWithoutStack(\n- false,\n- 'setState(...): Cannot call setState() inside getChildContext()',\n- );\n- didWarnSetStateChildContext = true;\n- break;\n- case 'render':\n- if (didWarnAboutStateTransition) {\n- return;\n- }\n- warningWithoutStack(\n- false,\n- 'Cannot update during an existing state transition (such as within ' +\n- '`render`). Render methods should be a pure function of props and state.',\n- );\n- didWarnAboutStateTransition = true;\n- break;\n- }\n- };\n-}\n-\n-\/\/ Used to ensure computeUniqueAsyncExpiration is monotonically decreasing.\n-let lastUniqueAsyncExpiration: number = Sync - 1;\n-\n-\/\/ Represents the expiration time that incoming updates should use. (If this\n-\/\/ is NoWork, use the default strategy: async updates in async mode, sync\n-\/\/ updates in sync mode.)\n-let expirationContext: ExpirationTime = NoWork;\n-\n-let isWorking: boolean = false;\n-\n-\/\/ The next work in progress fiber that we're currently working on.\n-let nextUnitOfWork: Fiber | null = null;\n-let nextRoot: FiberRoot | null = null;\n-\/\/ The time at which we're currently rendering work.\n-let nextRenderExpirationTime: ExpirationTime = NoWork;\n-let mostRecentEventTime: ExpirationTime = Sync;\n-let nextRenderDidSuspend: boolean = false;\n-let nextRenderDidError: boolean = false;\n-\n-\/\/ The next fiber with an effect that we're currently committing.\n-let nextEffect: Fiber | null = null;\n-\n-let isCommitting: boolean = false;\n-let rootWithPendingPassiveEffects: FiberRoot | null = null;\n-let passiveEffectCallbackHandle: * = null;\n-let passiveEffectCallback: * = null;\n-\n-let legacyErrorBoundariesThatAlreadyFailed: Set | null = null;\n-\n-\/\/ Used for performance tracking.\n-let interruptedBy: Fiber | null = null;\n-\n-let stashedWorkInProgressProperties;\n-let replayUnitOfWork;\n-let mayReplayFailedUnitOfWork;\n-let isReplayingFailedUnitOfWork;\n-let originalReplayError;\n-let rethrowOriginalError;\n-if (__DEV__ && replayFailedUnitOfWorkWithInvokeGuardedCallback) {\n- stashedWorkInProgressProperties = null;\n- mayReplayFailedUnitOfWork = true;\n- isReplayingFailedUnitOfWork = false;\n- originalReplayError = null;\n- replayUnitOfWork = (\n- failedUnitOfWork: Fiber,\n- thrownValue: mixed,\n- isYieldy: boolean,\n- ) => {\n- if (\n- thrownValue !== null &&\n- typeof thrownValue === 'object' &&\n- typeof thrownValue.then === 'function'\n- ) {\n- \/\/ Don't replay promises. Treat everything else like an error.\n- \/\/ TODO: Need to figure out a different strategy if\/when we add\n- \/\/ support for catching other types.\n- return;\n- }\n-\n- \/\/ Restore the original state of the work-in-progress\n- if (stashedWorkInProgressProperties === null) {\n- \/\/ This should never happen. Don't throw because this code is DEV-only.\n- warningWithoutStack(\n- false,\n- 'Could not replay rendering after an error. This is likely a bug in React. ' +\n- 'Please file an issue.',\n- );\n- return;\n- }\n- assignFiberPropertiesInDEV(\n- failedUnitOfWork,\n- stashedWorkInProgressProperties,\n- );\n-\n- switch (failedUnitOfWork.tag) {\n- case HostRoot:\n- popHostContainer(failedUnitOfWork);\n- popTopLevelLegacyContextObject(failedUnitOfWork);\n- break;\n- case HostComponent:\n- popHostContext(failedUnitOfWork);\n- break;\n- case ClassComponent: {\n- const Component = failedUnitOfWork.type;\n- if (isLegacyContextProvider(Component)) {\n- popLegacyContext(failedUnitOfWork);\n- }\n- break;\n- }\n- case HostPortal:\n- popHostContainer(failedUnitOfWork);\n- break;\n- case ContextProvider:\n- popProvider(failedUnitOfWork);\n- break;\n- }\n- \/\/ Replay the begin phase.\n- isReplayingFailedUnitOfWork = true;\n- originalReplayError = thrownValue;\n- invokeGuardedCallback(null, workLoop, null, isYieldy);\n- isReplayingFailedUnitOfWork = false;\n- originalReplayError = null;\n- if (hasCaughtError()) {\n- const replayError = clearCaughtError();\n- if (replayError != null && thrownValue != null) {\n- try {\n- \/\/ Reading the expando property is intentionally\n- \/\/ inside `try` because it might be a getter or Proxy.\n- if (replayError._suppressLogging) {\n- \/\/ Also suppress logging for the original error.\n- (thrownValue: any)._suppressLogging = true;\n- }\n- } catch (inner) {\n- \/\/ Ignore.\n- }\n- }\n- } else {\n- \/\/ If the begin phase did not fail the second time, set this pointer\n- \/\/ back to the original value.\n- nextUnitOfWork = failedUnitOfWork;\n- }\n- };\n- rethrowOriginalError = () => {\n- throw originalReplayError;\n- };\n-}\n-\n-function resetStack() {\n- if (nextUnitOfWork !== null) {\n- let interruptedWork = nextUnitOfWork.return;\n- while (interruptedWork !== null) {\n- unwindInterruptedWork(interruptedWork);\n- interruptedWork = interruptedWork.return;\n- }\n- }\n-\n- if (__DEV__) {\n- ReactStrictModeWarnings.discardPendingWarnings();\n- checkThatStackIsEmpty();\n- }\n-\n- nextRoot = null;\n- nextRenderExpirationTime = NoWork;\n- mostRecentEventTime = Sync;\n- nextRenderDidSuspend = false;\n- nextRenderDidError = false;\n- nextUnitOfWork = null;\n-}\n-\n-function commitAllHostEffects() {\n- while (nextEffect !== null) {\n- if (__DEV__) {\n- setCurrentFiber(nextEffect);\n- }\n- recordEffect();\n-\n- const effectTag = nextEffect.effectTag;\n-\n- if (effectTag & ContentReset) {\n- commitResetTextContent(nextEffect);\n- }\n-\n- if (effectTag & Ref) {\n- const current = nextEffect.alternate;\n- if (current !== null) {\n- commitDetachRef(current);\n- }\n- }\n-\n- \/\/ The following switch statement is only concerned about placement,\n- \/\/ updates, and deletions. To avoid needing to add a case for every\n- \/\/ possible bitmap value, we remove the secondary effects from the\n- \/\/ effect tag and switch on that value.\n- let primaryEffectTag = effectTag & (Placement | Update | Deletion);\n- switch (primaryEffectTag) {\n- case Placement: {\n- commitPlacement(nextEffect);\n- \/\/ Clear the \"placement\" from effect tag so that we know that this is inserted, before\n- \/\/ any life-cycles like componentDidMount gets called.\n- \/\/ TODO: findDOMNode doesn't rely on this any more but isMounted\n- \/\/ does and isMounted is deprecated anyway so we should be able\n- \/\/ to kill this.\n- nextEffect.effectTag &= ~Placement;\n- break;\n- }\n- case PlacementAndUpdate: {\n- \/\/ Placement\n- commitPlacement(nextEffect);\n- \/\/ Clear the \"placement\" from effect tag so that we know that this is inserted, before\n- \/\/ any life-cycles like componentDidMount gets called.\n- nextEffect.effectTag &= ~Placement;\n-\n- \/\/ Update\n- const current = nextEffect.alternate;\n- commitWork(current, nextEffect);\n- break;\n- }\n- case Update: {\n- const current = nextEffect.alternate;\n- commitWork(current, nextEffect);\n- break;\n- }\n- case Deletion: {\n- commitDeletion(nextEffect);\n- break;\n- }\n- }\n- nextEffect = nextEffect.nextEffect;\n- }\n-\n- if (__DEV__) {\n- resetCurrentFiber();\n- }\n-}\n-\n-function commitBeforeMutationLifecycles() {\n- while (nextEffect !== null) {\n- if (__DEV__) {\n- setCurrentFiber(nextEffect);\n- }\n-\n- const effectTag = nextEffect.effectTag;\n- if (effectTag & Snapshot) {\n- recordEffect();\n- const current = nextEffect.alternate;\n- commitBeforeMutationLifeCycles(current, nextEffect);\n- }\n-\n- nextEffect = nextEffect.nextEffect;\n- }\n-\n- if (__DEV__) {\n- resetCurrentFiber();\n- }\n-}\n-\n-function commitAllLifeCycles(\n- finishedRoot: FiberRoot,\n- committedExpirationTime: ExpirationTime,\n-) {\n- if (__DEV__) {\n- ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();\n- ReactStrictModeWarnings.flushLegacyContextWarning();\n-\n- if (warnAboutDeprecatedLifecycles) {\n- ReactStrictModeWarnings.flushPendingDeprecationWarnings();\n- }\n- }\n- while (nextEffect !== null) {\n- if (__DEV__) {\n- setCurrentFiber(nextEffect);\n- }\n- const effectTag = nextEffect.effectTag;\n-\n- if (effectTag & (Update | Callback)) {\n- recordEffect();\n- const current = nextEffect.alternate;\n- commitLifeCycles(\n- finishedRoot,\n- current,\n- nextEffect,\n- committedExpirationTime,\n- );\n- }\n-\n- if (effectTag & Ref) {\n- recordEffect();\n- commitAttachRef(nextEffect);\n- }\n-\n- if (effectTag & Passive) {\n- rootWithPendingPassiveEffects = finishedRoot;\n- }\n-\n- nextEffect = nextEffect.nextEffect;\n- }\n- if (__DEV__) {\n- resetCurrentFiber();\n- }\n-}\n-\n-function commitPassiveEffects(root: FiberRoot, firstEffect: Fiber): void {\n- rootWithPendingPassiveEffects = null;\n- passiveEffectCallbackHandle = null;\n- passiveEffectCallback = null;\n-\n- \/\/ Set this to true to prevent re-entrancy\n- const previousIsRendering = isRendering;\n- isRendering = true;\n-\n- let effect = firstEffect;\n- do {\n- if (__DEV__) {\n- setCurrentFiber(effect);\n- }\n-\n- if (effect.effectTag & Passive) {\n- let didError = false;\n- let error;\n- if (__DEV__) {\n- isInPassiveEffectDEV = true;\n- invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);\n- isInPassiveEffectDEV = false;\n- if (hasCaughtError()) {\n- didError = true;\n- error = clearCaughtError();\n- }\n- } else {\n- try {\n- commitPassiveHookEffects(effect);\n- } catch (e) {\n- didError = true;\n- error = e;\n- }\n- }\n- if (didError) {\n- captureCommitPhaseError(effect, error);\n- }\n- }\n- effect = effect.nextEffect;\n- } while (effect !== null);\n- if (__DEV__) {\n- resetCurrentFiber();\n- }\n-\n- isRendering = previousIsRendering;\n-\n- \/\/ Check if work was scheduled by one of the effects\n- const rootExpirationTime = root.expirationTime;\n- if (rootExpirationTime !== NoWork) {\n- requestWork(root, rootExpirationTime);\n- }\n- \/\/ Flush any sync work that was scheduled by effects\n- if (!isBatchingUpdates && !isRendering) {\n- performSyncWork();\n- }\n-\n- if (__DEV__) {\n- if (rootWithPendingPassiveEffects === root) {\n- nestedPassiveEffectCountDEV++;\n- } else {\n- nestedPassiveEffectCountDEV = 0;\n- }\n- }\n-}\n-\n-function isAlreadyFailedLegacyErrorBoundary(instance: mixed): boolean {\n- return (\n- legacyErrorBoundariesThatAlreadyFailed !== null &&\n- legacyErrorBoundariesThatAlreadyFailed.has(instance)\n- );\n-}\n-\n-function markLegacyErrorBoundaryAsFailed(instance: mixed) {\n- if (legacyErrorBoundariesThatAlreadyFailed === null) {\n- legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);\n- } else {\n- legacyErrorBoundariesThatAlreadyFailed.add(instance);\n- }\n-}\n-\n-function flushPassiveEffects() {\n- const didFlushEffects = passiveEffectCallback !== null;\n- if (passiveEffectCallbackHandle !== null) {\n- cancelCallback(passiveEffectCallbackHandle);\n- }\n- if (passiveEffectCallback !== null) {\n- \/\/ We call the scheduled callback instead of commitPassiveEffects directly\n- \/\/ to ensure tracing works correctly.\n- passiveEffectCallback();\n- }\n- return didFlushEffects;\n-}\n-\n-function commitRoot(root: FiberRoot, finishedWork: Fiber): void {\n- isWorking = true;\n- isCommitting = true;\n- startCommitTimer();\n-\n- invariant(\n- root.current !== finishedWork,\n- 'Cannot commit the same tree as before. This is probably a bug ' +\n- 'related to the return field. This error is likely caused by a bug ' +\n- 'in React. Please file an issue.',\n- );\n- const committedExpirationTime = root.pendingCommitExpirationTime;\n- invariant(\n- committedExpirationTime !== NoWork,\n- 'Cannot commit an incomplete root. This error is likely caused by a ' +\n- 'bug in React. Please file an issue.',\n- );\n- root.pendingCommitExpirationTime = NoWork;\n-\n- \/\/ Update the pending priority levels to account for the work that we are\n- \/\/ about to commit. This needs to happen before calling the lifecycles, since\n- \/\/ they may schedule additional updates.\n- const updateExpirationTimeBeforeCommit = finishedWork.expirationTime;\n- const childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;\n- const earliestRemainingTimeBeforeCommit =\n- childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit\n- ? childExpirationTimeBeforeCommit\n- : updateExpirationTimeBeforeCommit;\n- markCommittedPriorityLevels(root, earliestRemainingTimeBeforeCommit);\n-\n- let prevInteractions: Set = (null: any);\n- if (enableSchedulerTracing) {\n- \/\/ Restore any pending interactions at this point,\n- \/\/ So that cascading work triggered during the render phase will be accounted for.\n- prevInteractions = __interactionsRef.current;\n- __interactionsRef.current = root.memoizedInteractions;\n- }\n-\n- \/\/ Reset this to null before calling lifecycles\n- ReactCurrentOwner.current = null;\n-\n- let firstEffect;\n- if (finishedWork.effectTag > PerformedWork) {\n- \/\/ A fiber's effect list consists only of its children, not itself. So if\n- \/\/ the root has an effect, we need to add it to the end of the list. The\n- \/\/ resulting list is the set that would belong to the root's parent, if\n- \/\/ it had one; that is, all the effects in the tree including the root.\n- if (finishedWork.lastEffect !== null) {\n- finishedWork.lastEffect.nextEffect = finishedWork;\n- firstEffect = finishedWork.firstEffect;\n- } else {\n- firstEffect = finishedWork;\n- }\n- } else {\n- \/\/ There is no effect on the root.\n- firstEffect = finishedWork.firstEffect;\n- }\n-\n- prepareForCommit(root.containerInfo);\n-\n- \/\/ Invoke instances of getSnapshotBeforeUpdate before mutation.\n- nextEffect = firstEffect;\n- startCommitSnapshotEffectsTimer();\n- while (nextEffect !== null) {\n- let didError = false;\n- let error;\n- if (__DEV__) {\n- invokeGuardedCallback(null, commitBeforeMutationLifecycles, null);\n- if (hasCaughtError()) {\n- didError = true;\n- error = clearCaughtError();\n- }\n- } else {\n- try {\n- commitBeforeMutationLifecycles();\n- } catch (e) {\n- didError = true;\n- error = e;\n- }\n- }\n- if (didError) {\n- invariant(\n- nextEffect !== null,\n- 'Should have next effect. This error is likely caused by a bug ' +\n- 'in React. Please file an issue.',\n- );\n- captureCommitPhaseError(nextEffect, error);\n- \/\/ Clean-up\n- if (nextEffect !== null) {\n- nextEffect = nextEffect.nextEffect;\n- }\n- }\n- }\n- stopCommitSnapshotEffectsTimer();\n-\n- if (enableProfilerTimer) {\n- \/\/ Mark the current commit time to be shared by all Profilers in this batch.\n- \/\/ This enables them to be grouped later.\n- recordCommitTime();\n- }\n-\n- \/\/ Commit all the side-effects within a tree. We'll do this in two passes.\n- \/\/ The first pass performs all the host insertions, updates, deletions and\n- \/\/ ref unmounts.\n- nextEffect = firstEffect;\n- startCommitHostEffectsTimer();\n- while (nextEffect !== null) {\n- let didError = false;\n- let error;\n- if (__DEV__) {\n- invokeGuardedCallback(null, commitAllHostEffects, null);\n- if (hasCaughtError()) {\n- didError = true;\n- error = clearCaughtError();\n- }\n- } else {\n- try {\n- commitAllHostEffects();\n- } catch (e) {\n- didError = true;\n- error = e;\n- }\n- }\n- if (didError) {\n- invariant(\n- nextEffect !== null,\n- 'Should have next effect. This error is likely caused by a bug ' +\n- 'in React. Please file an issue.',\n- );\n- captureCommitPhaseError(nextEffect, error);\n- \/\/ Clean-up\n- if (nextEffect !== null) {\n- nextEffect = nextEffect.nextEffect;\n- }\n- }\n- }\n- stopCommitHostEffectsTimer();\n-\n- resetAfterCommit(root.containerInfo);\n-\n- \/\/ The work-in-progress tree is now the current tree. This must come after\n- \/\/ the first pass of the commit phase, so that the previous tree is still\n- \/\/ current during componentWillUnmount, but before the second pass, so that\n- \/\/ the finished work is current during componentDidMount\/Update.\n- root.current = finishedWork;\n-\n- \/\/ In the second pass we'll perform all life-cycles and ref callbacks.\n- \/\/ Life-cycles happen as a separate pass so that all placements, updates,\n- \/\/ and deletions in the entire tree have already been invoked.\n- \/\/ This pass also triggers any renderer-specific initial effects.\n- nextEffect = firstEffect;\n- startCommitLifeCyclesTimer();\n- while (nextEffect !== null) {\n- let didError = false;\n- let error;\n- if (__DEV__) {\n- invokeGuardedCallback(\n- null,\n- commitAllLifeCycles,\n- null,\n- root,\n- committedExpirationTime,\n- );\n- if (hasCaughtError()) {\n- didError = true;\n- error = clearCaughtError();\n- }\n- } else {\n- try {\n- commitAllLifeCycles(root, committedExpirationTime);\n- } catch (e) {\n- didError = true;\n- error = e;\n- }\n- }\n- if (didError) {\n- invariant(\n- nextEffect !== null,\n- 'Should have next effect. This error is likely caused by a bug ' +\n- 'in React. Please file an issue.',\n- );\n- captureCommitPhaseError(nextEffect, error);\n- if (nextEffect !== null) {\n- nextEffect = nextEffect.nextEffect;\n- }\n- }\n- }\n-\n- if (firstEffect !== null && rootWithPendingPassiveEffects !== null) {\n- \/\/ This commit included a passive effect. These do not need to fire until\n- \/\/ after the next paint. Schedule an callback to fire them in an async\n- \/\/ event. To ensure serial execution, the callback will be flushed early if\n- \/\/ we enter rootWithPendingPassiveEffects commit phase before then.\n- let callback = commitPassiveEffects.bind(null, root, firstEffect);\n- if (enableSchedulerTracing) {\n- \/\/ TODO: Avoid this extra callback by mutating the tracing ref directly,\n- \/\/ like we do at the beginning of commitRoot. I've opted not to do that\n- \/\/ here because that code is still in flux.\n- callback = Scheduler_tracing_wrap(callback);\n- }\n- passiveEffectCallbackHandle = scheduleCallback(NormalPriority, callback);\n- passiveEffectCallback = callback;\n- }\n-\n- isCommitting = false;\n- isWorking = false;\n- stopCommitLifeCyclesTimer();\n- stopCommitTimer();\n- onCommitRoot(finishedWork.stateNode);\n- if (__DEV__ && ReactFiberInstrumentation.debugTool) {\n- ReactFiberInstrumentation.debugTool.onCommitWork(finishedWork);\n- }\n-\n- const updateExpirationTimeAfterCommit = finishedWork.expirationTime;\n- const childExpirationTimeAfterCommit = finishedWork.childExpirationTime;\n- const earliestRemainingTimeAfterCommit =\n- childExpirationTimeAfterCommit > updateExpirationTimeAfterCommit\n- ? childExpirationTimeAfterCommit\n- : updateExpirationTimeAfterCommit;\n- if (earliestRemainingTimeAfterCommit === NoWork) {\n- \/\/ If there's no remaining work, we can clear the set of already failed\n- \/\/ error boundaries.\n- legacyErrorBoundariesThatAlreadyFailed = null;\n- }\n- onCommit(root, earliestRemainingTimeAfterCommit);\n-\n- if (enableSchedulerTracing) {\n- __interactionsRef.current = prevInteractions;\n-\n- let subscriber;\n-\n- try {\n- subscriber = __subscriberRef.current;\n- if (subscriber !== null && root.memoizedInteractions.size > 0) {\n- const threadID = computeThreadID(\n- committedExpirationTime,\n- root.interactionThreadID,\n- );\n- subscriber.onWorkStopped(root.memoizedInteractions, threadID);\n- }\n- } catch (error) {\n- \/\/ It's not safe for commitRoot() to throw.\n- \/\/ Store the error for now and we'll re-throw in finishRendering().\n- if (!hasUnhandledError) {\n- hasUnhandledError = true;\n- unhandledError = error;\n- }\n- } finally {\n- \/\/ Clear completed interactions from the pending Map.\n- \/\/ Unless the render was suspended or cascading work was scheduled,\n- \/\/ In which case– leave pending interactions until the subsequent render.\n- const pendingInteractionMap = root.pendingInteractionMap;\n- pendingInteractionMap.forEach(\n- (scheduledInteractions, scheduledExpirationTime) => {\n- \/\/ Only decrement the pending interaction count if we're done.\n- \/\/ If there's still work at the current priority,\n- \/\/ That indicates that we are waiting for suspense data.\n- if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {\n- pendingInteractionMap.delete(scheduledExpirationTime);\n-\n- scheduledInteractions.forEach(interaction => {\n- interaction.__count--;\n-\n- if (subscriber !== null && interaction.__count === 0) {\n- try {\n- subscriber.onInteractionScheduledWorkCompleted(interaction);\n- } catch (error) {\n- \/\/ It's not safe for commitRoot() to throw.\n- \/\/ Store the error for now and we'll re-throw in finishRendering().\n- if (!hasUnhandledError) {\n- hasUnhandledError = true;\n- unhandledError = error;\n- }\n- }\n- }\n- });\n- }\n- },\n- );\n- }\n- }\n-}\n-\n-function resetChildExpirationTime(\n- workInProgress: Fiber,\n- renderTime: ExpirationTime,\n-) {\n- if (renderTime !== Never && workInProgress.childExpirationTime === Never) {\n- \/\/ The children of this component are hidden. Don't bubble their\n- \/\/ expiration times.\n- return;\n- }\n-\n- let newChildExpirationTime = NoWork;\n-\n- \/\/ Bubble up the earliest expiration time.\n- if (enableProfilerTimer && workInProgress.mode & ProfileMode) {\n- \/\/ We're in profiling mode.\n- \/\/ Let's use this same traversal to update the render durations.\n- let actualDuration = workInProgress.actualDuration;\n- let treeBaseDuration = workInProgress.selfBaseDuration;\n-\n- \/\/ When a fiber is cloned, its actualDuration is reset to 0.\n- \/\/ This value will only be updated if work is done on the fiber (i.e. it doesn't bailout).\n- \/\/ When work is done, it should bubble to the parent's actualDuration.\n- \/\/ If the fiber has not been cloned though, (meaning no work was done),\n- \/\/ Then this value will reflect the amount of time spent working on a previous render.\n- \/\/ In that case it should not bubble.\n- \/\/ We determine whether it was cloned by comparing the child pointer.\n- const shouldBubbleActualDurations =\n- workInProgress.alternate === null ||\n- workInProgress.child !== workInProgress.alternate.child;\n-\n- let child = workInProgress.child;\n- while (child !== null) {\n- const childUpdateExpirationTime = child.expirationTime;\n- const childChildExpirationTime = child.childExpirationTime;\n- if (childUpdateExpirationTime > newChildExpirationTime) {\n- newChildExpirationTime = childUpdateExpirationTime;\n- }\n- if (childChildExpirationTime > newChildExpirationTime) {\n- newChildExpirationTime = childChildExpirationTime;\n- }\n- if (shouldBubbleActualDurations) {\n- actualDuration += child.actualDuration;\n- }\n- treeBaseDuration += child.treeBaseDuration;\n- child = child.sibling;\n- }\n- workInProgress.actualDuration = actualDuration;\n- workInProgress.treeBaseDuration = treeBaseDuration;\n- } else {\n- let child = workInProgress.child;\n- while (child !== null) {\n- const childUpdateExpirationTime = child.expirationTime;\n- const childChildExpirationTime = child.childExpirationTime;\n- if (childUpdateExpirationTime > newChildExpirationTime) {\n- newChildExpirationTime = childUpdateExpirationTime;\n- }\n- if (childChildExpirationTime > newChildExpirationTime) {\n- newChildExpirationTime = childChildExpirationTime;\n- }\n- child = child.sibling;\n- }\n- }\n-\n- workInProgress.childExpirationTime = newChildExpirationTime;\n-}\n-\n-function completeUnitOfWork(workInProgress: Fiber): Fiber | null {\n- \/\/ Attempt to complete the current unit of work, then move to the\n- \/\/ next sibling. If there are no more siblings, return to the\n- \/\/ parent fiber.\n- while (true) {\n- \/\/ The current, flushed, state of this fiber is the alternate.\n- \/\/ Ideally nothing should rely on this, but relying on it here\n- \/\/ means that we don't need an additional field on the work in\n- \/\/ progress.\n- const current = workInProgress.alternate;\n- if (__DEV__) {\n- setCurrentFiber(workInProgress);\n- }\n-\n- const returnFiber = workInProgress.return;\n- const siblingFiber = workInProgress.sibling;\n-\n- if ((workInProgress.effectTag & Incomplete) === NoEffect) {\n- if (__DEV__ && replayFailedUnitOfWorkWithInvokeGuardedCallback) {\n- \/\/ Don't replay if it fails during completion phase.\n- mayReplayFailedUnitOfWork = false;\n- }\n- \/\/ This fiber completed.\n- \/\/ Remember we're completing this unit so we can find a boundary if it fails.\n- nextUnitOfWork = workInProgress;\n- if (enableProfilerTimer) {\n- if (workInProgress.mode & ProfileMode) {\n- startProfilerTimer(workInProgress);\n- }\n- nextUnitOfWork = completeWork(\n- current,\n- workInProgress,\n- nextRenderExpirationTime,\n- );\n- if (workInProgress.mode & ProfileMode) {\n- \/\/ Update render duration assuming we didn't error.\n- stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);\n- }\n- } else {\n- nextUnitOfWork = completeWork(\n- current,\n- workInProgress,\n- nextRenderExpirationTime,\n- );\n- }\n- if (__DEV__ && replayFailedUnitOfWorkWithInvokeGuardedCallback) {\n- \/\/ We're out of completion phase so replaying is fine now.\n- mayReplayFailedUnitOfWork = true;\n- }\n- stopWorkTimer(workInProgress);\n- resetChildExpirationTime(workInProgress, nextRenderExpirationTime);\n- if (__DEV__) {\n- resetCurrentFiber();\n- }\n-\n- if (nextUnitOfWork !== null) {\n- \/\/ Completing this fiber spawned new work. Work on that next.\n- return nextUnitOfWork;\n- }\n-\n- if (\n- returnFiber !== null &&\n- \/\/ Do not append effects to parents if a sibling failed to complete\n- (returnFiber.effectTag & Incomplete) === NoEffect\n- ) {\n- \/\/ Append all the effects of the subtree and this fiber onto the effect\n- \/\/ list of the parent. The completion order of the children affects the\n- \/\/ side-effect order.\n- if (returnFiber.firstEffect === null) {\n- returnFiber.firstEffect = workInProgress.firstEffect;\n- }\n- if (workInProgress.lastEffect !== null) {\n- if (returnFiber.lastEffect !== null) {\n- returnFiber.lastEffect.nextEffect = workInProgress.firstEffect;\n- }\n- returnFiber.lastEffect = workInProgress.lastEffect;\n- }\n-\n- \/\/ If this fiber had side-effects, we append it AFTER the children's\n- \/\/ side-effects. We can perform certain side-effects earlier if\n- \/\/ needed, by doing multiple passes over the effect list. We don't want\n- \/\/ to schedule our own side-effect on our own list because if end up\n- \/\/ reusing children we'll schedule this effect onto itself since we're\n- \/\/ at the end.\n- const effectTag = workInProgress.effectTag;\n- \/\/ Skip both NoWork and PerformedWork tags when creating the effect list.\n- \/\/ PerformedWork effect is read by React DevTools but shouldn't be committed.\n- if (effectTag > PerformedWork) {\n- if (returnFiber.lastEffect !== null) {\n- returnFiber.lastEffect.nextEffect = workInProgress;\n- } else {\n- returnFiber.firstEffect = workInProgress;\n- }\n- returnFiber.lastEffect = workInProgress;\n- }\n- }\n-\n- if (__DEV__ && ReactFiberInstrumentation.debugTool) {\n- ReactFiberInstrumentation.debugTool.onCompleteWork(workInProgress);\n- }\n-\n- if (siblingFiber !== null) {\n- \/\/ If there is more work to do in this returnFiber, do that next.\n- return siblingFiber;\n- } else if (returnFiber !== null) {\n- \/\/ If there's no more work in this returnFiber. Complete the returnFiber.\n- workInProgress = returnFiber;\n- continue;\n- } else {\n- \/\/ We've reached the root.\n- return null;\n- }\n- } else {\n- if (enableProfilerTimer && workInProgress.mode & ProfileMode) {\n- \/\/ Record the render duration for the fiber that errored.\n- stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);\n-\n- \/\/ Include the time spent working on failed children before continuing.\n- let actualDuration = workInProgress.actualDuration;\n- let child = workInProgress.child;\n- while (child !== null) {\n- actualDuration += child.actualDuration;\n- child = child.sibling;\n- }\n- workInProgress.actualDuration = actualDuration;\n- }\n-\n- \/\/ This fiber did not complete because something threw. Pop values off\n- \/\/ the stack without entering the complete phase. If this is a boundary,\n- \/\/ capture values if possible.\n- const next = unwindWork(workInProgress, nextRenderExpirationTime);\n- \/\/ Because this fiber did not complete, don't reset its expiration time.\n- if (workInProgress.effectTag & DidCapture) {\n- \/\/ Restarting an error boundary\n- stopFailedWorkTimer(workInProgress);\n- } else {\n- stopWorkTimer(workInProgress);\n- }\n-\n- if (__DEV__) {\n- resetCurrentFiber();\n- }\n-\n- if (next !== null) {\n- stopWorkTimer(workInProgress);\n- if (__DEV__ && ReactFiberInstrumentation.debugTool) {\n- ReactFiberInstrumentation.debugTool.onCompleteWork(workInProgress);\n- }\n-\n- \/\/ If completing this work spawned new work, do that next. We'll come\n- \/\/ back here again.\n- \/\/ Since we're restarting, remove anything that is not a host effect\n- \/\/ from the effect tag.\n- next.effectTag &= HostEffectMask;\n- return next;\n- }\n-\n- if (returnFiber !== null) {\n- \/\/ Mark the parent fiber as incomplete and clear its effect list.\n- returnFiber.firstEffect = returnFiber.lastEffect = null;\n- returnFiber.effectTag |= Incomplete;\n- }\n-\n- if (__DEV__ && ReactFiberInstrumentation.debugTool) {\n- ReactFiberInstrumentation.debugTool.onCompleteWork(workInProgress);\n- }\n-\n- if (siblingFiber !== null) {\n- \/\/ If there is more work to do in this returnFiber, do that next.\n- return siblingFiber;\n- } else if (returnFiber !== null) {\n- \/\/ If there's no more work in this returnFiber. Complete the returnFiber.\n- workInProgress = returnFiber;\n- continue;\n- } else {\n- return null;\n- }\n- }\n- }\n-\n- \/\/ Without this explicit null return Flow complains of invalid return type\n- \/\/ TODO Remove the above while(true) loop\n- \/\/ eslint-disable-next-line no-unreachable\n- return null;\n-}\n-\n-function performUnitOfWork(workInProgress: Fiber): Fiber | null {\n- \/\/ The current, flushed, state of this fiber is the alternate.\n- \/\/ Ideally nothing should rely on this, but relying on it here\n- \/\/ means that we don't need an additional field on the work in\n- \/\/ progress.\n- const current = workInProgress.alternate;\n-\n- \/\/ See if beginning this work spawns more work.\n- startWorkTimer(workInProgress);\n- if (__DEV__) {\n- setCurrentFiber(workInProgress);\n- }\n-\n- if (__DEV__ && replayFailedUnitOfWorkWithInvokeGuardedCallback) {\n- stashedWorkInProgressProperties = assignFiberPropertiesInDEV(\n- stashedWorkInProgressProperties,\n- workInProgress,\n- );\n- }\n-\n- let next;\n- if (enableProfilerTimer) {\n- if (workInProgress.mode & ProfileMode) {\n- startProfilerTimer(workInProgress);\n- }\n-\n- next = beginWork(current, workInProgress, nextRenderExpirationTime);\n- workInProgress.memoizedProps = workInProgress.pendingProps;\n-\n- if (workInProgress.mode & ProfileMode) {\n- \/\/ Record the render duration assuming we didn't bailout (or error).\n- stopProfilerTimerIfRunningAndRecordDelta(workInProgress, true);\n- }\n- } else {\n- next = beginWork(current, workInProgress, nextRenderExpirationTime);\n- workInProgress.memoizedProps = workInProgress.pendingProps;\n- }\n-\n- if (__DEV__) {\n- resetCurrentFiber();\n- if (isReplayingFailedUnitOfWork) {\n- \/\/ Currently replaying a failed unit of work. This should be unreachable,\n- \/\/ because the render phase is meant to be idempotent, and it should\n- \/\/ have thrown again. Since it didn't, rethrow the original error, so\n- \/\/ React's internal stack is not misaligned.\n- rethrowOriginalError();\n- }\n- }\n- if (__DEV__ && ReactFiberInstrumentation.debugTool) {\n- ReactFiberInstrumentation.debugTool.onBeginWork(workInProgress);\n- }\n-\n- if (next === null) {\n- \/\/ If this doesn't spawn new work, complete the current work.\n- next = completeUnitOfWork(workInProgress);\n- }\n-\n- ReactCurrentOwner.current = null;\n-\n- return next;\n-}\n-\n-function workLoop(isYieldy) {\n- if (!isYieldy) {\n- \/\/ Flush work without yielding\n- while (nextUnitOfWork !== null) {\n- nextUnitOfWork = performUnitOfWork(nextUnitOfWork);\n- }\n- } else {\n- \/\/ Flush asynchronous work until there's a higher priority event\n- while (nextUnitOfWork !== null && !shouldYield()) {\n- nextUnitOfWork = performUnitOfWork(nextUnitOfWork);\n- }\n- }\n-}\n-\n-function jnd(timeElapsed: number) {\n- return timeElapsed < 120\n- ? 120\n- : timeElapsed < 480\n- ? 480\n- : timeElapsed < 1080\n- ? 1080\n- : timeElapsed < 1920\n- ? 1920\n- : timeElapsed < 3000\n- ? 3000\n- : timeElapsed < 4320\n- ? 4320\n- : Math.ceil(timeElapsed \/ 1960) * 1960;\n-}\n-\n-function renderRoot(root: FiberRoot, isYieldy: boolean): void {\n- invariant(\n- !isWorking,\n- 'renderRoot was called recursively. This error is likely caused ' +\n- 'by a bug in React. Please file an issue.',\n- );\n-\n- flushPassiveEffects();\n-\n- isWorking = true;\n- const previousDispatcher = ReactCurrentDispatcher.current;\n- ReactCurrentDispatcher.current = ContextOnlyDispatcher;\n-\n- const expirationTime = root.nextExpirationTimeToWorkOn;\n-\n- \/\/ Check if we're starting from a fresh stack, or if we're resuming from\n- \/\/ previously yielded work.\n- if (\n- expirationTime !== nextRenderExpirationTime ||\n- root !== nextRoot ||\n- nextUnitOfWork === null\n- ) {\n- \/\/ Reset the stack and start working from the root.\n- resetStack();\n- nextRoot = root;\n- nextRenderExpirationTime = expirationTime;\n- nextUnitOfWork = createWorkInProgress(\n- nextRoot.current,\n- null,\n- nextRenderExpirationTime,\n- );\n- root.pendingCommitExpirationTime = NoWork;\n-\n- if (enableSchedulerTracing) {\n- \/\/ Determine which interactions this batch of work currently includes,\n- \/\/ So that we can accurately attribute time spent working on it,\n- \/\/ And so that cascading work triggered during the render phase will be associated with it.\n- const interactions: Set = new Set();\n- root.pendingInteractionMap.forEach(\n- (scheduledInteractions, scheduledExpirationTime) => {\n- if (scheduledExpirationTime >= expirationTime) {\n- scheduledInteractions.forEach(interaction =>\n- interactions.add(interaction),\n- );\n- }\n- },\n- );\n-\n- \/\/ Store the current set of interactions on the FiberRoot for a few reasons:\n- \/\/ We can re-use it in hot functions like renderRoot() without having to recalculate it.\n- \/\/ We will also use it in commitWork() to pass to any Profiler onRender() hooks.\n- \/\/ This also provides DevTools with a way to access it when the onCommitRoot() hook is called.\n- root.memoizedInteractions = interactions;\n-\n- if (interactions.size > 0) {\n- const subscriber = __subscriberRef.current;\n- if (subscriber !== null) {\n- const threadID = computeThreadID(\n- expirationTime,\n- root.interactionThreadID,\n- );\n- try {\n- subscriber.onWorkStarted(interactions, threadID);\n- } catch (error) {\n- \/\/ Work thrown by an interaction tracing subscriber should be rethrown,\n- \/\/ But only once it's safe (to avoid leaving the scheduler in an invalid state).\n- \/\/ Store the error for now and we'll re-throw in finishRendering().\n- if (!hasUnhandledError) {\n- hasUnhandledError = true;\n- unhandledError = error;\n- }\n- }\n- }\n- }\n- }\n- }\n-\n- let prevInteractions: Set = (null: any);\n- if (enableSchedulerTracing) {\n- \/\/ We're about to start new traced work.\n- \/\/ Restore pending interactions so cascading work triggered during the render phase will be accounted for.\n- prevInteractions = __interactionsRef.current;\n- __interactionsRef.current = root.memoizedInteractions;\n- }\n-\n- let didFatal = false;\n-\n- startWorkLoopTimer(nextUnitOfWork);\n-\n- do {\n- try {\n- workLoop(isYieldy);\n- } catch (thrownValue) {\n- resetContextDependences();\n- resetHooks();\n-\n- \/\/ Reset in case completion throws.\n- \/\/ This is only used in DEV and when replaying is on.\n- let mayReplay;\n- if (__DEV__ && replayFailedUnitOfWorkWithInvokeGuardedCallback) {\n- mayReplay = mayReplayFailedUnitOfWork;\n- mayReplayFailedUnitOfWork = true;\n- }\n-\n- if (nextUnitOfWork === null) {\n- \/\/ This is a fatal error.\n- didFatal = true;\n- onUncaughtError(thrownValue);\n- } else {\n- if (enableProfilerTimer && nextUnitOfWork.mode & ProfileMode) {\n- \/\/ Record the time spent rendering before an error was thrown.\n- \/\/ This avoids inaccurate Profiler durations in the case of a suspended render.\n- stopProfilerTimerIfRunningAndRecordDelta(nextUnitOfWork, true);\n- }\n-\n- if (__DEV__) {\n- \/\/ Reset global debug state\n- \/\/ We assume this is defined in DEV\n- (resetCurrentlyProcessingQueue: any)();\n- }\n-\n- if (__DEV__ && replayFailedUnitOfWorkWithInvokeGuardedCallback) {\n- if (mayReplay) {\n- const failedUnitOfWork: Fiber = nextUnitOfWork;\n- replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy);\n- }\n- }\n-\n- \/\/ TODO: we already know this isn't true in some cases.\n- \/\/ At least this shows a nicer error message until we figure out the cause.\n- \/\/ https:\/\/github.com\/facebook\/react\/issues\/12449#issuecomment-386727431\n- invariant(\n- nextUnitOfWork !== null,\n- 'Failed to replay rendering after an error. This ' +\n- 'is likely caused by a bug in React. Please file an issue ' +\n- 'with a reproducing case to help us find it.',\n- );\n-\n- const sourceFiber: Fiber = nextUnitOfWork;\n- let returnFiber = sourceFiber.return;\n- if (returnFiber === null) {\n- \/\/ This is the root. The root could capture its own errors. However,\n- \/\/ we don't know if it errors before or after we pushed the host\n- \/\/ context. This information is needed to avoid a stack mismatch.\n- \/\/ Because we're not sure, treat this as a fatal error. We could track\n- \/\/ which phase it fails in, but doesn't seem worth it. At least\n- \/\/ for now.\n- didFatal = true;\n- onUncaughtError(thrownValue);\n- } else {\n- throwException(\n- root,\n- returnFiber,\n- sourceFiber,\n- thrownValue,\n- nextRenderExpirationTime,\n- );\n- nextUnitOfWork = completeUnitOfWork(sourceFiber);\n- continue;\n- }\n- }\n- }\n- break;\n- } while (true);\n-\n- if (enableSchedulerTracing) {\n- \/\/ Traced work is done for now; restore the previous interactions.\n- __interactionsRef.current = prevInteractions;\n- }\n-\n- \/\/ We're done performing work. Time to clean up.\n- isWorking = false;\n- ReactCurrentDispatcher.current = previousDispatcher;\n- resetContextDependences();\n- resetHooks();\n-\n- \/\/ Yield back to main thread.\n- if (didFatal) {\n- const didCompleteRoot = false;\n- stopWorkLoopTimer(interruptedBy, didCompleteRoot);\n- interruptedBy = null;\n- \/\/ There was a fatal error.\n- if (__DEV__) {\n- resetStackAfterFatalErrorInDev();\n- }\n- \/\/ `nextRoot` points to the in-progress root. A non-null value indicates\n- \/\/ that we're in the middle of an async render. Set it to null to indicate\n- \/\/ there's no more work to be done in the current batch.\n- nextRoot = null;\n- onFatal(root);\n- return;\n- }\n-\n- if (nextUnitOfWork !== null) {\n- \/\/ There's still remaining async work in this tree, but we ran out of time\n- \/\/ in the current frame. Yield back to the renderer. Unless we're\n- \/\/ interrupted by a higher priority update, we'll continue later from where\n- \/\/ we left off.\n- const didCompleteRoot = false;\n- stopWorkLoopTimer(interruptedBy, didCompleteRoot);\n- interruptedBy = null;\n- onYield(root);\n- return;\n- }\n-\n- \/\/ We completed the whole tree.\n- const didCompleteRoot = true;\n- stopWorkLoopTimer(interruptedBy, didCompleteRoot);\n- const rootWorkInProgress = root.current.alternate;\n- invariant(\n- rootWorkInProgress !== null,\n- 'Finished root should have a work-in-progress. This error is likely ' +\n- 'caused by a bug in React. Please file an issue.',\n- );\n-\n- \/\/ `nextRoot` points to the in-progress root. A non-null value indicates\n- \/\/ that we're in the middle of an async render. Set it to null to indicate\n- \/\/ there's no more work to be done in the current batch.\n- nextRoot = null;\n- interruptedBy = null;\n-\n- if (nextRenderDidError) {\n- \/\/ There was an error\n- if (hasLowerPriorityWork(root, expirationTime)) {\n- \/\/ There's lower priority work. If so, it may have the effect of fixing\n- \/\/ the exception that was just thrown. Exit without committing. This is\n- \/\/ similar to a suspend, but without a timeout because we're not waiting\n- \/\/ for a promise to resolve. React will restart at the lower\n- \/\/ priority level.\n- markSuspendedPriorityLevel(root, expirationTime);\n- const suspendedExpirationTime = expirationTime;\n- const rootExpirationTime = root.expirationTime;\n- onSuspend(\n- root,\n- rootWorkInProgress,\n- suspendedExpirationTime,\n- rootExpirationTime,\n- -1, \/\/ Indicates no timeout\n- );\n- return;\n- } else if (\n- \/\/ There's no lower priority work, but we're rendering asynchronously.\n- \/\/ Synchronously attempt to render the same level one more time. This is\n- \/\/ similar to a suspend, but without a timeout because we're not waiting\n- \/\/ for a promise to resolve.\n- !root.didError &&\n- isYieldy\n- ) {\n- root.didError = true;\n- const suspendedExpirationTime = (root.nextExpirationTimeToWorkOn = expirationTime);\n- const rootExpirationTime = (root.expirationTime = Sync);\n- onSuspend(\n- root,\n- rootWorkInProgress,\n- suspendedExpirationTime,\n- rootExpirationTime,\n- -1, \/\/ Indicates no timeout\n- );\n- return;\n- }\n- }\n-\n- \/\/ Check if we should suspend this commit.\n- \/\/ If mostRecentEventTime is Sync, that means we didn't track any event\n- \/\/ times. That can happen if we retried but nothing switched from fallback\n- \/\/ to content. There's no reason to delay doing no work.\n- if (isYieldy && nextRenderDidSuspend && mostRecentEventTime !== Sync) {\n- \/\/ The tree was suspended.\n- const suspendedExpirationTime = expirationTime;\n- markSuspendedPriorityLevel(root, suspendedExpirationTime);\n-\n- const eventTimeMs: number = inferTimeFromExpirationTime(\n- mostRecentEventTime,\n- );\n- const currentTimeMs: number = now();\n- const timeElapsed = currentTimeMs - eventTimeMs;\n-\n- let msUntilTimeout = jnd(timeElapsed) - timeElapsed;\n-\n- if (msUntilTimeout < 10) {\n- \/\/ Don't bother with a very short suspense time.\n- msUntilTimeout = 0;\n- } else {\n- \/\/ Compute the time until this render pass would expire.\n- const timeUntilExpirationMs =\n- expirationTimeToMs(suspendedExpirationTime) +\n- originalStartTimeMs -\n- currentTimeMs;\n- \/\/ Clamp the timeout to the expiration time.\n- if (timeUntilExpirationMs < msUntilTimeout) {\n- msUntilTimeout = timeUntilExpirationMs;\n- }\n- }\n-\n- const rootExpirationTime = root.expirationTime;\n- onSuspend(\n- root,\n- rootWorkInProgress,\n- suspendedExpirationTime,\n- rootExpirationTime,\n- msUntilTimeout,\n- );\n- return;\n- }\n-\n- \/\/ Ready to commit.\n- onComplete(root, rootWorkInProgress, expirationTime);\n-}\n-\n-function captureCommitPhaseError(sourceFiber: Fiber, value: mixed) {\n- const expirationTime = Sync;\n- let fiber = sourceFiber.return;\n- while (fiber !== null) {\n- switch (fiber.tag) {\n- case ClassComponent:\n- const ctor = fiber.type;\n- const instance = fiber.stateNode;\n- if (\n- typeof ctor.getDerivedStateFromError === 'function' ||\n- (typeof instance.componentDidCatch === 'function' &&\n- !isAlreadyFailedLegacyErrorBoundary(instance))\n- ) {\n- const errorInfo = createCapturedValue(value, sourceFiber);\n- const update = createClassErrorUpdate(\n- fiber,\n- errorInfo,\n- expirationTime,\n- );\n- enqueueUpdate(fiber, update);\n- scheduleWork(fiber, expirationTime);\n- return;\n- }\n- break;\n- case HostRoot: {\n- const errorInfo = createCapturedValue(value, sourceFiber);\n- const update = createRootErrorUpdate(fiber, errorInfo, expirationTime);\n- enqueueUpdate(fiber, update);\n- scheduleWork(fiber, expirationTime);\n- return;\n- }\n- }\n- fiber = fiber.return;\n- }\n-\n- if (sourceFiber.tag === HostRoot) {\n- \/\/ Error was thrown at the root. There is no parent, so the root\n- \/\/ itself should capture it.\n- const rootFiber = sourceFiber;\n- const errorInfo = createCapturedValue(value, rootFiber);\n- const update = createRootErrorUpdate(rootFiber, errorInfo, expirationTime);\n- enqueueUpdate(rootFiber, update);\n- scheduleWork(rootFiber, expirationTime);\n- }\n-}\n-\n-function computeThreadID(\n- expirationTime: ExpirationTime,\n- interactionThreadID: number,\n-): number {\n- \/\/ Interaction threads are unique per root and expiration time.\n- return expirationTime * 1000 + interactionThreadID;\n-}\n-\n-\/\/ Creates a unique async expiration time.\n-function computeUniqueAsyncExpiration(): ExpirationTime {\n- const currentTime = requestCurrentTime();\n- let result = computeAsyncExpiration(currentTime);\n- if (result >= lastUniqueAsyncExpiration) {\n- \/\/ Since we assume the current time monotonically increases, we only hit\n- \/\/ this branch when computeUniqueAsyncExpiration is fired multiple times\n- \/\/ within a 200ms window (or whatever the async bucket size is).\n- result = lastUniqueAsyncExpiration - 1;\n- }\n- lastUniqueAsyncExpiration = result;\n- return lastUniqueAsyncExpiration;\n-}\n-\n-function computeExpirationForFiber(currentTime: ExpirationTime, fiber: Fiber) {\n- let expirationTime;\n- if (expirationContext !== NoWork) {\n- \/\/ An explicit expiration context was set;\n- expirationTime = expirationContext;\n- } else if (isWorking) {\n- if (isCommitting) {\n- \/\/ Updates that occur during the commit phase should have sync priority\n- \/\/ by default.\n- expirationTime = Sync;\n- } else {\n- \/\/ Updates during the render phase should expire at the same time as\n- \/\/ the work that is being rendered.\n- expirationTime = nextRenderExpirationTime;\n- }\n- } else {\n- \/\/ No explicit expiration context was set, and we're not currently\n- \/\/ performing work. Calculate a new expiration time.\n- if (fiber.mode & ConcurrentMode) {\n- if (isBatchingInteractiveUpdates) {\n- \/\/ This is an interactive update\n- expirationTime = computeInteractiveExpiration(currentTime);\n- } else {\n- \/\/ This is an async update\n- expirationTime = computeAsyncExpiration(currentTime);\n- }\n- \/\/ If we're in the middle of rendering a tree, do not update at the same\n- \/\/ expiration time that is already rendering.\n- if (nextRoot !== null && expirationTime === nextRenderExpirationTime) {\n- expirationTime -= 1;\n- }\n- } else {\n- \/\/ This is a sync update\n- expirationTime = Sync;\n- }\n- }\n- if (isBatchingInteractiveUpdates) {\n- \/\/ This is an interactive update. Keep track of the lowest pending\n- \/\/ interactive expiration time. This allows us to synchronously flush\n- \/\/ all interactive updates when needed.\n- if (\n- lowestPriorityPendingInteractiveExpirationTime === NoWork ||\n- expirationTime < lowestPriorityPendingInteractiveExpirationTime\n- ) {\n- lowestPriorityPendingInteractiveExpirationTime = expirationTime;\n- }\n- }\n- return expirationTime;\n-}\n-\n-function markRenderEventTime(expirationTime: ExpirationTime): void {\n- if (expirationTime < mostRecentEventTime) {\n- mostRecentEventTime = expirationTime;\n- }\n-}\n-\n-function renderDidSuspend() {\n- nextRenderDidSuspend = true;\n-}\n-\n-function renderDidError() {\n- nextRenderDidError = true;\n-}\n-\n-function inferTimeFromExpirationTime(expirationTime: ExpirationTime) {\n- \/\/ We don't know exactly when the update was scheduled, but we can infer an\n- \/\/ approximate start time from the expiration time.\n- const earliestExpirationTimeMs = expirationTimeToMs(expirationTime);\n- return (\n- earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION + originalStartTimeMs\n- );\n-}\n-\n-function pingSuspendedRoot(\n- root: FiberRoot,\n- thenable: Thenable,\n- pingTime: ExpirationTime,\n-) {\n- \/\/ A promise that previously suspended React from committing has resolved.\n- \/\/ If React is still suspended, try again at the previous level (pingTime).\n-\n- const pingCache = root.pingCache;\n- if (pingCache !== null) {\n- \/\/ The thenable resolved, so we no longer need to memoize, because it will\n- \/\/ never be thrown again.\n- pingCache.delete(thenable);\n- }\n-\n- if (nextRoot !== null && nextRenderExpirationTime === pingTime) {\n- \/\/ Received a ping at the same priority level at which we're currently\n- \/\/ rendering. Restart from the root.\n- nextRoot = null;\n- } else {\n- \/\/ Confirm that the root is still suspended at this level. Otherwise exit.\n- if (isPriorityLevelSuspended(root, pingTime)) {\n- \/\/ Ping at the original level\n- markPingedPriorityLevel(root, pingTime);\n- const rootExpirationTime = root.expirationTime;\n- if (rootExpirationTime !== NoWork) {\n- requestWork(root, rootExpirationTime);\n- }\n- }\n- }\n-}\n-\n-function retryTimedOutBoundary(boundaryFiber: Fiber) {\n- const currentTime = requestCurrentTime();\n- const retryTime = computeExpirationForFiber(currentTime, boundaryFiber);\n- const root = scheduleWorkToRoot(boundaryFiber, retryTime);\n- if (root !== null) {\n- markPendingPriorityLevel(root, retryTime);\n- const rootExpirationTime = root.expirationTime;\n- if (rootExpirationTime !== NoWork) {\n- requestWork(root, rootExpirationTime);\n- }\n- }\n-}\n-\n-function resolveRetryThenable(boundaryFiber: Fiber, thenable: Thenable) {\n- \/\/ The boundary fiber (a Suspense component) previously timed out and was\n- \/\/ rendered in its fallback state. One of the promises that suspended it has\n- \/\/ resolved, which means at least part of the tree was likely unblocked. Try\n- \/\/ rendering again, at a new expiration time.\n-\n- let retryCache: WeakSet | Set | null;\n- if (enableSuspenseServerRenderer) {\n- switch (boundaryFiber.tag) {\n- case SuspenseComponent:\n- retryCache = boundaryFiber.stateNode;\n- break;\n- case DehydratedSuspenseComponent:\n- retryCache = boundaryFiber.memoizedState;\n- break;\n- default:\n- invariant(\n- false,\n- 'Pinged unknown suspense boundary type. ' +\n- 'This is probably a bug in React.',\n- );\n- }\n- } else {\n- retryCache = boundaryFiber.stateNode;\n- }\n- if (retryCache !== null) {\n- \/\/ The thenable resolved, so we no longer need to memoize, because it will\n- \/\/ never be thrown again.\n- retryCache.delete(thenable);\n- }\n-\n- retryTimedOutBoundary(boundaryFiber);\n-}\n-\n-function scheduleWorkToRoot(fiber: Fiber, expirationTime): FiberRoot | null {\n- recordScheduleUpdate();\n-\n- if (__DEV__) {\n- if (fiber.tag === ClassComponent) {\n- const instance = fiber.stateNode;\n- warnAboutInvalidUpdates(instance);\n- }\n- }\n-\n- \/\/ Update the source fiber's expiration time\n- if (fiber.expirationTime < expirationTime) {\n- fiber.expirationTime = expirationTime;\n- }\n- let alternate = fiber.alternate;\n- if (alternate !== null && alternate.expirationTime < expirationTime) {\n- alternate.expirationTime = expirationTime;\n- }\n- \/\/ Walk the parent path to the root and update the child expiration time.\n- let node = fiber.return;\n- let root = null;\n- if (node === null && fiber.tag === HostRoot) {\n- root = fiber.stateNode;\n- } else {\n- while (node !== null) {\n- alternate = node.alternate;\n- if (node.childExpirationTime < expirationTime) {\n- node.childExpirationTime = expirationTime;\n- if (\n- alternate !== null &&\n- alternate.childExpirationTime < expirationTime\n- ) {\n- alternate.childExpirationTime = expirationTime;\n- }\n- } else if (\n- alternate !== null &&\n- alternate.childExpirationTime < expirationTime\n- ) {\n- alternate.childExpirationTime = expirationTime;\n- }\n- if (node.return === null && node.tag === HostRoot) {\n- root = node.stateNode;\n- break;\n- }\n- node = node.return;\n- }\n- }\n-\n- if (enableSchedulerTracing) {\n- if (root !== null) {\n- const interactions = __interactionsRef.current;\n- if (interactions.size > 0) {\n- const pendingInteractionMap = root.pendingInteractionMap;\n- const pendingInteractions = pendingInteractionMap.get(expirationTime);\n- if (pendingInteractions != null) {\n- interactions.forEach(interaction => {\n- if (!pendingInteractions.has(interaction)) {\n- \/\/ Update the pending async work count for previously unscheduled interaction.\n- interaction.__count++;\n- }\n-\n- pendingInteractions.add(interaction);\n- });\n- } else {\n- pendingInteractionMap.set(expirationTime, new Set(interactions));\n-\n- \/\/ Update the pending async work count for the current interactions.\n- interactions.forEach(interaction => {\n- interaction.__count++;\n- });\n- }\n-\n- const subscriber = __subscriberRef.current;\n- if (subscriber !== null) {\n- const threadID = computeThreadID(\n- expirationTime,\n- root.interactionThreadID,\n- );\n- subscriber.onWorkScheduled(interactions, threadID);\n- }\n- }\n- }\n- }\n- return root;\n-}\n-\n-\/\/ in a test-like environment, we want to warn if dispatchAction() is\n-\/\/ called outside of a TestUtils.act(...)\/batchedUpdates\/render call.\n-\/\/ so we have a a step counter for when we descend\/ascend from\n-\/\/ act() calls, and test on it for when to warn\n-\/\/ It's a tuple with a single value. Look for shared\/createAct to\n-\/\/ see how we change the value inside act() calls\n-\n-export function warnIfNotCurrentlyActingUpdatesInDev(fiber: Fiber): void {\n- if (__DEV__) {\n- if (\n- isBatchingUpdates === false &&\n- isRendering === false &&\n- ReactShouldWarnActingUpdates.current === false\n- ) {\n- warningWithoutStack(\n- false,\n- 'An update to %s inside a test was not wrapped in act(...).\\n\\n' +\n- 'When testing, code that causes React state updates should be wrapped into act(...):\\n\\n' +\n- 'act(() => {\\n' +\n- ' \/* fire events that update state *\/\\n' +\n- '});\\n' +\n- '\/* assert on the output *\/\\n\\n' +\n- \"This ensures that you're testing the behavior the user would see in the browser.\" +\n- ' Learn more at https:\/\/fb.me\/react-wrap-tests-with-act' +\n- '%s',\n- getComponentName(fiber.type),\n- getStackByFiberInDevAndProd(fiber),\n- );\n- }\n- }\n-}\n-\n-function scheduleWork(fiber: Fiber, expirationTime: ExpirationTime) {\n- const root = scheduleWorkToRoot(fiber, expirationTime);\n- if (root === null) {\n- if (__DEV__) {\n- switch (fiber.tag) {\n- case ClassComponent:\n- warnAboutUpdateOnUnmounted(fiber, true);\n- break;\n- case FunctionComponent:\n- case ForwardRef:\n- case MemoComponent:\n- case SimpleMemoComponent:\n- warnAboutUpdateOnUnmounted(fiber, false);\n- break;\n- }\n- }\n- return;\n- }\n-\n- if (\n- !isWorking &&\n- nextRenderExpirationTime !== NoWork &&\n- expirationTime > nextRenderExpirationTime\n- ) {\n- \/\/ This is an interruption. (Used for performance tracking.)\n- interruptedBy = fiber;\n- resetStack();\n- }\n- markPendingPriorityLevel(root, expirationTime);\n- if (\n- \/\/ If we're in the render phase, we don't need to schedule this root\n- \/\/ for an update, because we'll do it before we exit...\n- !isWorking ||\n- isCommitting ||\n- \/\/ ...unless this is a different root than the one we're rendering.\n- nextRoot !== root\n- ) {\n- const rootExpirationTime = root.expirationTime;\n- requestWork(root, rootExpirationTime);\n- }\n- if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {\n- \/\/ Reset this back to zero so subsequent updates don't throw.\n- nestedUpdateCount = 0;\n- invariant(\n- false,\n- 'Maximum update depth exceeded. This can happen when a ' +\n- 'component repeatedly calls setState inside ' +\n- 'componentWillUpdate or componentDidUpdate. React limits ' +\n- 'the number of nested updates to prevent infinite loops.',\n- );\n- }\n- if (__DEV__) {\n- if (\n- isInPassiveEffectDEV &&\n- nestedPassiveEffectCountDEV > NESTED_PASSIVE_UPDATE_LIMIT\n- ) {\n- nestedPassiveEffectCountDEV = 0;\n- warning(\n- false,\n- 'Maximum update depth exceeded. This can happen when a ' +\n- 'component calls setState inside useEffect, but ' +\n- \"useEffect either doesn't have a dependency array, or \" +\n- 'one of the dependencies changes on every render.',\n- );\n- }\n- }\n-}\n-\n-function deferredUpdates (fn: () => A): A {\n- const currentTime = requestCurrentTime();\n- const previousExpirationContext = expirationContext;\n- const previousIsBatchingInteractiveUpdates = isBatchingInteractiveUpdates;\n- expirationContext = computeAsyncExpiration(currentTime);\n- isBatchingInteractiveUpdates = false;\n- try {\n- return fn();\n- } finally {\n- expirationContext = previousExpirationContext;\n- isBatchingInteractiveUpdates = previousIsBatchingInteractiveUpdates;\n- }\n-}\n-\n-function syncUpdates(\n- fn: (A, B, C0, D) => R,\n- a: A,\n- b: B,\n- c: C0,\n- d: D,\n-): R {\n- const previousExpirationContext = expirationContext;\n- expirationContext = Sync;\n- try {\n- return fn(a, b, c, d);\n- } finally {\n- expirationContext = previousExpirationContext;\n- }\n-}\n-\n-\/\/ TODO: Everything below this is written as if it has been lifted to the\n-\/\/ renderers. I'll do this in a follow-up.\n-\n-\/\/ Linked-list of roots\n-let firstScheduledRoot: FiberRoot | null = null;\n-let lastScheduledRoot: FiberRoot | null = null;\n-\n-let callbackExpirationTime: ExpirationTime = NoWork;\n-let callbackID: *;\n-let isRendering: boolean = false;\n-let nextFlushedRoot: FiberRoot | null = null;\n-let nextFlushedExpirationTime: ExpirationTime = NoWork;\n-let lowestPriorityPendingInteractiveExpirationTime: ExpirationTime = NoWork;\n-let hasUnhandledError: boolean = false;\n-let unhandledError: mixed | null = null;\n-\n-let isBatchingUpdates: boolean = false;\n-let isUnbatchingUpdates: boolean = false;\n-let isBatchingInteractiveUpdates: boolean = false;\n-\n-let completedBatches: Array | null = null;\n-\n-let originalStartTimeMs: number = now();\n-let currentRendererTime: ExpirationTime = msToExpirationTime(\n- originalStartTimeMs,\n-);\n-let currentSchedulerTime: ExpirationTime = currentRendererTime;\n-\n-\/\/ Use these to prevent an infinite loop of nested updates\n-const NESTED_UPDATE_LIMIT = 50;\n-let nestedUpdateCount: number = 0;\n-let lastCommittedRootDuringThisBatch: FiberRoot | null = null;\n-\n-\/\/ Similar, but for useEffect infinite loops. These are DEV-only.\n-const NESTED_PASSIVE_UPDATE_LIMIT = 50;\n-let nestedPassiveEffectCountDEV;\n-let isInPassiveEffectDEV;\n-if (__DEV__) {\n- nestedPassiveEffectCountDEV = 0;\n- isInPassiveEffectDEV = false;\n-}\n-\n-function recomputeCurrentRendererTime() {\n- const currentTimeMs = now() - originalStartTimeMs;\n- currentRendererTime = msToExpirationTime(currentTimeMs);\n-}\n-\n-function scheduleCallbackWithExpirationTime(\n- root: FiberRoot,\n- expirationTime: ExpirationTime,\n-) {\n- if (callbackExpirationTime !== NoWork) {\n- \/\/ A callback is already scheduled. Check its expiration time (timeout).\n- if (expirationTime < callbackExpirationTime) {\n- \/\/ Existing callback has sufficient timeout. Exit.\n- return;\n- } else {\n- if (callbackID !== null) {\n- \/\/ Existing callback has insufficient timeout. Cancel and schedule a\n- \/\/ new one.\n- cancelCallback(callbackID);\n- }\n- }\n- \/\/ The request callback timer is already running. Don't start a new one.\n- } else {\n- startRequestCallbackTimer();\n- }\n-\n- callbackExpirationTime = expirationTime;\n- const currentMs = now() - originalStartTimeMs;\n- const expirationTimeMs = expirationTimeToMs(expirationTime);\n- const timeout = expirationTimeMs - currentMs;\n- const priorityLevel = getCurrentPriorityLevel();\n- callbackID = scheduleCallback(priorityLevel, performAsyncWork, {timeout});\n-}\n-\n-\/\/ For every call to renderRoot, one of onFatal, onComplete, onSuspend, and\n-\/\/ onYield is called upon exiting. We use these in lieu of returning a tuple.\n-\/\/ I've also chosen not to inline them into renderRoot because these will\n-\/\/ eventually be lifted into the renderer.\n-function onFatal(root) {\n- root.finishedWork = null;\n-}\n-\n-function onComplete(\n- root: FiberRoot,\n- finishedWork: Fiber,\n- expirationTime: ExpirationTime,\n-) {\n- root.pendingCommitExpirationTime = expirationTime;\n- root.finishedWork = finishedWork;\n-}\n-\n-function onSuspend(\n- root: FiberRoot,\n- finishedWork: Fiber,\n- suspendedExpirationTime: ExpirationTime,\n- rootExpirationTime: ExpirationTime,\n- msUntilTimeout: number,\n-): void {\n- root.expirationTime = rootExpirationTime;\n- if (msUntilTimeout === 0 && (disableYielding || !shouldYield())) {\n- \/\/ Don't wait an additional tick. Commit the tree immediately.\n- root.pendingCommitExpirationTime = suspendedExpirationTime;\n- root.finishedWork = finishedWork;\n- } else if (msUntilTimeout > 0) {\n- \/\/ Wait `msUntilTimeout` milliseconds before committing.\n- root.timeoutHandle = scheduleTimeout(\n- onTimeout.bind(null, root, finishedWork, suspendedExpirationTime),\n- msUntilTimeout,\n- );\n- }\n-}\n-\n-function onYield(root) {\n- root.finishedWork = null;\n-}\n-\n-function onTimeout(root, finishedWork, suspendedExpirationTime) {\n- \/\/ The root timed out. Commit it.\n- root.pendingCommitExpirationTime = suspendedExpirationTime;\n- root.finishedWork = finishedWork;\n- \/\/ Read the current time before entering the commit phase. We can be\n- \/\/ certain this won't cause tearing related to batching of event updates\n- \/\/ because we're at the top of a timer event.\n- recomputeCurrentRendererTime();\n- currentSchedulerTime = currentRendererTime;\n- flushRoot(root, suspendedExpirationTime);\n-}\n-\n-function onCommit(root, expirationTime) {\n- root.expirationTime = expirationTime;\n- root.finishedWork = null;\n-}\n-\n-function requestCurrentTime() {\n- \/\/ requestCurrentTime is called by the scheduler to compute an expiration\n- \/\/ time.\n- \/\/\n- \/\/ Expiration times are computed by adding to the current time (the start\n- \/\/ time). However, if two updates are scheduled within the same event, we\n- \/\/ should treat their start times as simultaneous, even if the actual clock\n- \/\/ time has advanced between the first and second call.\n-\n- \/\/ In other words, because expiration times determine how updates are batched,\n- \/\/ we want all updates of like priority that occur within the same event to\n- \/\/ receive the same expiration time. Otherwise we get tearing.\n- \/\/\n- \/\/ We keep track of two separate times: the current \"renderer\" time and the\n- \/\/ current \"scheduler\" time. The renderer time can be updated whenever; it\n- \/\/ only exists to minimize the calls performance.now.\n- \/\/\n- \/\/ But the scheduler time can only be updated if there's no pending work, or\n- \/\/ if we know for certain that we're not in the middle of an event.\n-\n- if (isRendering) {\n- \/\/ We're already rendering. Return the most recently read time.\n- return currentSchedulerTime;\n- }\n- \/\/ Check if there's pending work.\n- findHighestPriorityRoot();\n- if (\n- nextFlushedExpirationTime === NoWork ||\n- nextFlushedExpirationTime === Never\n- ) {\n- \/\/ If there's no pending work, or if the pending work is offscreen, we can\n- \/\/ read the current time without risk of tearing.\n- recomputeCurrentRendererTime();\n- currentSchedulerTime = currentRendererTime;\n- return currentSchedulerTime;\n- }\n- \/\/ There's already pending work. We might be in the middle of a browser\n- \/\/ event. If we were to read the current time, it could cause multiple updates\n- \/\/ within the same event to receive different expiration times, leading to\n- \/\/ tearing. Return the last read time. During the next idle callback, the\n- \/\/ time will be updated.\n- return currentSchedulerTime;\n-}\n-\n-\/\/ requestWork is called by the scheduler whenever a root receives an update.\n-\/\/ It's up to the renderer to call renderRoot at some point in the future.\n-function requestWork(root: FiberRoot, expirationTime: ExpirationTime) {\n- addRootToSchedule(root, expirationTime);\n- if (isRendering) {\n- \/\/ Prevent reentrancy. Remaining work will be scheduled at the end of\n- \/\/ the currently rendering batch.\n- return;\n- }\n-\n- if (isBatchingUpdates) {\n- \/\/ Flush work at the end of the batch.\n- if (isUnbatchingUpdates) {\n- \/\/ ...unless we're inside unbatchedUpdates, in which case we should\n- \/\/ flush it now.\n- nextFlushedRoot = root;\n- nextFlushedExpirationTime = Sync;\n- performWorkOnRoot(root, Sync, false);\n- }\n- return;\n- }\n-\n- \/\/ TODO: Get rid of Sync and use current time?\n- if (expirationTime === Sync) {\n- performSyncWork();\n- } else {\n- scheduleCallbackWithExpirationTime(root, expirationTime);\n- }\n-}\n-\n-function addRootToSchedule(root: FiberRoot, expirationTime: ExpirationTime) {\n- \/\/ Add the root to the schedule.\n- \/\/ Check if this root is already part of the schedule.\n- if (root.nextScheduledRoot === null) {\n- \/\/ This root is not already scheduled. Add it.\n- root.expirationTime = expirationTime;\n- if (lastScheduledRoot === null) {\n- firstScheduledRoot = lastScheduledRoot = root;\n- root.nextScheduledRoot = root;\n- } else {\n- lastScheduledRoot.nextScheduledRoot = root;\n- lastScheduledRoot = root;\n- lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;\n- }\n- } else {\n- \/\/ This root is already scheduled, but its priority may have increased.\n- const remainingExpirationTime = root.expirationTime;\n- if (expirationTime > remainingExpirationTime) {\n- \/\/ Update the priority.\n- root.expirationTime = expirationTime;\n- }\n- }\n-}\n-\n-function findHighestPriorityRoot() {\n- let highestPriorityWork = NoWork;\n- let highestPriorityRoot = null;\n- if (lastScheduledRoot !== null) {\n- let previousScheduledRoot = lastScheduledRoot;\n- let root = firstScheduledRoot;\n- while (root !== null) {\n- const remainingExpirationTime = root.expirationTime;\n- if (remainingExpirationTime === NoWork) {\n- \/\/ This root no longer has work. Remove it from the scheduler.\n-\n- \/\/ TODO: This check is redudant, but Flow is confused by the branch\n- \/\/ below where we set lastScheduledRoot to null, even though we break\n- \/\/ from the loop right after.\n- invariant(\n- previousScheduledRoot !== null && lastScheduledRoot !== null,\n- 'Should have a previous and last root. This error is likely ' +\n- 'caused by a bug in React. Please file an issue.',\n- );\n- if (root === root.nextScheduledRoot) {\n- \/\/ This is the only root in the list.\n- root.nextScheduledRoot = null;\n- firstScheduledRoot = lastScheduledRoot = null;\n- break;\n- } else if (root === firstScheduledRoot) {\n- \/\/ This is the first root in the list.\n- const next = root.nextScheduledRoot;\n- firstScheduledRoot = next;\n- lastScheduledRoot.nextScheduledRoot = next;\n- root.nextScheduledRoot = null;\n- } else if (root === lastScheduledRoot) {\n- \/\/ This is the last root in the list.\n- lastScheduledRoot = previousScheduledRoot;\n- lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;\n- root.nextScheduledRoot = null;\n- break;\n- } else {\n- previousScheduledRoot.nextScheduledRoot = root.nextScheduledRoot;\n- root.nextScheduledRoot = null;\n- }\n- root = previousScheduledRoot.nextScheduledRoot;\n- } else {\n- if (remainingExpirationTime > highestPriorityWork) {\n- \/\/ Update the priority, if it's higher\n- highestPriorityWork = remainingExpirationTime;\n- highestPriorityRoot = root;\n- }\n- if (root === lastScheduledRoot) {\n- break;\n- }\n- if (highestPriorityWork === Sync) {\n- \/\/ Sync is highest priority by definition so\n- \/\/ we can stop searching.\n- break;\n- }\n- previousScheduledRoot = root;\n- root = root.nextScheduledRoot;\n- }\n- }\n- }\n-\n- nextFlushedRoot = highestPriorityRoot;\n- nextFlushedExpirationTime = highestPriorityWork;\n-}\n-\n-function performAsyncWork(didTimeout) {\n- if (didTimeout) {\n- \/\/ The callback timed out. That means at least one update has expired.\n- \/\/ Iterate through the root schedule. If they contain expired work, set\n- \/\/ the next render expiration time to the current time. This has the effect\n- \/\/ of flushing all expired work in a single batch, instead of flushing each\n- \/\/ level one at a time.\n- if (firstScheduledRoot !== null) {\n- recomputeCurrentRendererTime();\n- let root: FiberRoot = firstScheduledRoot;\n- do {\n- didExpireAtExpirationTime(root, currentRendererTime);\n- \/\/ The root schedule is circular, so this is never null.\n- root = (root.nextScheduledRoot: any);\n- } while (root !== firstScheduledRoot);\n- }\n- }\n-\n- \/\/ Keep working on roots until there's no more work, or until there's a higher\n- \/\/ priority event.\n- findHighestPriorityRoot();\n-\n- if (disableYielding) {\n- \/\/ Just do it all\n- while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork) {\n- performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);\n- findHighestPriorityRoot();\n- }\n- } else {\n- recomputeCurrentRendererTime();\n- currentSchedulerTime = currentRendererTime;\n-\n- if (enableUserTimingAPI) {\n- const didExpire = nextFlushedExpirationTime > currentRendererTime;\n- const timeout = expirationTimeToMs(nextFlushedExpirationTime);\n- stopRequestCallbackTimer(didExpire, timeout);\n- }\n-\n- while (\n- nextFlushedRoot !== null &&\n- nextFlushedExpirationTime !== NoWork &&\n- !(shouldYield() && currentRendererTime > nextFlushedExpirationTime)\n- ) {\n- performWorkOnRoot(\n- nextFlushedRoot,\n- nextFlushedExpirationTime,\n- currentRendererTime > nextFlushedExpirationTime,\n- );\n- findHighestPriorityRoot();\n- recomputeCurrentRendererTime();\n- currentSchedulerTime = currentRendererTime;\n- }\n- }\n-\n- \/\/ We're done flushing work. Either we ran out of time in this callback,\n- \/\/ or there's no more work left with sufficient priority.\n-\n- \/\/ If we're inside a callback, set this to false since we just completed it.\n- callbackExpirationTime = NoWork;\n- callbackID = null;\n-\n- \/\/ If there's work left over, schedule a new callback.\n- if (nextFlushedExpirationTime !== NoWork) {\n- scheduleCallbackWithExpirationTime(\n- ((nextFlushedRoot: any): FiberRoot),\n- nextFlushedExpirationTime,\n- );\n- }\n-\n- \/\/ Clean-up.\n- finishRendering();\n-}\n-\n-function performSyncWork() {\n- performWork(Sync);\n-}\n-\n-function performWork(minExpirationTime: ExpirationTime) {\n- \/\/ Keep working on roots until there's no more work, or until there's a higher\n- \/\/ priority event.\n- findHighestPriorityRoot();\n-\n- while (\n- nextFlushedRoot !== null &&\n- nextFlushedExpirationTime !== NoWork &&\n- minExpirationTime <= nextFlushedExpirationTime\n- ) {\n- performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);\n- findHighestPriorityRoot();\n- }\n-\n- \/\/ We're done flushing work. Either we ran out of time in this callback,\n- \/\/ or there's no more work left with sufficient priority.\n-\n- \/\/ If there's work left over, schedule a new callback.\n- if (nextFlushedExpirationTime !== NoWork) {\n- scheduleCallbackWithExpirationTime(\n- ((nextFlushedRoot: any): FiberRoot),\n- nextFlushedExpirationTime,\n- );\n- }\n-\n- \/\/ Clean-up.\n- finishRendering();\n-}\n-\n-function flushRoot(root: FiberRoot, expirationTime: ExpirationTime) {\n- invariant(\n- !isRendering,\n- 'work.commit(): Cannot commit while already rendering. This likely ' +\n- 'means you attempted to commit from inside a lifecycle method.',\n- );\n- \/\/ Perform work on root as if the given expiration time is the current time.\n- \/\/ This has the effect of synchronously flushing all work up to and\n- \/\/ including the given time.\n- nextFlushedRoot = root;\n- nextFlushedExpirationTime = expirationTime;\n- performWorkOnRoot(root, expirationTime, false);\n- \/\/ Flush any sync work that was scheduled by lifecycles\n- performSyncWork();\n-}\n-\n-function finishRendering() {\n- nestedUpdateCount = 0;\n- lastCommittedRootDuringThisBatch = null;\n-\n- if (__DEV__) {\n- if (rootWithPendingPassiveEffects === null) {\n- nestedPassiveEffectCountDEV = 0;\n- }\n- }\n-\n- if (completedBatches !== null) {\n- const batches = completedBatches;\n- completedBatches = null;\n- for (let i = 0; i < batches.length; i++) {\n- const batch = batches[i];\n- try {\n- batch._onComplete();\n- } catch (error) {\n- if (!hasUnhandledError) {\n- hasUnhandledError = true;\n- unhandledError = error;\n- }\n- }\n- }\n- }\n-\n- if (hasUnhandledError) {\n- const error = unhandledError;\n- unhandledError = null;\n- hasUnhandledError = false;\n- throw error;\n- }\n-}\n-\n-function performWorkOnRoot(\n- root: FiberRoot,\n- expirationTime: ExpirationTime,\n- isYieldy: boolean,\n-) {\n- invariant(\n- !isRendering,\n- 'performWorkOnRoot was called recursively. This error is likely caused ' +\n- 'by a bug in React. Please file an issue.',\n- );\n-\n- isRendering = true;\n-\n- \/\/ Check if this is async work or sync\/expired work.\n- if (!isYieldy) {\n- \/\/ Flush work without yielding.\n- \/\/ TODO: Non-yieldy work does not necessarily imply expired work. A renderer\n- \/\/ may want to perform some work without yielding, but also without\n- \/\/ requiring the root to complete (by triggering placeholders).\n-\n- let finishedWork = root.finishedWork;\n- if (finishedWork !== null) {\n- \/\/ This root is already complete. We can commit it.\n- completeRoot(root, finishedWork, expirationTime);\n- } else {\n- root.finishedWork = null;\n- \/\/ If this root previously suspended, clear its existing timeout, since\n- \/\/ we're about to try rendering again.\n- const timeoutHandle = root.timeoutHandle;\n- if (timeoutHandle !== noTimeout) {\n- root.timeoutHandle = noTimeout;\n- \/\/ $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above\n- cancelTimeout(timeoutHandle);\n- }\n- renderRoot(root, isYieldy);\n- finishedWork = root.finishedWork;\n- if (finishedWork !== null) {\n- \/\/ We've completed the root. Commit it.\n- completeRoot(root, finishedWork, expirationTime);\n- }\n- }\n- } else {\n- \/\/ Flush async work.\n- let finishedWork = root.finishedWork;\n- if (finishedWork !== null) {\n- \/\/ This root is already complete. We can commit it.\n- completeRoot(root, finishedWork, expirationTime);\n- } else {\n- root.finishedWork = null;\n- \/\/ If this root previously suspended, clear its existing timeout, since\n- \/\/ we're about to try rendering again.\n- const timeoutHandle = root.timeoutHandle;\n- if (timeoutHandle !== noTimeout) {\n- root.timeoutHandle = noTimeout;\n- \/\/ $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above\n- cancelTimeout(timeoutHandle);\n- }\n- renderRoot(root, isYieldy);\n- finishedWork = root.finishedWork;\n- if (finishedWork !== null) {\n- \/\/ We've completed the root. Check the if we should yield one more time\n- \/\/ before committing.\n- if (!shouldYield()) {\n- \/\/ Still time left. Commit the root.\n- completeRoot(root, finishedWork, expirationTime);\n- } else {\n- \/\/ There's no time left. Mark this root as complete. We'll come\n- \/\/ back and commit it later.\n- root.finishedWork = finishedWork;\n- }\n- }\n- }\n- }\n-\n- isRendering = false;\n-}\n-\n-function completeRoot(\n- root: FiberRoot,\n- finishedWork: Fiber,\n- expirationTime: ExpirationTime,\n-): void {\n- \/\/ Check if there's a batch that matches this expiration time.\n- const firstBatch = root.firstBatch;\n- if (firstBatch !== null && firstBatch._expirationTime >= expirationTime) {\n- if (completedBatches === null) {\n- completedBatches = [firstBatch];\n- } else {\n- completedBatches.push(firstBatch);\n- }\n- if (firstBatch._defer) {\n- \/\/ This root is blocked from committing by a batch. Unschedule it until\n- \/\/ we receive another update.\n- root.finishedWork = finishedWork;\n- root.expirationTime = NoWork;\n- return;\n- }\n- }\n-\n- \/\/ Commit the root.\n- root.finishedWork = null;\n-\n- \/\/ Check if this is a nested update (a sync update scheduled during the\n- \/\/ commit phase).\n- if (root === lastCommittedRootDuringThisBatch) {\n- \/\/ If the next root is the same as the previous root, this is a nested\n- \/\/ update. To prevent an infinite loop, increment the nested update count.\n- nestedUpdateCount++;\n- } else {\n- \/\/ Reset whenever we switch roots.\n- lastCommittedRootDuringThisBatch = root;\n- nestedUpdateCount = 0;\n- }\n- commitRoot(root, finishedWork);\n-}\n-\n-function onUncaughtError(error: mixed) {\n- invariant(\n- nextFlushedRoot !== null,\n- 'Should be working on a root. This error is likely caused by a bug in ' +\n- 'React. Please file an issue.',\n- );\n- \/\/ Unschedule this root so we don't work on it again until there's\n- \/\/ another update.\n- nextFlushedRoot.expirationTime = NoWork;\n- if (!hasUnhandledError) {\n- hasUnhandledError = true;\n- unhandledError = error;\n- }\n-}\n-\n-\/\/ TODO: Batching should be implemented at the renderer level, not inside\n-\/\/ the reconciler.\n-function batchedUpdates(fn: (a: A) => R, a: A): R {\n- const previousIsBatchingUpdates = isBatchingUpdates;\n- isBatchingUpdates = true;\n- try {\n- return fn(a);\n- } finally {\n- isBatchingUpdates = previousIsBatchingUpdates;\n- if (!isBatchingUpdates && !isRendering) {\n- performSyncWork();\n- }\n- }\n-}\n-\n-\/\/ TODO: Batching should be implemented at the renderer level, not inside\n-\/\/ the reconciler.\n-function unbatchedUpdates(fn: (a: A) => R, a: A): R {\n- if (isBatchingUpdates && !isUnbatchingUpdates) {\n- isUnbatchingUpdates = true;\n- try {\n- return fn(a);\n- } finally {\n- isUnbatchingUpdates = false;\n- }\n- }\n- return fn(a);\n-}\n-\n-\/\/ TODO: Batching should be implemented at the renderer level, not within\n-\/\/ the reconciler.\n-function flushSync(fn: (a: A) => R, a: A): R {\n- invariant(\n- !isRendering,\n- 'flushSync was called from inside a lifecycle method. It cannot be ' +\n- 'called when React is already rendering.',\n- );\n- const previousIsBatchingUpdates = isBatchingUpdates;\n- isBatchingUpdates = true;\n- try {\n- return syncUpdates(fn, a);\n- } finally {\n- isBatchingUpdates = previousIsBatchingUpdates;\n- performSyncWork();\n- }\n-}\n-\n-function interactiveUpdates(\n- fn: (A, B, C) => R,\n- a: A,\n- b: B,\n- c: C,\n-): R {\n- if (isBatchingInteractiveUpdates) {\n- return fn(a, b, c);\n- }\n- \/\/ If there are any pending interactive updates, synchronously flush them.\n- \/\/ This needs to happen before we read any handlers, because the effect of\n- \/\/ the previous event may influence which handlers are called during\n- \/\/ this event.\n- if (\n- !isBatchingUpdates &&\n- !isRendering &&\n- lowestPriorityPendingInteractiveExpirationTime !== NoWork\n- ) {\n- \/\/ Synchronously flush pending interactive updates.\n- performWork(lowestPriorityPendingInteractiveExpirationTime);\n- lowestPriorityPendingInteractiveExpirationTime = NoWork;\n- }\n- const previousIsBatchingInteractiveUpdates = isBatchingInteractiveUpdates;\n- const previousIsBatchingUpdates = isBatchingUpdates;\n- isBatchingInteractiveUpdates = true;\n- isBatchingUpdates = true;\n- try {\n- return fn(a, b, c);\n- } finally {\n- isBatchingInteractiveUpdates = previousIsBatchingInteractiveUpdates;\n- isBatchingUpdates = previousIsBatchingUpdates;\n- if (!isBatchingUpdates && !isRendering) {\n- performSyncWork();\n- }\n- }\n-}\n-\n-function flushInteractiveUpdates() {\n- if (\n- !isRendering &&\n- lowestPriorityPendingInteractiveExpirationTime !== NoWork\n- ) {\n- \/\/ Synchronously flush pending interactive updates.\n- performWork(lowestPriorityPendingInteractiveExpirationTime);\n- lowestPriorityPendingInteractiveExpirationTime = NoWork;\n- }\n-}\n-\n-function flushControlled(fn: () => mixed): void {\n- const previousIsBatchingUpdates = isBatchingUpdates;\n- isBatchingUpdates = true;\n- try {\n- syncUpdates(fn);\n- } finally {\n- isBatchingUpdates = previousIsBatchingUpdates;\n- if (!isBatchingUpdates && !isRendering) {\n- performSyncWork();\n- }\n- }\n-}\n-\n-export {\n- requestCurrentTime,\n- computeExpirationForFiber,\n- captureCommitPhaseError,\n- onUncaughtError,\n- markRenderEventTime,\n- renderDidSuspend,\n- renderDidError,\n- pingSuspendedRoot,\n- retryTimedOutBoundary,\n- resolveRetryThenable,\n- markLegacyErrorBoundaryAsFailed,\n- isAlreadyFailedLegacyErrorBoundary,\n- scheduleWork,\n- flushRoot,\n- batchedUpdates,\n- unbatchedUpdates,\n- flushSync,\n- flushControlled,\n- deferredUpdates,\n- syncUpdates,\n- interactiveUpdates,\n- flushInteractiveUpdates,\n- computeUniqueAsyncExpiration,\n- flushPassiveEffects,\n-};\ndiff --git a\/packages\/react-reconciler\/src\/SchedulerWithReactIntegration.js b\/packages\/react-reconciler\/src\/SchedulerWithReactIntegration.js\nindex 323ab5528f..3a30a2ea2e 100644\n--- a\/packages\/react-reconciler\/src\/SchedulerWithReactIntegration.js\n+++ b\/packages\/react-reconciler\/src\/SchedulerWithReactIntegration.js\n@@ -10,8 +10,11 @@\n \/\/ Intentionally not named imports because Rollup would use dynamic dispatch for\n \/\/ CommonJS interop named imports.\n import * as Scheduler from 'scheduler';\n-\n-import {disableYielding} from 'shared\/ReactFeatureFlags';\n+import {__interactionsRef} from 'scheduler\/tracing';\n+import {\n+ disableYielding,\n+ enableSchedulerTracing,\n+} from 'shared\/ReactFeatureFlags';\n import invariant from 'shared\/invariant';\n \n const {\n@@ -28,6 +31,20 @@ const {\n unstable_IdlePriority: Scheduler_IdlePriority,\n } = Scheduler;\n \n+if (enableSchedulerTracing) {\n+ \/\/ Provide explicit error message when production+profiling bundle of e.g.\n+ \/\/ react-dom is used with production (non-profiling) bundle of\n+ \/\/ scheduler\/tracing\n+ invariant(\n+ __interactionsRef != null && __interactionsRef.current != null,\n+ 'It is not supported to run the profiling version of a renderer (for ' +\n+ 'example, `react-dom\/profiling`) without also replacing the ' +\n+ '`scheduler\/tracing` module with `scheduler\/tracing-profiling`. Your ' +\n+ 'bundler might have a setting for aliasing both modules. Learn more at ' +\n+ 'http:\/\/fb.me\/react-profiling',\n+ );\n+}\n+\n export opaque type ReactPriorityLevel = 99 | 98 | 97 | 96 | 95 | 90;\n export type SchedulerCallback = (isSync: boolean) => SchedulerCallback | null;\n \ndiff --git a\/packages\/react-reconciler\/src\/__tests__\/ReactIncrementalErrorHandling-test.internal.js b\/packages\/react-reconciler\/src\/__tests__\/ReactIncrementalErrorHandling-test.internal.js\nindex 4d6ddee647..6fe7fc0936 100644\n--- a\/packages\/react-reconciler\/src\/__tests__\/ReactIncrementalErrorHandling-test.internal.js\n+++ b\/packages\/react-reconciler\/src\/__tests__\/ReactIncrementalErrorHandling-test.internal.js\n@@ -15,7 +15,6 @@ let ReactFeatureFlags;\n let React;\n let ReactNoop;\n let Scheduler;\n-let enableNewScheduler;\n \n describe('ReactIncrementalErrorHandling', () => {\n beforeEach(() => {\n@@ -23,7 +22,6 @@ describe('ReactIncrementalErrorHandling', () => {\n ReactFeatureFlags = require('shared\/ReactFeatureFlags');\n ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = false;\n ReactFeatureFlags.replayFailedUnitOfWorkWithInvokeGuardedCallback = false;\n- enableNewScheduler = ReactFeatureFlags.enableNewScheduler;\n PropTypes = require('prop-types');\n React = require('react');\n ReactNoop = require('react-noop-renderer');\n@@ -1034,23 +1032,15 @@ describe('ReactIncrementalErrorHandling', () => {\n ReactNoop.renderToRootWithID(, 'e');\n ReactNoop.renderToRootWithID(, 'f');\n \n- if (enableNewScheduler) {\n- \/\/ The new scheduler will throw all three errors.\n- expect(() => {\n- expect(Scheduler).toFlushWithoutYielding();\n- }).toThrow('a');\n- expect(() => {\n- expect(Scheduler).toFlushWithoutYielding();\n- }).toThrow('c');\n- expect(() => {\n- expect(Scheduler).toFlushWithoutYielding();\n- }).toThrow('e');\n- } else {\n- \/\/ The old scheduler only throws the first one.\n- expect(() => {\n- expect(Scheduler).toFlushWithoutYielding();\n- }).toThrow('a');\n- }\n+ expect(() => {\n+ expect(Scheduler).toFlushWithoutYielding();\n+ }).toThrow('a');\n+ expect(() => {\n+ expect(Scheduler).toFlushWithoutYielding();\n+ }).toThrow('c');\n+ expect(() => {\n+ expect(Scheduler).toFlushWithoutYielding();\n+ }).toThrow('e');\n \n expect(Scheduler).toFlushWithoutYielding();\n expect(ReactNoop.getChildren('a')).toEqual([]);\ndiff --git a\/packages\/react-reconciler\/src\/__tests__\/ReactIncrementalPerf-test.internal.js b\/packages\/react-reconciler\/src\/__tests__\/ReactIncrementalPerf-test.internal.js\nindex 1c6bf0f6b7..2080cbc17a 100644\n--- a\/packages\/react-reconciler\/src\/__tests__\/ReactIncrementalPerf-test.internal.js\n+++ b\/packages\/react-reconciler\/src\/__tests__\/ReactIncrementalPerf-test.internal.js\n@@ -118,568 +118,554 @@ describe('ReactDebugFiberPerf', () => {\n return
{props.children}<\/div>;\n }\n \n- describe('old scheduler', () => {\n- runTests(false);\n+ beforeEach(() => {\n+ jest.resetModules();\n+ resetFlamechart();\n+ global.performance = createUserTimingPolyfill();\n+\n+ require('shared\/ReactFeatureFlags').enableUserTimingAPI = true;\n+ require('shared\/ReactFeatureFlags').enableProfilerTimer = false;\n+ require('shared\/ReactFeatureFlags').replayFailedUnitOfWorkWithInvokeGuardedCallback = false;\n+ require('shared\/ReactFeatureFlags').debugRenderPhaseSideEffectsForStrictMode = false;\n+\n+ \/\/ Import after the polyfill is set up:\n+ React = require('react');\n+ ReactNoop = require('react-noop-renderer');\n+ Scheduler = require('scheduler');\n+ PropTypes = require('prop-types');\n });\n \n- describe('new scheduler', () => {\n- runTests(true);\n+ afterEach(() => {\n+ delete global.performance;\n });\n \n- function runTests(enableNewScheduler) {\n- beforeEach(() => {\n- jest.resetModules();\n- resetFlamechart();\n- global.performance = createUserTimingPolyfill();\n-\n- require('shared\/ReactFeatureFlags').enableNewScheduler = enableNewScheduler;\n- require('shared\/ReactFeatureFlags').enableUserTimingAPI = true;\n- require('shared\/ReactFeatureFlags').enableProfilerTimer = false;\n- require('shared\/ReactFeatureFlags').replayFailedUnitOfWorkWithInvokeGuardedCallback = false;\n- require('shared\/ReactFeatureFlags').debugRenderPhaseSideEffectsForStrictMode = false;\n-\n- \/\/ Import after the polyfill is set up:\n- React = require('react');\n- ReactNoop = require('react-noop-renderer');\n- Scheduler = require('scheduler');\n- PropTypes = require('prop-types');\n- });\n+ it('measures a simple reconciliation', () => {\n+ ReactNoop.render(\n+ \n+ \n+ <\/Parent>,\n+ );\n+ addComment('Mount');\n+ expect(Scheduler).toFlushWithoutYielding();\n+\n+ ReactNoop.render(\n+ \n+ \n+ <\/Parent>,\n+ );\n+ addComment('Update');\n+ expect(Scheduler).toFlushWithoutYielding();\n+\n+ ReactNoop.render(null);\n+ addComment('Unmount');\n+ expect(Scheduler).toFlushWithoutYielding();\n+\n+ expect(getFlameChart()).toMatchSnapshot();\n+ });\n \n- afterEach(() => {\n- delete global.performance;\n+ it('properly displays the forwardRef component in measurements', () => {\n+ const AnonymousForwardRef = React.forwardRef((props, ref) => (\n+ \n+ ));\n+ const NamedForwardRef = React.forwardRef(function refForwarder(props, ref) {\n+ return ;\n });\n+ function notImportant(props, ref) {\n+ return ;\n+ }\n+ notImportant.displayName = 'OverriddenName';\n+ const DisplayNamedForwardRef = React.forwardRef(notImportant);\n+\n+ ReactNoop.render(\n+ \n+ \n+ \n+ \n+ <\/Parent>,\n+ );\n+ addComment('Mount');\n+ expect(Scheduler).toFlushWithoutYielding();\n+\n+ expect(getFlameChart()).toMatchSnapshot();\n+ });\n \n- it('measures a simple reconciliation', () => {\n- ReactNoop.render(\n- \n- \n- <\/Parent>,\n- );\n- addComment('Mount');\n- expect(Scheduler).toFlushWithoutYielding();\n-\n- ReactNoop.render(\n- \n- \n- <\/Parent>,\n- );\n- addComment('Update');\n- expect(Scheduler).toFlushWithoutYielding();\n-\n- ReactNoop.render(null);\n- addComment('Unmount');\n- expect(Scheduler).toFlushWithoutYielding();\n+ it('does not include ConcurrentMode, StrictMode, or Profiler components in measurements', () => {\n+ ReactNoop.render(\n+ \n+ \n+ \n+ \n+ \n+ <\/React.unstable_ConcurrentMode>\n+ <\/Parent>\n+ <\/React.StrictMode>\n+ <\/React.Profiler>,\n+ );\n+ addComment('Mount');\n+ expect(Scheduler).toFlushWithoutYielding();\n \n- expect(getFlameChart()).toMatchSnapshot();\n- });\n+ expect(getFlameChart()).toMatchSnapshot();\n+ });\n \n- it('properly displays the forwardRef component in measurements', () => {\n- const AnonymousForwardRef = React.forwardRef((props, ref) => (\n- \n- ));\n- const NamedForwardRef = React.forwardRef(function refForwarder(\n- props,\n- ref,\n- ) {\n- return ;\n- });\n- function notImportant(props, ref) {\n- return ;\n- }\n- notImportant.displayName = 'OverriddenName';\n- const DisplayNamedForwardRef = React.forwardRef(notImportant);\n+ it('does not include context provider or consumer in measurements', () => {\n+ const {Consumer, Provider} = React.createContext(true);\n \n- ReactNoop.render(\n+ ReactNoop.render(\n+ \n \n- \n- \n- \n- <\/Parent>,\n- );\n- addComment('Mount');\n- expect(Scheduler).toFlushWithoutYielding();\n-\n- expect(getFlameChart()).toMatchSnapshot();\n- });\n-\n- it('does not include ConcurrentMode, StrictMode, or Profiler components in measurements', () => {\n- ReactNoop.render(\n- \n- \n- \n- \n- \n- <\/React.unstable_ConcurrentMode>\n- <\/Parent>\n- <\/React.StrictMode>\n- <\/React.Profiler>,\n- );\n- addComment('Mount');\n- expect(Scheduler).toFlushWithoutYielding();\n-\n- expect(getFlameChart()).toMatchSnapshot();\n- });\n-\n- it('does not include context provider or consumer in measurements', () => {\n- const {Consumer, Provider} = React.createContext(true);\n-\n- ReactNoop.render(\n- \n- \n- {value => }<\/Consumer>\n- <\/Parent>\n- <\/Provider>,\n- );\n- addComment('Mount');\n- expect(Scheduler).toFlushWithoutYielding();\n-\n- expect(getFlameChart()).toMatchSnapshot();\n- });\n+ {value => }<\/Consumer>\n+ <\/Parent>\n+ <\/Provider>,\n+ );\n+ addComment('Mount');\n+ expect(Scheduler).toFlushWithoutYielding();\n+\n+ expect(getFlameChart()).toMatchSnapshot();\n+ });\n \n- it('skips parents during setState', () => {\n- class A extends React.Component {\n- render() {\n- return
{this.props.children}<\/div>;\n- }\n+ it('skips parents during setState', () => {\n+ class A extends React.Component {\n+ render() {\n+ return
{this.props.children}<\/div>;\n }\n+ }\n \n- class B extends React.Component {\n- render() {\n- return
{this.props.children}<\/div>;\n- }\n+ class B extends React.Component {\n+ render() {\n+ return
{this.props.children}<\/div>;\n }\n+ }\n \n- let a;\n- let b;\n- ReactNoop.render(\n+ let a;\n+ let b;\n+ ReactNoop.render(\n+ \n \n \n- \n- (a = inst)} \/>\n- <\/Parent>\n- <\/Parent>\n- \n- (b = inst)} \/>\n+ (a = inst)} \/>\n <\/Parent>\n- <\/Parent>,\n- );\n- expect(Scheduler).toFlushWithoutYielding();\n- resetFlamechart();\n-\n- a.setState({});\n- b.setState({});\n- addComment('Should include just A and B, no Parents');\n- expect(Scheduler).toFlushWithoutYielding();\n- expect(getFlameChart()).toMatchSnapshot();\n- });\n-\n- it('warns on cascading renders from setState', () => {\n- class Cascading extends React.Component {\n- componentDidMount() {\n- this.setState({});\n- }\n- render() {\n- return
{this.props.children}<\/div>;\n- }\n- }\n-\n- ReactNoop.render(\n+ <\/Parent>\n \n- \n- <\/Parent>,\n- );\n- addComment('Should print a warning');\n- expect(Scheduler).toFlushWithoutYielding();\n- expect(getFlameChart()).toMatchSnapshot();\n- });\n+ (b = inst)} \/>\n+ <\/Parent>\n+ <\/Parent>,\n+ );\n+ expect(Scheduler).toFlushWithoutYielding();\n+ resetFlamechart();\n+\n+ a.setState({});\n+ b.setState({});\n+ addComment('Should include just A and B, no Parents');\n+ expect(Scheduler).toFlushWithoutYielding();\n+ expect(getFlameChart()).toMatchSnapshot();\n+ });\n \n- it('warns on cascading renders from top-level render', () => {\n- class Cascading extends React.Component {\n- componentDidMount() {\n- ReactNoop.renderToRootWithID(, 'b');\n- addComment('Scheduling another root from componentDidMount');\n- }\n- render() {\n- return {this.props.children}<\/div>;\n- }\n+ it('warns on cascading renders from setState', () => {\n+ class Cascading extends React.Component {\n+ componentDidMount() {\n+ this.setState({});\n }\n-\n- ReactNoop.renderToRootWithID(, 'a');\n- addComment('Rendering the first root');\n- expect(Scheduler).toFlushWithoutYielding();\n- expect(getFlameChart()).toMatchSnapshot();\n- });\n-\n- it('does not treat setState from cWM or cWRP as cascading', () => {\n- class NotCascading extends React.Component {\n- UNSAFE_componentWillMount() {\n- this.setState({});\n- }\n- UNSAFE_componentWillReceiveProps() {\n- this.setState({});\n- }\n- render() {\n- return
{this.props.children}<\/div>;\n- }\n+ render() {\n+ return
{this.props.children}<\/div>;\n }\n+ }\n+\n+ ReactNoop.render(\n+ \n+ \n+ <\/Parent>,\n+ );\n+ addComment('Should print a warning');\n+ expect(Scheduler).toFlushWithoutYielding();\n+ expect(getFlameChart()).toMatchSnapshot();\n+ });\n \n- ReactNoop.render(\n- \n- \n- <\/Parent>,\n- );\n- addComment('Should not print a warning');\n- expect(() => expect(Scheduler).toFlushWithoutYielding()).toWarnDev(\n- [\n- 'componentWillMount: Please update the following components ' +\n- 'to use componentDidMount instead: NotCascading' +\n- '\\n\\ncomponentWillReceiveProps: Please update the following components ' +\n- 'to use static getDerivedStateFromProps instead: NotCascading',\n- ],\n- {withoutStack: true},\n- );\n- ReactNoop.render(\n- \n- \n- <\/Parent>,\n- );\n- addComment('Should not print a warning');\n- expect(Scheduler).toFlushWithoutYielding();\n- expect(getFlameChart()).toMatchSnapshot();\n- });\n-\n- it('captures all lifecycles', () => {\n- class AllLifecycles extends React.Component {\n- static childContextTypes = {\n- foo: PropTypes.any,\n- };\n- shouldComponentUpdate() {\n- return true;\n- }\n- getChildContext() {\n- return {foo: 42};\n- }\n- UNSAFE_componentWillMount() {}\n- componentDidMount() {}\n- UNSAFE_componentWillReceiveProps() {}\n- UNSAFE_componentWillUpdate() {}\n- componentDidUpdate() {}\n- componentWillUnmount() {}\n- render() {\n- return
;\n- }\n+ it('warns on cascading renders from top-level render', () => {\n+ class Cascading extends React.Component {\n+ componentDidMount() {\n+ ReactNoop.renderToRootWithID(, 'b');\n+ addComment('Scheduling another root from componentDidMount');\n }\n- ReactNoop.render();\n- addComment('Mount');\n- expect(() => expect(Scheduler).toFlushWithoutYielding()).toWarnDev(\n- [\n- 'componentWillMount: Please update the following components ' +\n- 'to use componentDidMount instead: AllLifecycles' +\n- '\\n\\ncomponentWillReceiveProps: Please update the following components ' +\n- 'to use static getDerivedStateFromProps instead: AllLifecycles' +\n- '\\n\\ncomponentWillUpdate: Please update the following components ' +\n- 'to use componentDidUpdate instead: AllLifecycles',\n- 'Legacy context API has been detected within a strict-mode tree: \\n\\n' +\n- 'Please update the following components: AllLifecycles',\n- ],\n- {withoutStack: true},\n- );\n- ReactNoop.render();\n- addComment('Update');\n- expect(Scheduler).toFlushWithoutYielding();\n- ReactNoop.render(null);\n- addComment('Unmount');\n- expect(Scheduler).toFlushWithoutYielding();\n- expect(getFlameChart()).toMatchSnapshot();\n- });\n+ render() {\n+ return
{this.props.children}<\/div>;\n+ }\n+ }\n \n- it('measures deprioritized work', () => {\n- addComment('Flush the parent');\n- ReactNoop.flushSync(() => {\n- ReactNoop.render(\n- \n-

dillon1000/react

Files changed