File size: 4,831 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 |
/**
* This class is used to detect when all cache reads for a given render are settled.
* We do this to allow for cache warming the prerender without having to continue rendering
* the remainder of the page. This feature is really only useful when the cacheComponents flag is on
* and should only be used in codepaths gated with this feature.
*/
import { InvariantError } from '../../shared/lib/invariant-error'
export class CacheSignal {
private count = 0
private earlyListeners: Array<() => void> = []
private listeners: Array<() => void> = []
private tickPending = false
private taskPending = false
private subscribedSignals: Set<CacheSignal> | null = null
constructor() {
if (process.env.NEXT_RUNTIME === 'edge') {
// we rely on `process.nextTick`, which is not supported in edge
throw new InvariantError(
'CacheSignal cannot be used in the edge runtime, because `cacheComponents` does not support it.'
)
}
}
private noMorePendingCaches() {
if (!this.tickPending) {
this.tickPending = true
process.nextTick(() => {
this.tickPending = false
if (this.count === 0) {
for (let i = 0; i < this.earlyListeners.length; i++) {
this.earlyListeners[i]()
}
this.earlyListeners.length = 0
}
})
}
if (!this.taskPending) {
this.taskPending = true
setTimeout(() => {
this.taskPending = false
if (this.count === 0) {
for (let i = 0; i < this.listeners.length; i++) {
this.listeners[i]()
}
this.listeners.length = 0
}
}, 0)
}
}
/**
* This promise waits until there are no more in progress cache reads but no later.
* This allows for adding more cache reads after to delay cacheReady.
*/
inputReady() {
return new Promise<void>((resolve) => {
this.earlyListeners.push(resolve)
if (this.count === 0) {
this.noMorePendingCaches()
}
})
}
/**
* If there are inflight cache reads this Promise can resolve in a microtask however
* if there are no inflight cache reads then we wait at least one task to allow initial
* cache reads to be initiated.
*/
cacheReady() {
return new Promise<void>((resolve) => {
this.listeners.push(resolve)
if (this.count === 0) {
this.noMorePendingCaches()
}
})
}
beginRead() {
this.count++
if (this.subscribedSignals !== null) {
for (const subscriber of this.subscribedSignals) {
subscriber.beginRead()
}
}
}
endRead() {
if (this.count === 0) {
throw new InvariantError(
'CacheSignal got more endRead() calls than beginRead() calls'
)
}
// If this is the last read we need to wait a task before we can claim the cache is settled.
// The cache read will likely ping a Server Component which can read from the cache again and this
// will play out in a microtask so we need to only resolve pending listeners if we're still at 0
// after at least one task.
// We only want one task scheduled at a time so when we hit count 1 we don't decrement the counter immediately.
// If intervening reads happen before the scheduled task runs they will never observe count 1 preventing reentrency
this.count--
if (this.count === 0) {
this.noMorePendingCaches()
}
if (this.subscribedSignals !== null) {
for (const subscriber of this.subscribedSignals) {
subscriber.endRead()
}
}
}
trackRead<T>(promise: Promise<T>) {
this.beginRead()
// `promise.finally()` still rejects, so don't use it here to avoid unhandled rejections
const onFinally = this.endRead.bind(this)
promise.then(onFinally, onFinally)
return promise
}
subscribeToReads(subscriber: CacheSignal): () => void {
if (subscriber === this) {
throw new InvariantError('A CacheSignal cannot subscribe to itself')
}
if (this.subscribedSignals === null) {
this.subscribedSignals = new Set()
}
this.subscribedSignals.add(subscriber)
// we'll notify the subscriber of each endRead() on this signal,
// so we need to give it a corresponding beginRead() for each read we have in flight now.
for (let i = 0; i < this.count; i++) {
subscriber.beginRead()
}
return this.unsubscribeFromReads.bind(this, subscriber)
}
unsubscribeFromReads(subscriber: CacheSignal) {
if (!this.subscribedSignals) {
return
}
this.subscribedSignals.delete(subscriber)
// we don't need to set the set back to `null` if it's empty --
// if other signals are subscribing to this one, it'll likely get more subscriptions later,
// so we'd have to allocate a fresh set again when that happens.
}
}
|