File size: 4,890 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
import { fetchServerResponse } from '../fetch-server-response'
import { createHrefFromUrl } from '../create-href-from-url'
import { applyRouterStatePatchToTree } from '../apply-router-state-patch-to-tree'
import { isNavigatingToNewRootLayout } from '../is-navigating-to-new-root-layout'
import type {
Mutable,
ReadonlyReducerState,
ReducerState,
RefreshAction,
} from '../router-reducer-types'
import { handleExternalUrl } from './navigate-reducer'
import { handleMutable } from '../handle-mutable'
import type { CacheNode } from '../../../../shared/lib/app-router-context.shared-runtime'
import { fillLazyItemsTillLeafWithHead } from '../fill-lazy-items-till-leaf-with-head'
import { createEmptyCacheNode } from '../../app-router'
import { handleSegmentMismatch } from '../handle-segment-mismatch'
import { hasInterceptionRouteInCurrentTree } from './has-interception-route-in-current-tree'
import { refreshInactiveParallelSegments } from '../refetch-inactive-parallel-segments'
import { revalidateEntireCache } from '../../segment-cache'
export function refreshReducer(
state: ReadonlyReducerState,
action: RefreshAction
): ReducerState {
const { origin } = action
const mutable: Mutable = {}
const href = state.canonicalUrl
let currentTree = state.tree
mutable.preserveCustomHistoryState = false
const cache: CacheNode = createEmptyCacheNode()
// If the current tree was intercepted, the nextUrl should be included in the request.
// This is to ensure that the refresh request doesn't get intercepted, accidentally triggering the interception route.
const includeNextUrl = hasInterceptionRouteInCurrentTree(state.tree)
// TODO-APP: verify that `href` is not an external url.
// Fetch data from the root of the tree.
cache.lazyData = fetchServerResponse(new URL(href, origin), {
flightRouterState: [
currentTree[0],
currentTree[1],
currentTree[2],
'refetch',
],
nextUrl: includeNextUrl ? state.nextUrl : null,
})
const navigatedAt = Date.now()
return cache.lazyData.then(
async ({ flightData, canonicalUrl: canonicalUrlOverride }) => {
// Handle case when navigating to page in `pages` from `app`
if (typeof flightData === 'string') {
return handleExternalUrl(
state,
mutable,
flightData,
state.pushRef.pendingPush
)
}
// Remove cache.lazyData as it has been resolved at this point.
cache.lazyData = null
for (const normalizedFlightData of flightData) {
const {
tree: treePatch,
seedData: cacheNodeSeedData,
head,
isRootRender,
} = normalizedFlightData
if (!isRootRender) {
// TODO-APP: handle this case better
console.log('REFRESH FAILED')
return state
}
const newTree = applyRouterStatePatchToTree(
// TODO-APP: remove ''
[''],
currentTree,
treePatch,
state.canonicalUrl
)
if (newTree === null) {
return handleSegmentMismatch(state, action, treePatch)
}
if (isNavigatingToNewRootLayout(currentTree, newTree)) {
return handleExternalUrl(
state,
mutable,
href,
state.pushRef.pendingPush
)
}
const canonicalUrlOverrideHref = canonicalUrlOverride
? createHrefFromUrl(canonicalUrlOverride)
: undefined
if (canonicalUrlOverride) {
mutable.canonicalUrl = canonicalUrlOverrideHref
}
// Handles case where prefetch only returns the router tree patch without rendered components.
if (cacheNodeSeedData !== null) {
const rsc = cacheNodeSeedData[1]
const loading = cacheNodeSeedData[3]
cache.rsc = rsc
cache.prefetchRsc = null
cache.loading = loading
fillLazyItemsTillLeafWithHead(
navigatedAt,
cache,
// Existing cache is not passed in as `router.refresh()` has to invalidate the entire cache.
undefined,
treePatch,
cacheNodeSeedData,
head,
undefined
)
if (process.env.__NEXT_CLIENT_SEGMENT_CACHE) {
revalidateEntireCache(state.nextUrl, newTree)
} else {
mutable.prefetchCache = new Map()
}
}
await refreshInactiveParallelSegments({
navigatedAt,
state,
updatedTree: newTree,
updatedCache: cache,
includeNextUrl,
canonicalUrl: mutable.canonicalUrl || state.canonicalUrl,
})
mutable.cache = cache
mutable.patchedTree = newTree
currentTree = newTree
}
return handleMutable(state, mutable)
},
() => state
)
}
|