行数 https://github.com/a8397550/react-source-share/blob/master/default/react-dom-default.js

  1. function scheduleUpdateOnFiber(fiber, expirationTime) {
  2.   // ... 省略
  3.   // true
  4.   if (expirationTime === Sync) {
  5.     if (
  6.       // 常量 NoContext = 0
  7.       // 初始化时 executionContext = 8 LegacyUnbatchedContext = 8
  8.       // 8 & 8 = 8 下条语句初始化时结果为true
  9.       (executionContext & LegacyUnbatchedContext) !== NoContext &&
  10.       // 初始化 (8 & (16 | 32)) === NoContext 结果为true
  11.       (executionContext & (RenderContext | CommitContext)) === NoContext) {
  12.       // expirationTime === 1073741823
  13.       // 初始化时，啥也没干
  14.       schedulePendingInteractions(root, expirationTime);
  16.       var callback = renderRoot(root, Sync, true);
  17.       while (callback !== null) {
  18.         callback = callback(true);
  19.       }
  20.     } else {
  21.       scheduleCallbackForRoot(root, ImmediatePriority, Sync);
  22.       if (executionContext === NoContext) {
  24.         flushSyncCallbackQueue();
  25.       }
  26.     }
  27.   } else {
  28.     scheduleCallbackForRoot(root, priorityLevel, expirationTime);
  29.   }
  31.   if ((executionContext & DiscreteEventContext) !== NoContext && (
  32.     // Only updates at user-blocking priority or greater are considered
  33.     // discrete, even inside a discrete event.
  34.     priorityLevel === UserBlockingPriority$2 || priorityLevel === ImmediatePriority)) {
  35.     // This is the result of a discrete event. Track the lowest priority
  36.     // discrete update per root so we can flush them early, if needed.
  37.     if (rootsWithPendingDiscreteUpdates === null) {
  38.       rootsWithPendingDiscreteUpdates = new Map([[root, expirationTime]]);
  39.     } else {
  40.       var lastDiscreteTime = rootsWithPendingDiscreteUpdates.get(root);
  41.       if (lastDiscreteTime === undefined || lastDiscreteTime > expirationTime) {
  42.         rootsWithPendingDiscreteUpdates.set(root, expirationTime);
  43.       }
  44.     }
  45.   }
  46. }

renderRoot 主要方法

  1. function renderRoot(root, expirationTime, isSync) {
  2.   (function () {
  3.     // (8 & (16 | 32)) === NoContext 结果为true 取反 false
  4.     if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
  5.       {
  6.         throw ReactError(Error('Should not already be working.'));
  7.       }
  8.     }
  9.   })();
  11.   // 初始化时 true && 1073741823 !== 1073741823 结果 false
  12.   if (enableUserTimingAPI && expirationTime !== Sync) {
  13.     var didExpire = isSync;
  14.     stopRequestCallbackTimer(didExpire);
  15.   }
  16.     // 初始化时 1073741823 < 1073741823 结果 false
  17.   if (root.firstPendingTime < expirationTime) {
  18.     return null;
  19.   }
  20.     // isSync = true
  21.   // root.finishedExpirationTime = 0
  22.   // expirationTime = 0
  23.   // 初始化时 结果为false
  24.   if (isSync && root.finishedExpirationTime === expirationTime) {
  25.     return commitRoot.bind(null, root);
  26.   }
  27.     // 初始化时，默认return了false，啥也没干
  28.   flushPassiveEffects();
  30.   // root = FiberRootNode
  31.   // workInProgressRoot = null
  32.   // expirationTime = 1073741823
  33.   // renderExpirationTime = 0
  34.   if (root !== workInProgressRoot || expirationTime !== renderExpirationTime) {
  35.     // prepare 准备 [prɪˈpeə(r)]
  36.     // Fresh 新的 [freʃ]
  37.     // stack 堆栈 [stæk]
  38.     prepareFreshStack(root, expirationTime);
  39.     startWorkOnPendingInteractions(root, expirationTime);
  40.   } else if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
  41.     if (workInProgressRootHasPendingPing) {
  42.       prepareFreshStack(root, expirationTime);
  43.     } else {
  44.       var lastPendingTime = root.lastPendingTime;
  45.       if (lastPendingTime < expirationTime) {
  46.         return renderRoot.bind(null, root, lastPendingTime);
  47.       }
  48.     }
  49.   }
  50.     // workInProgress = FiberNode
  51.   if (workInProgress !== null) {
  52.     // executionContext = 8
  53.     var prevExecutionContext = executionContext;
  54.     // 8 | 16 = 24
  55.     executionContext |= RenderContext;
  56.     // ReactCurrentDispatcher.current = null
  57.     var prevDispatcher = ReactCurrentDispatcher.current;
  58.     if (prevDispatcher === null) {
  59.       /*
  60.           var ContextOnlyDispatcher = {
  61.           readContext: readContext,
  62.           useCallback: throwInvalidHookError,
  63.           useContext: throwInvalidHookError,
  64.           useEffect: throwInvalidHookError,
  65.           useImperativeHandle: throwInvalidHookError,
  66.           useLayoutEffect: throwInvalidHookError,
  67.           useMemo: throwInvalidHookError,
  68.           useReducer: throwInvalidHookError,
  69.           useRef: throwInvalidHookError,
  70.           useState: throwInvalidHookError,
  71.           useDebugValue: throwInvalidHookError,
  72.           useResponder: throwInvalidHookError
  73.         };
  74.       */
  75.       prevDispatcher = ContextOnlyDispatcher;
  76.     }
  77.     // ReactCurrentDispatcher.current = null 全局变量
  78.     ReactCurrentDispatcher.current = ContextOnlyDispatcher;
  79.     var prevInteractions = null;
  80.     // enableSchedulerTracing = true
  81.     if (enableSchedulerTracing) {
  82.       // __interactionsRef.current = Set(0)
  83.       prevInteractions = __interactionsRef.current;
  84.       // root.memoizedInteractions = Set(0)
  85.       __interactionsRef.current = root.memoizedInteractions;
  86.     }
  88.     startWorkLoopTimer(workInProgress);
  89.         // 方法形参 isSync = true
  90.     if (isSync) {
  91.       // expirationTime = 1073741823 !== Sync = 1073741823 结果为false
  92.       if (expirationTime !== Sync) {
  94.         var currentTime = requestCurrentTime();
  95.         if (currentTime < expirationTime) {
  97.           executionContext = prevExecutionContext;
  98.           resetContextDependencies();
  99.           ReactCurrentDispatcher.current = prevDispatcher;
  100.           if (enableSchedulerTracing) {
  101.             __interactionsRef.current = prevInteractions;
  102.           }
  103.           return renderRoot.bind(null, root, currentTime);
  104.         }
  105.       }
  106.     } else {
  108.       currentEventTime = NoWork;
  109.     }
  111.     do {
  112.       try {
  113.         // isSync = true
  114.         if (isSync) {
  115.           workLoopSync();
  116.         } else {
  117.           workLoop();
  118.         }
  119.         break;
  120.       } catch (thrownValue) {
  121.         resetContextDependencies();
  122.         resetHooks();
  124.         var sourceFiber = workInProgress;
  125.         if (sourceFiber === null || sourceFiber.return === null) {
  127.           prepareFreshStack(root, expirationTime);
  128.           executionContext = prevExecutionContext;
  129.           throw thrownValue;
  130.         }
  132.         if (enableProfilerTimer && sourceFiber.mode & ProfileMode) {
  134.           stopProfilerTimerIfRunningAndRecordDelta(sourceFiber, true);
  135.         }
  137.         var returnFiber = sourceFiber.return;
  138.         throwException(root, returnFiber, sourceFiber, thrownValue, renderExpirationTime);
  139.         workInProgress = completeUnitOfWork(sourceFiber);
  140.       }
  141.     } while (true);
  143.     executionContext = prevExecutionContext;
  144.     resetContextDependencies();
  145.     ReactCurrentDispatcher.current = prevDispatcher;
  146.     if (enableSchedulerTracing) {
  147.       __interactionsRef.current = prevInteractions;
  148.     }
  150.     if (workInProgress !== null) {
  151.       // There's still work left over. Return a continuation.
  152.       stopInterruptedWorkLoopTimer();
  153.       if (expirationTime !== Sync) {
  154.         startRequestCallbackTimer();
  155.       }
  156.       return renderRoot.bind(null, root, expirationTime);
  157.     }
  158.   }
  160.   stopFinishedWorkLoopTimer();
  162.   root.finishedWork = root.current.alternate;
  163.   root.finishedExpirationTime = expirationTime;
  165.   var isLocked = resolveLocksOnRoot(root, expirationTime);
  166.   if (isLocked) {
  168.     return null;
  169.   }
  171.   workInProgressRoot = null;
  173.   switch (workInProgressRootExitStatus) {
  174.     case RootIncomplete:
  175.       {
  176.         (function () {
  177.           {
  178.             {
  179.               throw ReactError(Error('Should have a work-in-progress.'));
  180.             }
  181.           }
  182.         })();
  183.       }
  185.     case RootErrored:
  186.       {
  187.         var _lastPendingTime = root.lastPendingTime;
  188.         if (_lastPendingTime < expirationTime) {
  190.           return renderRoot.bind(null, root, _lastPendingTime);
  191.         }
  192.         if (!isSync) {
  194.           prepareFreshStack(root, expirationTime);
  195.           scheduleSyncCallback(renderRoot.bind(null, root, expirationTime));
  196.           return null;
  197.         }
  199.         return commitRoot.bind(null, root);
  200.       }
  201.     case RootSuspended:
  202.       {
  203.         flushSuspensePriorityWarningInDEV();
  205.         var hasNotProcessedNewUpdates = workInProgressRootLatestProcessedExpirationTime === Sync;
  206.         if (hasNotProcessedNewUpdates && !isSync &&
  208.         !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current)) {
  210.           var msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now();
  212.           if (msUntilTimeout > 10) {
  213.             if (workInProgressRootHasPendingPing) {
  215.               prepareFreshStack(root, expirationTime);
  216.               return renderRoot.bind(null, root, expirationTime);
  217.             }
  218.             var _lastPendingTime2 = root.lastPendingTime;
  219.             if (_lastPendingTime2 < expirationTime) {
  221.               return renderRoot.bind(null, root, _lastPendingTime2);
  222.             }
  224.             root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), msUntilTimeout);
  225.             return null;
  226.           }
  227.         }
  229.         return commitRoot.bind(null, root);
  230.       }
  231.     case RootSuspendedWithDelay:
  232.       {
  233.         flushSuspensePriorityWarningInDEV();
  235.         if (!isSync &&
  237.         !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current)) {
  239.           if (workInProgressRootHasPendingPing) {
  241.             prepareFreshStack(root, expirationTime);
  242.             return renderRoot.bind(null, root, expirationTime);
  243.           }
  244.           var _lastPendingTime3 = root.lastPendingTime;
  245.           if (_lastPendingTime3 < expirationTime) {
  247.             return renderRoot.bind(null, root, _lastPendingTime3);
  248.           }
  250.           var _msUntilTimeout = void 0;
  251.           if (workInProgressRootLatestSuspenseTimeout !== Sync) {
  253.             _msUntilTimeout = expirationTimeToMs(workInProgressRootLatestSuspenseTimeout) - now();
  254.           } else if (workInProgressRootLatestProcessedExpirationTime === Sync) {
  256.             _msUntilTimeout = 0;
  257.           } else {
  259.             var eventTimeMs = inferTimeFromExpirationTime(workInProgressRootLatestProcessedExpirationTime);
  260.             var currentTimeMs = now();
  261.             var timeUntilExpirationMs = expirationTimeToMs(expirationTime) - currentTimeMs;
  262.             var timeElapsed = currentTimeMs - eventTimeMs;
  263.             if (timeElapsed < 0) {
  265.               timeElapsed = 0;
  266.             }
  268.             _msUntilTimeout = jnd(timeElapsed) - timeElapsed;
  271.             if (timeUntilExpirationMs < _msUntilTimeout) {
  272.               _msUntilTimeout = timeUntilExpirationMs;
  273.             }
  274.           }
  277.           if (_msUntilTimeout > 10) {
  279.             root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), _msUntilTimeout);
  280.             return null;
  281.           }
  282.         }
  284.         return commitRoot.bind(null, root);
  285.       }
  286.     case RootCompleted:
  287.       {
  289.         if (!isSync &&
  291.         !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current) && workInProgressRootLatestProcessedExpirationTime !== Sync && workInProgressRootCanSuspendUsingConfig !== null) {
  293.           var _msUntilTimeout2 = computeMsUntilSuspenseLoadingDelay(workInProgressRootLatestProcessedExpirationTime, expirationTime, workInProgressRootCanSuspendUsingConfig);
  294.           if (_msUntilTimeout2 > 10) {
  295.             root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), _msUntilTimeout2);
  296.             return null;
  297.           }
  298.         }
  299.         return commitRoot.bind(null, root);
  300.       }
  301.     default:
  302.       {
  303.         (function () {
  304.           {
  305.             {
  306.               throw ReactError(Error('Unknown root exit status.'));
  307.             }
  308.           }
  309.         })();
  310.       }
  311.   }
  312. }

flushPassiveEffects

  1. function flushPassiveEffects() {
  2.   // 变量rootWithPendingPassiveEffects 默认等于null
  3.   if (rootWithPendingPassiveEffects === null) {
  4.     return false;
  5.   }
  6.   var root = rootWithPendingPassiveEffects;
  7.   var expirationTime = pendingPassiveEffectsExpirationTime;
  8.   var renderPriorityLevel = pendingPassiveEffectsRenderPriority;
  9.   rootWithPendingPassiveEffects = null;
  10.   pendingPassiveEffectsExpirationTime = NoWork;
  11.   pendingPassiveEffectsRenderPriority = NoPriority;
  12.   var priorityLevel = renderPriorityLevel > NormalPriority ? NormalPriority : renderPriorityLevel;
  13.   return runWithPriority$2(priorityLevel, flushPassiveEffectsImpl.bind(null, root, expirationTime));
  14. }

prepareFreshStack

  1. function prepareFreshStack(root, expirationTime) {
  2.   // 初始化时 root.finishedWork = null,root.finishedExpirationTime = 0
  3.   // NoWork = 0
  4.   root.finishedWork = null;
  5.   root.finishedExpirationTime = NoWork;
  6.     // root.timeoutHandle 初始化时 = -1
  7.   var timeoutHandle = root.timeoutHandle;
  8.   // 常量 noTimeout = -1
  9.   if (timeoutHandle !== noTimeout) {
  10.     root.timeoutHandle = noTimeout;
  11.     cancelTimeout(timeoutHandle);
  12.   }
  13.     // 初始化时 变量 workInProgress = null
  14.   if (workInProgress !== null) {
  15.     var interruptedWork = workInProgress.return;
  16.     while (interruptedWork !== null) {
  17.       unwindInterruptedWork(interruptedWork);
  18.       interruptedWork = interruptedWork.return;
  19.     }
  20.   }
  21.   // 初始化时 workInProgressRoot = null
  22.   // Progress 进程 [ˈprəʊɡres]
  23.   workInProgressRoot = root;
  24.   workInProgress = createWorkInProgress(root.current, null, expirationTime);
  25.   // expirationTime = 1073741823
  26.   renderExpirationTime = expirationTime;
  27.   // RootIncomplete = 0
  28.   workInProgressRootExitStatus = RootIncomplete;
  29.   // Sync = 1073741823
  30.   workInProgressRootLatestProcessedExpirationTime = Sync;
  31.   workInProgressRootLatestSuspenseTimeout = Sync;
  32.   workInProgressRootCanSuspendUsingConfig = null;
  33.   workInProgressRootHasPendingPing = false;
  34.     // enableSchedulerTracing = true
  35.   if (enableSchedulerTracing) {
  36.     spawnedWorkDuringRender = null;
  37.   }
  39.   {
  40.     /* 
  41.       ReactStrictModeWarnings = {
  42.         discardPendingWarnings: ƒ ()
  43.         flushLegacyContextWarning: ƒ ()
  44.         flushPendingUnsafeLifecycleWarnings: ƒ ()
  45.         recordLegacyContextWarning: ƒ (fiber, instance)
  46.         recordUnsafeLifecycleWarnings: ƒ (fiber, instance)
  47.         __proto__: Object
  48.       }
  49.       11858行
  50.       ReactStrictModeWarnings.discardPendingWarnings = function () {
  51.         pendingComponentWillMountWarnings = [];
  52.         pendingUNSAFE_ComponentWillMountWarnings = [];
  53.         pendingComponentWillReceivePropsWarnings = [];
  54.         pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
  55.         pendingComponentWillUpdateWarnings = [];
  56.         pendingUNSAFE_ComponentWillUpdateWarnings = [];
  57.         pendingLegacyContextWarning = new Map();
  58.       };
  59.     */
  60.     ReactStrictModeWarnings.discardPendingWarnings();
  61.     componentsThatTriggeredHighPriSuspend = null;
  62.   }
  63. }

行数 23910 createWorkInProgress [prəˈɡres]

  1. function createWorkInProgress(current, pendingProps, expirationTime) {
  2.   // current.alternate 默认为null
  3.   var workInProgress = current.alternate;
  4.   if (workInProgress === null) {
  5.     // current.tag = 3
  6.     // pendingProps = null
  7.     // current.key = null
  8.     // current.mode = 0
  9.     workInProgress = createFiber(current.tag, pendingProps,
  10.                                  current.key, current.mode);
  11.     // current.elementType = null
  12.     workInProgress.elementType = current.elementType;
  13.     // current.type = null
  14.     workInProgress.type = current.type;
  15.     // current.stateNode = FiberRootNode
  16.     workInProgress.stateNode = current.stateNode;
  18.     {
  19.       // DEV-only fields
  20.       // current._debugID = 1;
  21.       workInProgress._debugID = current._debugID;
  22.       // current._debugSource = null;
  23.       workInProgress._debugSource = current._debugSource;
  24.       // current._debugOwner = null;
  25.       workInProgress._debugOwner = current._debugOwner;
  26.       // current._debugHookTypes = null;
  27.       workInProgress._debugHookTypes = current._debugHookTypes;
  28.     }
  30.     workInProgress.alternate = current;
  31.     current.alternate = workInProgress;
  32.   } else {
  33.     workInProgress.pendingProps = pendingProps;
  34.     workInProgress.effectTag = NoEffect;
  35.     workInProgress.nextEffect = null;
  36.     workInProgress.firstEffect = null;
  37.     workInProgress.lastEffect = null;
  39.     if (enableProfilerTimer) {
  41.       workInProgress.actualDuration = 0;
  42.       workInProgress.actualStartTime = -1;
  43.     }
  44.   }
  45.     // current.childExpirationTime = 0
  46.   workInProgress.childExpirationTime = current.childExpirationTime;
  47.   // current.expirationTime = 1073741823
  48.   workInProgress.expirationTime = current.expirationTime;
  49.     // current.child = null
  50.   workInProgress.child = current.child;
  51.   // current.memoizedProps = null;
  52.   workInProgress.memoizedProps = current.memoizedProps;
  53.   // current.memoizedState = null;
  54.   workInProgress.memoizedState = current.memoizedState;
  56.   // 重要 current.updateQueue = {firstUpdate, lastUpdate, ...}
  57.   /*
  58.     firstUpdate = {
  59.       payload: {
  60.         element: {$$typeof: Symbol(react.element), ...}
  61.       , ...}
  62.     , ...}
  63.     lastUpdate的结构与firstUpdate一致
  64.   */
  65.   workInProgress.updateQueue = current.updateQueue;
  66.     // current.dependencies = null 
  67.   var currentDependencies = current.dependencies;
  68.   workInProgress.dependencies = currentDependencies === null ? null : {
  69.     expirationTime: currentDependencies.expirationTime,
  70.     firstContext: currentDependencies.firstContext,
  71.     responders: currentDependencies.responders
  72.   };
  73.     // current.sibling = null;
  74.   workInProgress.sibling = current.sibling;
  75.   // current.index = 0;
  76.   workInProgress.index = current.index;
  77.   // current.ref = null;
  78.   workInProgress.ref = current.ref;
  79.     // 常量 enableProfilerTimer = true
  80.   if (enableProfilerTimer) {
  81.     // current.selfBaseDuration = 0;
  82.     workInProgress.selfBaseDuration = current.selfBaseDuration;
  83.     // current.treeBaseDuration = 0;
  84.     workInProgress.treeBaseDuration = current.treeBaseDuration;
  85.   }
  87.   {
  88.     // current._debugNeedsRemount = false;
  89.     workInProgress._debugNeedsRemount = current._debugNeedsRemount;
  90.     switch (workInProgress.tag) {
  91.       case IndeterminateComponent: // 2
  92.       case FunctionComponent: // 0
  93.       case SimpleMemoComponent: // 15
  94.         workInProgress.type = resolveFunctionForHotReloading(current.type);
  95.         break;
  96.       case ClassComponent: // 1
  97.         workInProgress.type = resolveClassForHotReloading(current.type);
  98.         break;
  99.       case ForwardRef: // 11
  100.         workInProgress.type = resolveForwardRefForHotReloading(current.type);
  101.         break;
  102.       default:
  103.         break;
  104.     }
  105.   }
  107.   return workInProgress;
  108. }

startWorkOnPendingInteractions

  1. function startWorkOnPendingInteractions(root, expirationTime) {
  2.   // enableSchedulerTracing = true
  3.   if (!enableSchedulerTracing) {
  4.     return;
  5.   }
  7.   var interactions = new Set();
  8.   // root.pendingInteractionMap.size = 0
  9.   root.pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
  10.     if (scheduledExpirationTime >= expirationTime) {
  11.       scheduledInteractions.forEach(function (interaction) {
  12.         return interactions.add(interaction);
  13.       });
  14.     }
  15.   });
  17.   root.memoizedInteractions = interactions;
  19.   if (interactions.size > 0) {
  20.     var subscriber = __subscriberRef.current;
  21.     if (subscriber !== null) {
  22.       var threadID = computeThreadID(root, expirationTime);
  23.       try {
  24.         subscriber.onWorkStarted(interactions, threadID);
  25.       } catch (error) {
  26.         // If the subscriber throws, rethrow it in a separate task
  27.         scheduleCallback(ImmediatePriority, function () {
  28.           throw error;
  29.         });
  30.       }
  31.     }
  32.   }
  33. }

startWorkLoopTimer

  1. var formatMarkName = function (markName) {
  2.   // reactEmoji = "⚛"
  3.   return reactEmoji + ' ' + markName;
  4. };
  6. var beginMark = function (markName) {
  7.      // performance 需要注意这个玩意是window.performance 
  8.   // performance 主要用来做性能监控，白屏时间，首屏时间，用户可操作时间节点，总下载时间...
  9.   performance.mark(formatMarkName(markName));
  10. };
  12. var resumeTimers = function () {
  13.   // currentFiber = FiberNode # renderRoot 传入 workInProgress
  14.   if (currentFiber !== null) {
  15.     resumeTimersRecursively(currentFiber);
  16.   }
  17. };
  19. var resumeTimersRecursively = function (fiber) {
  20.   // fiber.return = null
  21.   if (fiber.return !== null) {
  22.     resumeTimersRecursively(fiber.return);
  23.   }
  24.   // fiber._debugIsCurrentlyTiming = false
  25.   if (fiber._debugIsCurrentlyTiming) {
  26.     beginFiberMark(fiber, null);
  27.   }
  28. };
  30. function startWorkLoopTimer(nextUnitOfWork) {
  31.   // enableUserTimingAPI = true
  32.   if (enableUserTimingAPI) {
  33.     // nextUnitOfWork = FiberNode # renderRoot 传入 workInProgress
  34.     currentFiber = nextUnitOfWork;
  35.     // supportsUserTiming = true
  36.     if (!supportsUserTiming) {
  37.       return;
  38.     }
  39.     commitCountInCurrentWorkLoop = 0;
  41.     beginMark('(React Tree Reconciliation)');
  42.     // Resume any measurements that were in progress during the last loop.
  43.     resumeTimers();
  44.   }
  45. }

行数 22320 workLoopSync

  1.  function workLoopSync() {
  2.    // workInProgress = FiberNode
  3.    while (workInProgress !== null) {
  4.      workInProgress = performUnitOfWork(workInProgress);
  5.    }
  6.  }
  8. function performUnitOfWork(unitOfWork) {
  9.   // The current, flushed, state of this fiber is the alternate. Ideally
  10.   // nothing should rely on this, but relying on it here means that we don't
  11.   // need an additional field on the work in progress.
  12.   var current$$1 = unitOfWork.alternate;
  14.   startWorkTimer(unitOfWork);
  15.   setCurrentFiber(unitOfWork);
  17.   var next = void 0;
  18.   if (enableProfilerTimer && (unitOfWork.mode & ProfileMode) !== NoMode) {
  19.     startProfilerTimer(unitOfWork);
  20.     next = beginWork$$1(current$$1, unitOfWork, renderExpirationTime);
  21.     stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
  22.   } else {
  23.     next = beginWork$$1(current$$1, unitOfWork, renderExpirationTime);
  24.   }
  26.   resetCurrentFiber();
  27.   unitOfWork.memoizedProps = unitOfWork.pendingProps;
  28.   if (next === null) {
  29.     // If this doesn't spawn new work, complete the current work.
  30.     next = completeUnitOfWork(unitOfWork);
  31.   }
  33.   ReactCurrentOwner$2.current = null;
  34.   return next;
  35. }