File size: 3,447 Bytes
b91e262 | 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 | import type { NonStaticRenderStage } from './app-render/staged-rendering'
import type { RequestStore } from './app-render/work-unit-async-storage.external'
export function isHangingPromiseRejectionError(
err: unknown
): err is HangingPromiseRejectionError {
if (typeof err !== 'object' || err === null || !('digest' in err)) {
return false
}
return err.digest === HANGING_PROMISE_REJECTION
}
const HANGING_PROMISE_REJECTION = 'HANGING_PROMISE_REJECTION'
class HangingPromiseRejectionError extends Error {
public readonly digest = HANGING_PROMISE_REJECTION
constructor(
public readonly route: string,
public readonly expression: string
) {
super(
`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context. This occurred at route "${route}".`
)
}
}
type AbortListeners = Array<(err: unknown) => void>
const abortListenersBySignal = new WeakMap<AbortSignal, AbortListeners>()
/**
* This function constructs a promise that will never resolve. This is primarily
* useful for cacheComponents where we use promise resolution timing to determine which
* parts of a render can be included in a prerender.
*
* @internal
*/
export function makeHangingPromise<T>(
signal: AbortSignal,
route: string,
expression: string
): Promise<T> {
if (signal.aborted) {
return Promise.reject(new HangingPromiseRejectionError(route, expression))
} else {
const hangingPromise = new Promise<T>((_, reject) => {
const boundRejection = reject.bind(
null,
new HangingPromiseRejectionError(route, expression)
)
let currentListeners = abortListenersBySignal.get(signal)
if (currentListeners) {
currentListeners.push(boundRejection)
} else {
const listeners = [boundRejection]
abortListenersBySignal.set(signal, listeners)
signal.addEventListener(
'abort',
() => {
for (let i = 0; i < listeners.length; i++) {
listeners[i]()
}
},
{ once: true }
)
}
})
// We are fine if no one actually awaits this promise. We shouldn't consider this an unhandled rejection so
// we attach a noop catch handler here to suppress this warning. If you actually await somewhere or construct
// your own promise out of it you'll need to ensure you handle the error when it rejects.
hangingPromise.catch(ignoreReject)
return hangingPromise
}
}
function ignoreReject() {}
export function makeDevtoolsIOAwarePromise<T>(
underlying: T,
requestStore: RequestStore,
stage: NonStaticRenderStage
): Promise<T> {
if (requestStore.stagedRendering) {
// We resolve each stage in a timeout, so React DevTools will pick this up as IO.
return requestStore.stagedRendering.delayUntilStage(
stage,
undefined,
underlying
)
}
// in React DevTools if we resolve in a setTimeout we will observe
// the promise resolution as something that can suspend a boundary or root.
return new Promise<T>((resolve) => {
// Must use setTimeout to be considered IO React DevTools. setImmediate will not work.
setTimeout(() => {
resolve(underlying)
}, 0)
})
}
|