Commit 40c1118

"use strict";

exports.useTransition = function () {

return ReactCurrentDispatcher.current.useTransition();

exports.useTransition = function () {

return ReactCurrentDispatcher.current.useTransition();

exports.useTransition = function () {

return ReactCurrentDispatcher.current.useTransition();

/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */

if (

return self;

}

var LegacyRoot = 0;

var ConcurrentRoot = 1;

var SyncLane =

/* */

2;

var InputContinuousHydrationLane =

/* */

4;

}

}

if ((root.current.mode & ConcurrentUpdatesByDefaultMode) !== NoMode);

// When updates are sync by default, we entangle continuous priority updates

// and default updates, so they render in the same batch. The only reason

// they use separate lanes is because continuous updates should interrupt

// transitions, but default updates should not.

} // Check for entangled lanes and add them to the batch.

//

// A lane is said to be entangled with another when it's not allowed to render

// we should ensure that there is no partial work at the

// time we apply the entanglement.

var entanglements = root.entanglements;

while (lanes > 0) {

var index = pickArbitraryLaneIndex(lanes);

var lane = 1 << index;

lanes &= ~lane;

}

}

}

function computeExpirationTime(lane, currentTime) {

var expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their

// expiration time. If so, we'll assume the update is being starved and mark

// it as expired to force it to finish.

//

// We exclude retry lanes because those must always be time sliced, in order

// to unwrap uncached promises.

lanes &= ~lane;

}

}

function markHiddenUpdate(root, update, lane) {

var index = laneToIndex(lane);

var hiddenUpdates = root.hiddenUpdates;

// InvisibleParentContext that is currently managed by SuspenseContext.

var currentTreeHiddenStackCursor = createCursor(null);

function pushHiddenContext(fiber, context) {

push(currentTreeHiddenStackCursor, context, fiber); // When rendering a subtree that's currently hidden, we must include all

// lanes that would have rendered if the hidden subtree hadn't been deferred.

// That is, in order to reveal content from hidden -> visible, we must commit

// all the updates that we skipped when we originally hid the tree.

}

function reuseHiddenContextOnStack(fiber) {

// This subtree is not currently hidden, so we don't need to add any lanes

// to the render lanes. But we still need to push something to avoid a

// context mismatch. Reuse the existing context on the stack.

push(

currentTreeHiddenStackCursor,

currentTreeHiddenStackCursor.current,

}

function popHiddenContext(fiber) {

// Restore the previous render lanes from the stack

pop(currentTreeHiddenStackCursor, fiber);

}

function isCurrentTreeHidden() {

return currentTreeHiddenStackCursor.current !== null;

currentEventTransitionLane !== NoLane &&

shouldAttemptEagerTransition()

) {

}

var nextLanes = scheduleTaskForRootDuringMicrotask(root, currentTime);

// optimizations later.

// These are set right before calling the component.

// the work-in-progress hook.

var currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The

secondArg,

nextRenderLanes

) {

currentlyRenderingFiber$1 = workInProgress;

{

// hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.

var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;

currentlyRenderingFiber$1 = null;

currentHook = null;

workInProgressHook = null;

didScheduleRenderPhaseUpdate = false;

}

currentlyRenderingFiber$1 = null;

currentHook = null;

workInProgressHook = null;

var shouldSkipUpdate = isHiddenUpdate

? !isSubsetOfLanes(getWorkInProgressRootRenderLanes(), updateLane)

if (shouldSkipUpdate) {

// Priority is insufficient. Skip this update. If this is the first

// sufficient, don't apply the update. Otherwise, apply the update,

// but leave it in the queue so it can be either reverted or

// rebased in a subsequent render.

// The transition that this optimistic update is associated with

// has finished. Pretend the update doesn't exist by skipping

// over it.

);

}

pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);

}

} // Read the current snapshot from the store on every render. This breaks the

);

}

pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);

}

}

function updateDeferredValueImpl(hook, prevValue, value, initialValue) {

// TODO: We should also check if this component is going from

// hidden -> visible. If so, it should use the initialValue arg.

if (shouldDeferValue) {

// This is an urgent update. If the value has changed, keep using the

// HiddenContext module.

//

// Most things in the work loop should deal with workInProgressRootRenderLanes.

var workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown

// place that ever modifies it. Which module it lives in doesn't matter for

// performance because this function will get inlined regardless

}

}

function resetWorkInProgressStack() {

workInProgressRoot = root;

var rootWorkInProgress = createWorkInProgress(root.current, null);

workInProgress = rootWorkInProgress;

workInProgressSuspendedReason = NotSuspended;

workInProgressThrownValue = null;

workInProgressRootDidAttachPingListener = false;

workInProgressRootInterleavedUpdatedLanes = NoLanes;

workInProgressRootPingedLanes = NoLanes;

workInProgressRootConcurrentErrors = null;

finishQueueingConcurrentUpdates();

{

if ((unitOfWork.mode & ProfileMode) !== NoMode) {

startProfilerTimer(unitOfWork);

stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);

} else {

}

resetCurrentFiber();

unwindInterruptedWork(current, unitOfWork);

unitOfWork = workInProgress = resetWorkInProgress(

unitOfWork,

);

break;

}

}

var next = void 0;

if ((completedWork.mode & ProfileMode) === NoMode) {

} else {

startProfilerTimer(completedWork);

stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);

}