|
588 | 588 | return requiredContext(contextStackCursor.current); |
589 | 589 | } |
590 | 590 | function pushHostContext(fiber) { |
591 | | - null !== fiber.memoizedState && |
592 | | - push(hostTransitionProviderCursor, fiber, fiber); |
593 | | - var context = requiredContext(contextStackCursor.current); |
| 591 | + var stateHook = fiber.memoizedState; |
| 592 | + null !== stateHook && |
| 593 | + ((HostTransitionContext._currentValue = stateHook.memoizedState), |
| 594 | + push(hostTransitionProviderCursor, fiber, fiber)); |
| 595 | + stateHook = requiredContext(contextStackCursor.current); |
594 | 596 | var type = fiber.type; |
595 | | - var nextContext = getChildHostContextProd(context.context, type); |
596 | | - type = updatedAncestorInfoDev(context.ancestorInfo, type); |
| 597 | + var nextContext = getChildHostContextProd(stateHook.context, type); |
| 598 | + type = updatedAncestorInfoDev(stateHook.ancestorInfo, type); |
597 | 599 | nextContext = { context: nextContext, ancestorInfo: type }; |
598 | | - context !== nextContext && |
| 600 | + stateHook !== nextContext && |
599 | 601 | (push(contextFiberStackCursor, fiber, fiber), |
600 | 602 | push(contextStackCursor, nextContext, fiber)); |
601 | 603 | } |
|
5093 | 5095 | (workInProgress.flags = 0), |
5094 | 5096 | (workInProgress.subtreeFlags = 0), |
5095 | 5097 | (workInProgress.deletions = null), |
| 5098 | + (workInProgress.key = current.key), |
5096 | 5099 | (workInProgress.actualDuration = -0), |
5097 | 5100 | (workInProgress.actualStartTime = -1.1)); |
5098 | 5101 | workInProgress.flags = current.flags & 132120576; |
|
5156 | 5159 | (workInProgress.memoizedState = current.memoizedState), |
5157 | 5160 | (workInProgress.updateQueue = current.updateQueue), |
5158 | 5161 | (workInProgress.type = current.type), |
| 5162 | + (workInProgress.key = current.key), |
5159 | 5163 | (renderLanes = current.dependencies), |
5160 | 5164 | (workInProgress.dependencies = |
5161 | 5165 | null === renderLanes |
|
6599 | 6603 | } |
6600 | 6604 | function mapRemainingChildren(currentFirstChild) { |
6601 | 6605 | for (var existingChildren = new Map(); null !== currentFirstChild; ) |
6602 | | - null !== currentFirstChild.key |
6603 | | - ? existingChildren.set(currentFirstChild.key, currentFirstChild) |
6604 | | - : existingChildren.set(currentFirstChild.index, currentFirstChild), |
| 6606 | + null === currentFirstChild.key |
| 6607 | + ? existingChildren.set(currentFirstChild.index, currentFirstChild) |
| 6608 | + : currentFirstChild.key === REACT_OPTIMISTIC_KEY |
| 6609 | + ? existingChildren.set( |
| 6610 | + -currentFirstChild.index - 1, |
| 6611 | + currentFirstChild |
| 6612 | + ) |
| 6613 | + : existingChildren.set(currentFirstChild.key, currentFirstChild), |
6605 | 6614 | (currentFirstChild = currentFirstChild.sibling); |
6606 | 6615 | return existingChildren; |
6607 | 6616 | } |
|
6697 | 6706 | current.stateNode.implementation !== portal.implementation |
6698 | 6707 | ) |
6699 | 6708 | return ( |
6700 | | - (current = createFiberFromPortal(portal, returnFiber.mode, lanes)), |
6701 | | - (current.return = returnFiber), |
6702 | | - (current._debugInfo = currentDebugInfo), |
6703 | | - current |
| 6709 | + (portal = createFiberFromPortal(portal, returnFiber.mode, lanes)), |
| 6710 | + (portal.return = returnFiber), |
| 6711 | + (portal._debugInfo = currentDebugInfo), |
| 6712 | + portal |
6704 | 6713 | ); |
6705 | 6714 | current = useFiber(current, portal.children || []); |
| 6715 | + current.key = portal.key; |
6706 | 6716 | current.return = returnFiber; |
6707 | 6717 | current._debugInfo = currentDebugInfo; |
6708 | 6718 | return current; |
6709 | 6719 | } |
6710 | 6720 | function updateFragment(returnFiber, current, fragment, lanes, key) { |
6711 | 6721 | if (null === current || 7 !== current.tag) |
6712 | 6722 | return ( |
6713 | | - (current = createFiberFromFragment( |
| 6723 | + (key = createFiberFromFragment( |
6714 | 6724 | fragment, |
6715 | 6725 | returnFiber.mode, |
6716 | 6726 | lanes, |
6717 | 6727 | key |
6718 | 6728 | )), |
6719 | | - (current.return = returnFiber), |
6720 | | - (current._debugOwner = returnFiber), |
6721 | | - (current._debugTask = returnFiber._debugTask), |
6722 | | - (current._debugInfo = currentDebugInfo), |
6723 | | - current |
| 6729 | + (key.return = returnFiber), |
| 6730 | + (key._debugOwner = returnFiber), |
| 6731 | + (key._debugTask = returnFiber._debugTask), |
| 6732 | + (key._debugInfo = currentDebugInfo), |
| 6733 | + key |
6724 | 6734 | ); |
6725 | 6735 | current = useFiber(current, fragment); |
| 6736 | + current.key = key; |
6726 | 6737 | current.return = returnFiber; |
6727 | 6738 | current._debugInfo = currentDebugInfo; |
6728 | 6739 | return current; |
|
6931 | 6942 | (newIdx = |
6932 | 6943 | existingChildren.get( |
6933 | 6944 | null === newChild.key ? newIdx : newChild.key |
6934 | | - ) || null), |
| 6945 | + ) || |
| 6946 | + existingChildren.get(-newIdx - 1) || |
| 6947 | + null), |
6935 | 6948 | (existingChildren = pushDebugInfo(newChild._debugInfo)), |
6936 | 6949 | (returnFiber = updateElement( |
6937 | 6950 | returnFiber, |
|
6947 | 6960 | (existingChildren = |
6948 | 6961 | existingChildren.get( |
6949 | 6962 | null === newChild.key ? newIdx : newChild.key |
6950 | | - ) || null), |
| 6963 | + ) || |
| 6964 | + existingChildren.get(-newIdx - 1) || |
| 6965 | + null), |
6951 | 6966 | updatePortal(returnFiber, existingChildren, newChild, lanes) |
6952 | 6967 | ); |
6953 | 6968 | case REACT_LAZY_TYPE: |
|
7133 | 7148 | knownKeys |
7134 | 7149 | )), |
7135 | 7150 | shouldTrackSideEffects && |
7136 | | - null !== nextOldFiber.alternate && |
7137 | | - oldFiber.delete( |
7138 | | - null === nextOldFiber.key ? newIdx : nextOldFiber.key |
7139 | | - ), |
| 7151 | + ((newFiber = nextOldFiber.alternate), |
| 7152 | + null !== newFiber && |
| 7153 | + (newFiber.key === REACT_OPTIMISTIC_KEY |
| 7154 | + ? oldFiber.delete(-newIdx - 1) |
| 7155 | + : oldFiber.delete( |
| 7156 | + null === newFiber.key ? newIdx : newFiber.key |
| 7157 | + ))), |
7140 | 7158 | (currentFirstChild = placeChild( |
7141 | 7159 | nextOldFiber, |
7142 | 7160 | currentFirstChild, |
|
7276 | 7294 | knownKeys |
7277 | 7295 | )), |
7278 | 7296 | shouldTrackSideEffects && |
7279 | | - null !== nextOldFiber.alternate && |
7280 | | - oldFiber.delete( |
7281 | | - null === nextOldFiber.key ? newIdx : nextOldFiber.key |
7282 | | - ), |
| 7297 | + ((step = nextOldFiber.alternate), |
| 7298 | + null !== step && |
| 7299 | + (step.key === REACT_OPTIMISTIC_KEY |
| 7300 | + ? oldFiber.delete(-newIdx - 1) |
| 7301 | + : oldFiber.delete(null === step.key ? newIdx : step.key))), |
7283 | 7302 | (currentFirstChild = placeChild( |
7284 | 7303 | nextOldFiber, |
7285 | 7304 | currentFirstChild, |
|
7315 | 7334 | var prevDebugInfo = pushDebugInfo(newChild._debugInfo); |
7316 | 7335 | a: { |
7317 | 7336 | for (var key = newChild.key; null !== currentFirstChild; ) { |
7318 | | - if (currentFirstChild.key === key) { |
7319 | | - key = newChild.type; |
7320 | | - if (key === REACT_FRAGMENT_TYPE) { |
| 7337 | + if ( |
| 7338 | + currentFirstChild.key === key || |
| 7339 | + currentFirstChild.key === REACT_OPTIMISTIC_KEY |
| 7340 | + ) { |
| 7341 | + var elementType = newChild.type; |
| 7342 | + if (elementType === REACT_FRAGMENT_TYPE) { |
7321 | 7343 | if (7 === currentFirstChild.tag) { |
7322 | 7344 | deleteRemainingChildren( |
7323 | 7345 | returnFiber, |
|
7327 | 7349 | currentFirstChild, |
7328 | 7350 | newChild.props.children |
7329 | 7351 | ); |
| 7352 | + lanes.key = key; |
7330 | 7353 | coerceRef(lanes, newChild); |
7331 | 7354 | lanes.return = returnFiber; |
7332 | 7355 | lanes._debugOwner = newChild._owner; |
|
7336 | 7359 | break a; |
7337 | 7360 | } |
7338 | 7361 | } else if ( |
7339 | | - currentFirstChild.elementType === key || |
| 7362 | + currentFirstChild.elementType === elementType || |
7340 | 7363 | isCompatibleFamilyForHotReloading( |
7341 | 7364 | currentFirstChild, |
7342 | 7365 | newChild |
7343 | 7366 | ) || |
7344 | | - ("object" === typeof key && |
7345 | | - null !== key && |
7346 | | - key.$$typeof === REACT_LAZY_TYPE && |
7347 | | - resolveLazy(key) === currentFirstChild.type) |
| 7367 | + ("object" === typeof elementType && |
| 7368 | + null !== elementType && |
| 7369 | + elementType.$$typeof === REACT_LAZY_TYPE && |
| 7370 | + resolveLazy(elementType) === currentFirstChild.type) |
7348 | 7371 | ) { |
7349 | 7372 | deleteRemainingChildren( |
7350 | 7373 | returnFiber, |
7351 | 7374 | currentFirstChild.sibling |
7352 | 7375 | ); |
7353 | 7376 | lanes = useFiber(currentFirstChild, newChild.props); |
| 7377 | + lanes.key = key; |
7354 | 7378 | coerceRef(lanes, newChild); |
7355 | 7379 | lanes.return = returnFiber; |
7356 | 7380 | lanes._debugOwner = newChild._owner; |
|
7392 | 7416 | return returnFiber; |
7393 | 7417 | case REACT_PORTAL_TYPE: |
7394 | 7418 | a: { |
7395 | | - prevDebugInfo = newChild; |
7396 | 7419 | for ( |
7397 | | - newChild = prevDebugInfo.key; |
| 7420 | + prevDebugInfo = newChild.key; |
7398 | 7421 | null !== currentFirstChild; |
7399 | 7422 |
|
7400 | 7423 | ) { |
7401 | | - if (currentFirstChild.key === newChild) |
| 7424 | + if ( |
| 7425 | + currentFirstChild.key === prevDebugInfo || |
| 7426 | + currentFirstChild.key === REACT_OPTIMISTIC_KEY |
| 7427 | + ) |
7402 | 7428 | if ( |
7403 | 7429 | 4 === currentFirstChild.tag && |
7404 | 7430 | currentFirstChild.stateNode.containerInfo === |
7405 | | - prevDebugInfo.containerInfo && |
| 7431 | + newChild.containerInfo && |
7406 | 7432 | currentFirstChild.stateNode.implementation === |
7407 | | - prevDebugInfo.implementation |
| 7433 | + newChild.implementation |
7408 | 7434 | ) { |
7409 | 7435 | deleteRemainingChildren( |
7410 | 7436 | returnFiber, |
7411 | 7437 | currentFirstChild.sibling |
7412 | 7438 | ); |
7413 | 7439 | lanes = useFiber( |
7414 | 7440 | currentFirstChild, |
7415 | | - prevDebugInfo.children || [] |
| 7441 | + newChild.children || [] |
7416 | 7442 | ); |
| 7443 | + lanes.key = prevDebugInfo; |
7417 | 7444 | lanes.return = returnFiber; |
7418 | 7445 | returnFiber = lanes; |
7419 | 7446 | break a; |
|
7425 | 7452 | currentFirstChild = currentFirstChild.sibling; |
7426 | 7453 | } |
7427 | 7454 | lanes = createFiberFromPortal( |
7428 | | - prevDebugInfo, |
| 7455 | + newChild, |
7429 | 7456 | returnFiber.mode, |
7430 | 7457 | lanes |
7431 | 7458 | ); |
|
7466 | 7493 | throw Error( |
7467 | 7494 | "An object is not an iterable. This error is likely caused by a bug in React. Please file an issue." |
7468 | 7495 | ); |
7469 | | - var newChildren = key.call(newChild); |
7470 | | - if (newChildren === newChild) { |
| 7496 | + elementType = key.call(newChild); |
| 7497 | + if (elementType === newChild) { |
7471 | 7498 | if ( |
7472 | 7499 | 0 !== returnFiber.tag || |
7473 | 7500 | "[object GeneratorFunction]" !== |
7474 | 7501 | Object.prototype.toString.call(returnFiber.type) || |
7475 | 7502 | "[object Generator]" !== |
7476 | | - Object.prototype.toString.call(newChildren) |
| 7503 | + Object.prototype.toString.call(elementType) |
7477 | 7504 | ) |
7478 | 7505 | didWarnAboutGenerators || |
7479 | 7506 | console.error( |
|
7490 | 7517 | returnFiber = reconcileChildrenIterator( |
7491 | 7518 | returnFiber, |
7492 | 7519 | currentFirstChild, |
7493 | | - newChildren, |
| 7520 | + elementType, |
7494 | 7521 | lanes |
7495 | 7522 | ); |
7496 | 7523 | currentDebugInfo = prevDebugInfo; |
|
28263 | 28290 | REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), |
28264 | 28291 | MAYBE_ITERATOR_SYMBOL = Symbol.iterator, |
28265 | 28292 | ASYNC_ITERATOR = Symbol.asyncIterator, |
| 28293 | + REACT_OPTIMISTIC_KEY = Symbol.for("react.optimistic_key"), |
28266 | 28294 | REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), |
28267 | 28295 | isArrayImpl = Array.isArray, |
28268 | 28296 | ReactSharedInternals = |
@@ -32418,11 +32446,11 @@ |
32418 | 32446 | }; |
32419 | 32447 | (function () { |
32420 | 32448 | var isomorphicReactPackageVersion = React.version; |
32421 | | - if ("19.3.0-experimental-0972e239-20251118" !== isomorphicReactPackageVersion) |
| 32449 | + if ("19.3.0-experimental-8ac5f4eb-20251119" !== isomorphicReactPackageVersion) |
32422 | 32450 | throw Error( |
32423 | 32451 | 'Incompatible React versions: The "react" and "react-dom" packages must have the exact same version. Instead got:\n - react: ' + |
32424 | 32452 | (isomorphicReactPackageVersion + |
32425 | | - "\n - react-dom: 19.3.0-experimental-0972e239-20251118\nLearn more: https://react.dev/warnings/version-mismatch") |
| 32453 | + "\n - react-dom: 19.3.0-experimental-8ac5f4eb-20251119\nLearn more: https://react.dev/warnings/version-mismatch") |
32426 | 32454 | ); |
32427 | 32455 | })(); |
32428 | 32456 | ("function" === typeof Map && |
@@ -32459,10 +32487,10 @@ |
32459 | 32487 | !(function () { |
32460 | 32488 | var internals = { |
32461 | 32489 | bundleType: 1, |
32462 | | - version: "19.3.0-experimental-0972e239-20251118", |
| 32490 | + version: "19.3.0-experimental-8ac5f4eb-20251119", |
32463 | 32491 | rendererPackageName: "react-dom", |
32464 | 32492 | currentDispatcherRef: ReactSharedInternals, |
32465 | | - reconcilerVersion: "19.3.0-experimental-0972e239-20251118" |
| 32493 | + reconcilerVersion: "19.3.0-experimental-8ac5f4eb-20251119" |
32466 | 32494 | }; |
32467 | 32495 | internals.overrideHookState = overrideHookState; |
32468 | 32496 | internals.overrideHookStateDeletePath = overrideHookStateDeletePath; |
|
32610 | 32638 | listenToAllSupportedEvents(container); |
32611 | 32639 | return new ReactDOMHydrationRoot(initialChildren); |
32612 | 32640 | }; |
32613 | | - exports.version = "19.3.0-experimental-0972e239-20251118"; |
| 32641 | + exports.version = "19.3.0-experimental-8ac5f4eb-20251119"; |
32614 | 32642 | "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && |
32615 | 32643 | "function" === |
32616 | 32644 | typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && |
|
0 commit comments