tomtheisen · July 21, 2023 04:47
diff --git a/day01.md b/day01.md
diff --git a/day02.md b/day02.md
diff --git a/day03.md b/day03.md
diff --git a/day04-00.md b/day04-00.md
diff --git a/day04-01-updateReducerImpl.flow b/day04-01-updateReducerImpl.flow
 function updateReducerImpl<S, A>(
  hook: Hook,
  current: Hook,
  reducer: (S, A) => S,
 ): [S, Dispatch<A>] {
  const queue = hook.queue;

  queue.lastRenderedReducer = reducer;

  // The last rebase update that is NOT part of the base state.
  let baseQueue = hook.baseQueue;

  // The last pending update that hasn't been processed yet.
  const pendingQueue = queue.pending;
  if (pendingQueue !== null) {
    // We have new updates that haven't been processed yet.
    // We'll add them to the base queue.
    if (baseQueue !== null) {
      // Merge the pending queue and the base queue.
      const baseFirst = baseQueue.next;
      const pendingFirst = pendingQueue.next;
      baseQueue.next = pendingFirst;
      pendingQueue.next = baseFirst;
    }
    current.baseQueue = baseQueue = pendingQueue;
    queue.pending = null;
  }

  if (baseQueue !== null) {
    // We have a queue to process.
    const first = baseQueue.next;
    let newState = hook.baseState;

    let newBaseState = null;
    let newBaseQueueFirst = null;
    let newBaseQueueLast: Update<S, A> | null = null;
    let update = first;
    do {
      // An extra OffscreenLane bit is added to updates that were made to
      // a hidden tree, so that we can distinguish them from updates that were
      // already there when the tree was hidden.
      const updateLane = removeLanes(update.lane, OffscreenLane);
      const isHiddenUpdate = updateLane !== update.lane;

      // Check if this is an optimistic update.
      const revertLane = update.revertLane;
      if (!enableAsyncActions || revertLane === NoLane) {
        // This is not an optimistic update, and we're going to apply it now.
        // But, if there were earlier updates that were skipped, we need to
        // leave this update in the queue so it can be rebased later.
        if (newBaseQueueLast !== null) {
          const clone: Update<S, A> = {
            // This update is going to be committed so we never want uncommit
            // it. Using NoLane works because 0 is a subset of all bitmasks, so
            // this will never be skipped by the check above.
            lane: NoLane,
            revertLane: NoLane,
            action: update.action,
            hasEagerState: update.hasEagerState,
            eagerState: update.eagerState,
            next: (null: any),
          };
          newBaseQueueLast = newBaseQueueLast.next = clone;
        }
      } else {
        // This is an optimistic update. 
        throw 'TJT removed this code';
      }

      // Process this update.
      const action = update.action;

      if (update.hasEagerState) {
        // If this update is a state update (not a reducer) and was processed eagerly,
        // we can use the eagerly computed state
        newState = ((update.eagerState: any): S);
      } else {
        newState = reducer(newState, action);
      }

      update = update.next;
    } while (update !== null && update !== first);

    if (newBaseQueueLast === null) {
      newBaseState = newState;
    } else {
      newBaseQueueLast.next = (newBaseQueueFirst: any);
    }

    // Mark that the fiber performed work, but only if the new state is
    // different from the current state.
    if (!Object.is(newState, hook.memoizedState)) {
      markWorkInProgressReceivedUpdate();
    }

    hook.memoizedState = newState;
    hook.baseState = newBaseState;
    hook.baseQueue = newBaseQueueLast;

    queue.lastRenderedState = newState;
  }

  if (baseQueue === null) {
    // `queue.lanes` is used for entangling transitions. We can set it back to
    // zero once the queue is empty.
    queue.lanes = NoLanes;
  }

  const dispatch: Dispatch<A> = (queue.dispatch: any);
  return [hook.memoizedState, dispatch];
 }
diff --git a/day04-02.md b/day04-02.md
diff --git a/day05.md b/day05.md
diff --git a/day06.md b/day06.md
diff --git a/day07.md b/day07.md
diff --git a/day08.md b/day08.md
diff --git a/day09.md b/day09.md
diff --git a/day10.md b/day10.md
diff --git a/day11-00.md b/day11-00.md
diff --git a/day11-01-call-graph.js b/day11-01-call-graph.js
 export function renderTransitionAwareHostComponentWithHooks() {
  renderWithHooks();
 }
 export function renderWithHooks() {
  function renderWithHooksAgain() {}
  finishRenderingHooks();
 }
 export function replaySuspendedComponentWithHooks() {
  function renderWithHooksAgain() {}
  finishRenderingHooks();
 }
 function finishRenderingHooks() {
  checkIfWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
  checkIfContextChanged(); // from './ReactFiberNewContext'
  markWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
 }
 export function TransitionAwareHostComponent() {
  useThenable();
 }
 export function checkDidRenderIdHook() {}
 export function bailoutHooks() {}
 export function resetHooksAfterThrow() {}
 export function resetHooksOnUnwind() {}
 function mountOptimistic() {
  function mountWorkInProgressHook() {}
 }
 function updateOptimistic() {
  function updateWorkInProgressHook() {}
  function updateReducerImpl() {
    removeLanes(); // from './ReactFiberLane'
    isSubsetOfLanes(); // from './ReactFiberLane'
    mergeLanes(); // from './ReactFiberLane'
    markSkippedUpdateLanes(); // from './ReactFiberLane'
    markWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
  }
 }
 function rerenderOptimistic() {
  updateOptimistic();
  function updateWorkInProgressHook() {}
 }
 function createEffectInstance() {}
 function mountRef() {
  function mountWorkInProgressHook() {}
 }
 function updateRef() {
  function updateWorkInProgressHook() {}
 }
 function mountEffect() {
  mountEffectImpl();
 }
 function mountEffectImpl() {
  function mountWorkInProgressHook() {}
  function pushEffect() {}
 }
 function updateEffect() {
  updateEffectImpl();
 }
 function mountEvent() {
  function mountWorkInProgressHook() {}
 }
 function updateEvent() {
  function updateWorkInProgressHook() {}
  function useEffectEventImpl() {
    function createFunctionComponentUpdateQueue() {}
  }
 }
 function mountInsertionEffect() {}
 function updateInsertionEffect() {
  updateEffectImpl();
 }
 function mountLayoutEffect() {
  mountEffectImpl();
 }
 function updateLayoutEffect() {
  updateEffectImpl();
 }
 function imperativeHandleEffect() {}
 function mountImperativeHandle() {
  mountEffectImpl();
 }
 function updateImperativeHandle() {
  updateEffectImpl();
 }
 function updateEffectImpl() {
  function updateWorkInProgressHook() {}
  function areHookInputsEqual() {}
  function pushEffect() {}
 }
 function mountDebugValue() {}
 function mountCallback() {
  function mountWorkInProgressHook() {}
 }
 function updateCallback() {
  function updateWorkInProgressHook() {}
  function areHookInputsEqual() {}
 }
 function mountMemo() {
  function mountWorkInProgressHook() {}
 }
 function updateMemo() {
  function updateWorkInProgressHook() {}
  function areHookInputsEqual() {}
 }
 function mountDeferredValue() {
  function mountWorkInProgressHook() {}
 }
 function updateDeferredValue() {
  function updateWorkInProgressHook() {}
  updateDeferredValueImpl();
 }
 function rerenderDeferredValue() {
  function updateWorkInProgressHook() {}
  updateDeferredValueImpl();
 }
 function updateDeferredValueImpl() {
  includesOnlyNonUrgentLanes(); // from './ReactFiberLane'
  claimNextTransitionLane(); // from './ReactFiberLane'
  mergeLanes(); // from './ReactFiberLane'
  markSkippedUpdateLanes(); // from './ReactFiberWorkLoop'
  markWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
 }
 export function startHostTransition() {
  function startTransition() {
    getCurrentUpdatePriority(); // from './ReactEventPriorities'
    higherEventPriority();  // from './ReactEventPriorities'
    setCurrentUpdatePriority(); // from './ReactEventPriorities'
    dispatchOptimisticSetState();
    dispatchSetState();
    now(); // from './Scheduler';
    requestAsyncActionContext(); // from './ReactFiberAsyncAction'
    dispatchSetState();
    setCurrentUpdatePriority(); // from './ReactEventPriorities'
  }
 }
 function mountTransition() {
  function mountStateImpl() {
    function mountWorkInProgressHook() {}
  }  
 }
 function updateTransition() {
  function updateState() {
    function updateReducer() {
      function updateWorkInProgressHook() {}
    }
  }
  function updateWorkInProgressHook() {}
  useThenable();
 }
 function rerenderTransition() {
  function rerenderState() {
    function rerenderReducer() {
      function updateWorkInProgressHook() {}
      markWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
    }
  }
  function updateWorkInProgressHook() {}
  useThenable();
 }
 function useThenable() {
  createThenableState(); // from './ReactFiberThenable'
  trackUsedThenable(); // from './ReactFiberThenable'
 }
 function useHostTransitionStatus() {
  readContext(); // from './ReactFiberNewContext'
 }
 function mountId() {
  function mountWorkInProgressHook() {}
  getWorkInProgressRoot(); // from './ReactFiberWorkLoop'
  getIsHydrating() // from './ReactFiberHydrationContext'
  getTreeId(); // from './ReactFiberTreeContext'
 }
 function updateId() {
  function updateWorkInProgressHook() {}
 }
 function mountRefresh() {
  function mountWorkInProgressHook() {}
 }
 function updateRefresh() {
  function updateWorkInProgressHook() {}
 }

 function dispatchSetState() {
  requestUpdateLane(); // from './ReactFiberWorkLoop'
  function isRenderPhaseUpdate() {}
  function enqueueRenderPhaseUpdate() {}
  enqueueConcurrentHookUpdateAndEagerlyBailout(); // from './ReactFiberConcurrentUpdates'
  enqueueConcurrentHookUpdate(); // from './ReactFiberConcurrentUpdates'
  scheduleUpdateOnFiber(); // from './ReactFiberWorkLoop'
  function entangleTransitionUpdate() {
    isTransitionLane(); // from './ReactFiberLane'
    intersectLanes(); // from './ReactFiberLane'
    mergeLanes(); // from './ReactFiberLane'
    markRootEntangled(); // from './ReactFiberLane'
  }
  markUpdateInDevTools();
 }
 function dispatchOptimisticSetState() {
  requestTransitionLane(); // from './ReactFiberRootScheduler'
  function isRenderPhaseUpdate() {}
  enqueueConcurrentHookUpdate(); // from './ReactFiberConcurrentUpdates'
  scheduleUpdateOnFiber(); // from './ReactFiberWorkLoop'
  markUpdateInDevTools();
 }

 function markUpdateInDevTools() {
  markStateUpdateScheduled(); // from './ReactFiberDevToolsHook'
 }
diff --git a/day12-00.md b/day12-00.md
diff --git a/day13-00.md b/day13-00.md
diff --git a/day14-00.md b/day14-00.md
diff --git a/day15-00.md b/day15-00.md
	function updateReducerImpl<S, A>(
	hook: Hook,
	current: Hook,
	reducer: (S, A) => S,
	): [S, Dispatch<A>] {
	const queue = hook.queue;

	queue.lastRenderedReducer = reducer;

	// The last rebase update that is NOT part of the base state.
	let baseQueue = hook.baseQueue;

	// The last pending update that hasn't been processed yet.
	const pendingQueue = queue.pending;
	if (pendingQueue !== null) {
	// We have new updates that haven't been processed yet.
	// We'll add them to the base queue.
	if (baseQueue !== null) {
	// Merge the pending queue and the base queue.
	const baseFirst = baseQueue.next;
	const pendingFirst = pendingQueue.next;
	baseQueue.next = pendingFirst;
	pendingQueue.next = baseFirst;
	}
	current.baseQueue = baseQueue = pendingQueue;
	queue.pending = null;
	}

	if (baseQueue !== null) {
	// We have a queue to process.
	const first = baseQueue.next;
	let newState = hook.baseState;

	let newBaseState = null;
	let newBaseQueueFirst = null;
	let newBaseQueueLast: Update<S, A> \| null = null;
	let update = first;
	do {
	// An extra OffscreenLane bit is added to updates that were made to
	// a hidden tree, so that we can distinguish them from updates that were
	// already there when the tree was hidden.
	const updateLane = removeLanes(update.lane, OffscreenLane);
	const isHiddenUpdate = updateLane !== update.lane;

	// Check if this is an optimistic update.
	const revertLane = update.revertLane;
	if (!enableAsyncActions \|\| revertLane === NoLane) {
	// This is not an optimistic update, and we're going to apply it now.
	// But, if there were earlier updates that were skipped, we need to
	// leave this update in the queue so it can be rebased later.
	if (newBaseQueueLast !== null) {
	const clone: Update<S, A> = {
	// This update is going to be committed so we never want uncommit
	// it. Using NoLane works because 0 is a subset of all bitmasks, so
	// this will never be skipped by the check above.
	lane: NoLane,
	revertLane: NoLane,
	action: update.action,
	hasEagerState: update.hasEagerState,
	eagerState: update.eagerState,
	next: (null: any),
	};
	newBaseQueueLast = newBaseQueueLast.next = clone;
	}
	} else {
	// This is an optimistic update.
	throw 'TJT removed this code';
	}

	// Process this update.
	const action = update.action;

	if (update.hasEagerState) {
	// If this update is a state update (not a reducer) and was processed eagerly,
	// we can use the eagerly computed state
	newState = ((update.eagerState: any): S);
	} else {
	newState = reducer(newState, action);
	}

	update = update.next;
	} while (update !== null && update !== first);

	if (newBaseQueueLast === null) {
	newBaseState = newState;
	} else {
	newBaseQueueLast.next = (newBaseQueueFirst: any);
	}

	// Mark that the fiber performed work, but only if the new state is
	// different from the current state.
	if (!Object.is(newState, hook.memoizedState)) {
	markWorkInProgressReceivedUpdate();
	}

	hook.memoizedState = newState;
	hook.baseState = newBaseState;
	hook.baseQueue = newBaseQueueLast;

	queue.lastRenderedState = newState;
	}

	if (baseQueue === null) {
	// `queue.lanes` is used for entangling transitions. We can set it back to
	// zero once the queue is empty.
	queue.lanes = NoLanes;
	}

	const dispatch: Dispatch<A> = (queue.dispatch: any);
	return [hook.memoizedState, dispatch];
	}
	export function renderTransitionAwareHostComponentWithHooks() {
	renderWithHooks();
	}
	export function renderWithHooks() {
	function renderWithHooksAgain() {}
	finishRenderingHooks();
	}
	export function replaySuspendedComponentWithHooks() {
	function renderWithHooksAgain() {}
	finishRenderingHooks();
	}
	function finishRenderingHooks() {
	checkIfWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
	checkIfContextChanged(); // from './ReactFiberNewContext'
	markWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
	}
	export function TransitionAwareHostComponent() {
	useThenable();
	}
	export function checkDidRenderIdHook() {}
	export function bailoutHooks() {}
	export function resetHooksAfterThrow() {}
	export function resetHooksOnUnwind() {}
	function mountOptimistic() {
	function mountWorkInProgressHook() {}
	}
	function updateOptimistic() {
	function updateWorkInProgressHook() {}
	function updateReducerImpl() {
	removeLanes(); // from './ReactFiberLane'
	isSubsetOfLanes(); // from './ReactFiberLane'
	mergeLanes(); // from './ReactFiberLane'
	markSkippedUpdateLanes(); // from './ReactFiberLane'
	markWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
	}
	}
	function rerenderOptimistic() {
	updateOptimistic();
	function updateWorkInProgressHook() {}
	}
	function createEffectInstance() {}
	function mountRef() {
	function mountWorkInProgressHook() {}
	}
	function updateRef() {
	function updateWorkInProgressHook() {}
	}
	function mountEffect() {
	mountEffectImpl();
	}
	function mountEffectImpl() {
	function mountWorkInProgressHook() {}
	function pushEffect() {}
	}
	function updateEffect() {
	updateEffectImpl();
	}
	function mountEvent() {
	function mountWorkInProgressHook() {}
	}
	function updateEvent() {
	function updateWorkInProgressHook() {}
	function useEffectEventImpl() {
	function createFunctionComponentUpdateQueue() {}
	}
	}
	function mountInsertionEffect() {}
	function updateInsertionEffect() {
	updateEffectImpl();
	}
	function mountLayoutEffect() {
	mountEffectImpl();
	}
	function updateLayoutEffect() {
	updateEffectImpl();
	}
	function imperativeHandleEffect() {}
	function mountImperativeHandle() {
	mountEffectImpl();
	}
	function updateImperativeHandle() {
	updateEffectImpl();
	}
	function updateEffectImpl() {
	function updateWorkInProgressHook() {}
	function areHookInputsEqual() {}
	function pushEffect() {}
	}
	function mountDebugValue() {}
	function mountCallback() {
	function mountWorkInProgressHook() {}
	}
	function updateCallback() {
	function updateWorkInProgressHook() {}
	function areHookInputsEqual() {}
	}
	function mountMemo() {
	function mountWorkInProgressHook() {}
	}
	function updateMemo() {
	function updateWorkInProgressHook() {}
	function areHookInputsEqual() {}
	}
	function mountDeferredValue() {
	function mountWorkInProgressHook() {}
	}
	function updateDeferredValue() {
	function updateWorkInProgressHook() {}
	updateDeferredValueImpl();
	}
	function rerenderDeferredValue() {
	function updateWorkInProgressHook() {}
	updateDeferredValueImpl();
	}
	function updateDeferredValueImpl() {
	includesOnlyNonUrgentLanes(); // from './ReactFiberLane'
	claimNextTransitionLane(); // from './ReactFiberLane'
	mergeLanes(); // from './ReactFiberLane'
	markSkippedUpdateLanes(); // from './ReactFiberWorkLoop'
	markWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
	}
	export function startHostTransition() {
	function startTransition() {
	getCurrentUpdatePriority(); // from './ReactEventPriorities'
	higherEventPriority(); // from './ReactEventPriorities'
	setCurrentUpdatePriority(); // from './ReactEventPriorities'
	dispatchOptimisticSetState();
	dispatchSetState();
	now(); // from './Scheduler';
	requestAsyncActionContext(); // from './ReactFiberAsyncAction'
	dispatchSetState();
	setCurrentUpdatePriority(); // from './ReactEventPriorities'
	}
	}
	function mountTransition() {
	function mountStateImpl() {
	function mountWorkInProgressHook() {}
	}
	}
	function updateTransition() {
	function updateState() {
	function updateReducer() {
	function updateWorkInProgressHook() {}
	}
	}
	function updateWorkInProgressHook() {}
	useThenable();
	}
	function rerenderTransition() {
	function rerenderState() {
	function rerenderReducer() {
	function updateWorkInProgressHook() {}
	markWorkInProgressReceivedUpdate(); // from './ReactFiberBeginWork'
	}
	}
	function updateWorkInProgressHook() {}
	useThenable();
	}
	function useThenable() {
	createThenableState(); // from './ReactFiberThenable'
	trackUsedThenable(); // from './ReactFiberThenable'
	}
	function useHostTransitionStatus() {
	readContext(); // from './ReactFiberNewContext'
	}
	function mountId() {
	function mountWorkInProgressHook() {}
	getWorkInProgressRoot(); // from './ReactFiberWorkLoop'
	getIsHydrating() // from './ReactFiberHydrationContext'
	getTreeId(); // from './ReactFiberTreeContext'
	}
	function updateId() {
	function updateWorkInProgressHook() {}
	}
	function mountRefresh() {
	function mountWorkInProgressHook() {}
	}
	function updateRefresh() {
	function updateWorkInProgressHook() {}
	}

	function dispatchSetState() {
	requestUpdateLane(); // from './ReactFiberWorkLoop'
	function isRenderPhaseUpdate() {}
	function enqueueRenderPhaseUpdate() {}
	enqueueConcurrentHookUpdateAndEagerlyBailout(); // from './ReactFiberConcurrentUpdates'
	enqueueConcurrentHookUpdate(); // from './ReactFiberConcurrentUpdates'
	scheduleUpdateOnFiber(); // from './ReactFiberWorkLoop'
	function entangleTransitionUpdate() {
	isTransitionLane(); // from './ReactFiberLane'
	intersectLanes(); // from './ReactFiberLane'
	mergeLanes(); // from './ReactFiberLane'
	markRootEntangled(); // from './ReactFiberLane'
	}
	markUpdateInDevTools();
	}
	function dispatchOptimisticSetState() {
	requestTransitionLane(); // from './ReactFiberRootScheduler'
	function isRenderPhaseUpdate() {}
	enqueueConcurrentHookUpdate(); // from './ReactFiberConcurrentUpdates'
	scheduleUpdateOnFiber(); // from './ReactFiberWorkLoop'
	markUpdateInDevTools();
	}

	function markUpdateInDevTools() {
	markStateUpdateScheduled(); // from './ReactFiberDevToolsHook'
	}