d147843c76
- Introduced blog routing using Next.js App Router - Implemented dynamic [slug] pages for blog posts - Added MDX-based content loading via lib/posts - Integrated shared TopBar layout with navigation - Established clear content, lib and component separation
570 lines
26 KiB
JavaScript
570 lines
26 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
0 && (module.exports = {
|
|
DANGEROUSLY_runPendingImmediatesAfterCurrentTask: null,
|
|
expectNoPendingImmediates: null,
|
|
unpatchedSetImmediate: null
|
|
});
|
|
function _export(target, all) {
|
|
for(var name in all)Object.defineProperty(target, name, {
|
|
enumerable: true,
|
|
get: all[name]
|
|
});
|
|
}
|
|
_export(exports, {
|
|
DANGEROUSLY_runPendingImmediatesAfterCurrentTask: function() {
|
|
return DANGEROUSLY_runPendingImmediatesAfterCurrentTask;
|
|
},
|
|
expectNoPendingImmediates: function() {
|
|
return expectNoPendingImmediates;
|
|
},
|
|
unpatchedSetImmediate: function() {
|
|
return originalSetImmediate;
|
|
}
|
|
});
|
|
const _nodeutil = require("node:util");
|
|
const _invarianterror = require("../../shared/lib/invariant-error");
|
|
const _asynclocalstorage = require("../app-render/async-local-storage");
|
|
var ExecutionState = /*#__PURE__*/ function(ExecutionState) {
|
|
ExecutionState[ExecutionState["Waiting"] = 1] = "Waiting";
|
|
ExecutionState[ExecutionState["Working"] = 2] = "Working";
|
|
ExecutionState[ExecutionState["Finished"] = 3] = "Finished";
|
|
ExecutionState[ExecutionState["Abandoned"] = 4] = "Abandoned";
|
|
return ExecutionState;
|
|
}(ExecutionState || {});
|
|
let wasEnabledAtLeastOnce = false;
|
|
let pendingNextTicks = 0;
|
|
let currentExecution = null;
|
|
const originalSetImmediate = globalThis.setImmediate;
|
|
const originalClearImmediate = globalThis.clearImmediate;
|
|
const originalNextTick = process.nextTick;
|
|
function install() {
|
|
if (process.env.NEXT_RUNTIME === 'edge') {
|
|
// Nothing to patch. The exported functions all error if used in the edge runtime,
|
|
// so we're not going to violate any assumptions by not patching.
|
|
return;
|
|
} else {
|
|
debug == null ? void 0 : debug('installing fast setImmediate patch');
|
|
const nodeTimers = require('node:timers');
|
|
globalThis.setImmediate = nodeTimers.setImmediate = // Workaround for missing __promisify__ which is not a real property
|
|
patchedSetImmediate;
|
|
globalThis.clearImmediate = nodeTimers.clearImmediate = patchedClearImmediate;
|
|
const nodeTimersPromises = require('node:timers/promises');
|
|
nodeTimersPromises.setImmediate = patchedSetImmediatePromise;
|
|
process.nextTick = patchedNextTick;
|
|
}
|
|
}
|
|
function DANGEROUSLY_runPendingImmediatesAfterCurrentTask() {
|
|
if (process.env.NEXT_RUNTIME === 'edge') {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('DANGEROUSLY_runPendingImmediatesAfterCurrentTask cannot be called in the edge runtime'), "__NEXT_ERROR_CODE", {
|
|
value: "E960",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
} else {
|
|
const execution = startCapturingImmediates();
|
|
try {
|
|
scheduleWorkAfterNextTicksAndMicrotasks(execution);
|
|
} catch (err) {
|
|
// If this error comes from a bail() call, rethrow it.
|
|
if (execution.state === 4) {
|
|
throw err;
|
|
}
|
|
// Otherwise, bail out here.
|
|
bail(execution, Object.defineProperty(new _invarianterror.InvariantError('An unexpected error occurred while starting to capture immediates', {
|
|
cause: err
|
|
}), "__NEXT_ERROR_CODE", {
|
|
value: "E964",
|
|
enumerable: false,
|
|
configurable: true
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
function expectNoPendingImmediates() {
|
|
if (process.env.NEXT_RUNTIME === 'edge') {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('expectNoPendingImmediates cannot be called in the edge runtime'), "__NEXT_ERROR_CODE", {
|
|
value: "E962",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
} else {
|
|
if (currentExecution !== null) {
|
|
bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError(`Expected all captured immediates to have been executed (state: ${ExecutionState[currentExecution.state]})`), "__NEXT_ERROR_CODE", {
|
|
value: "E958",
|
|
enumerable: false,
|
|
configurable: true
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Wait until all nextTicks and microtasks spawned from the current task are done,
|
|
* then execute any immediates that they queued.
|
|
* */ function scheduleWorkAfterNextTicksAndMicrotasks(execution) {
|
|
if (execution.state !== 1) {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError(`scheduleWorkAfterTicksAndMicrotasks can only be called while waiting (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
|
|
value: "E959",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
// We want to execute "fast immediates" after all the nextTicks and microtasks
|
|
// spawned from the current task are done.
|
|
// The ordering here is:
|
|
//
|
|
// 1. sync code
|
|
// 2. process.nextTick (scheduled from sync code, or from one of these nextTicks)
|
|
// 3. microtasks
|
|
// 4. process.nextTick (scheduled from microtasks, e.g. `queueMicrotask(() => process.nextTick(callback))`)
|
|
//
|
|
// We want to run to run in step 4, because that's the latest point before the next tick.
|
|
// However, there might also be other callbacks scheduled to run in that step.
|
|
// But importantly, they had to be scheduled using a `process.nextTick`,
|
|
// so we can detect them by checking if `pendingNextTicks > 0`.
|
|
// In that case, we'll just reschedule ourselves in the same way again to let them run first.
|
|
// (this process can theoretically repeat multiple times, hence the recursion).
|
|
queueMicrotask(()=>{
|
|
// (note that this call won't increment `pendingNextTicks`,
|
|
// only the patched `process.nextTick` does that, so this won't loop infinitely)
|
|
originalNextTick(()=>{
|
|
// We're now in a nextTick, which means that we're executing inside `processTicksAndRejections`:
|
|
// https://github.com/nodejs/node/blob/d546e7fd0bc3cbb4bcc2baae6f3aa44d2e81a413/lib/internal/process/task_queues.js#L84
|
|
// All the work scheduled here will happen within that `processTicksAndRejections` loop.
|
|
// Reading the source of `processTicksAndRejections` can help understand the timing here --
|
|
// All we're really doing is strategically pushing callbacks into the two queues
|
|
// (nextTicks and microtasks) that that function is currently looping over.
|
|
try {
|
|
if (execution.state === 4 || currentExecution !== execution) {
|
|
debug == null ? void 0 : debug(`scheduler :: the execution was abandoned`);
|
|
return;
|
|
}
|
|
if (pendingNextTicks > 0) {
|
|
// Other nextTicks have been scheduled. Let those run first, then try again --
|
|
// we're simulating a event loop task, so all nextTicks should be exhausted before we execute.
|
|
debug == null ? void 0 : debug(`scheduler :: yielding to ${pendingNextTicks} nextTicks`);
|
|
return scheduleWorkAfterNextTicksAndMicrotasks(execution);
|
|
}
|
|
// There's no other nextTicks, we're the last one, so we're about to move on to the next task (likely a timer).
|
|
// Now, we can try and execute any queued immediates.
|
|
return performWork(execution);
|
|
} catch (err) {
|
|
// If this error comes from a bail() call, rethrow it.
|
|
// typescript can't tell that the state might've been mutated
|
|
// and the narrowing from above is no longer valid
|
|
const executionAfterWork = execution;
|
|
if (executionAfterWork.state === 4) {
|
|
throw err;
|
|
}
|
|
// Otherwise, bail out here (which will trigger an uncaught exception)
|
|
// Note that we're using the same microtask trick as `safelyRunNextTickCallback`.
|
|
queueMicrotask(()=>{
|
|
bail(execution, Object.defineProperty(new _invarianterror.InvariantError('An unexpected error occurred while executing immediates', {
|
|
cause: err
|
|
}), "__NEXT_ERROR_CODE", {
|
|
value: "E955",
|
|
enumerable: false,
|
|
configurable: true
|
|
}));
|
|
});
|
|
}
|
|
});
|
|
});
|
|
}
|
|
/** Execute one immediate, and schedule a check for more (in case there's others in the queue) */ function performWork(execution) {
|
|
if (execution.state === 4) {
|
|
return;
|
|
}
|
|
debug == null ? void 0 : debug(`scheduler :: performing work`);
|
|
if (execution.state !== 1) {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError(`performWork can only be called while waiting (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
|
|
value: "E956",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
execution.state = 2;
|
|
const queueItem = takeNextActiveQueueItem(execution);
|
|
if (queueItem === null) {
|
|
debug == null ? void 0 : debug(`scheduler :: no immediates queued, exiting`);
|
|
stopCapturingImmediates(execution);
|
|
return;
|
|
}
|
|
debug == null ? void 0 : debug(`scheduler :: executing queued immediate`);
|
|
const { immediateObject, callback, args } = queueItem;
|
|
immediateObject[INTERNALS].queueItem = null;
|
|
clearQueueItem(queueItem);
|
|
// Execute the immediate.
|
|
// If a sync error was thrown in the immediate, we want to trigger a `uncaughtException`.
|
|
// However, we're executing in a nextTick, and if a nextTick callback errors,
|
|
// It'll break out of `processTicksAndRejections` (note the lack of a `catch` block):
|
|
// https://github.com/nodejs/node/blob/d546e7fd0bc3cbb4bcc2baae6f3aa44d2e81a413/lib/internal/process/task_queues.js#L81-L97
|
|
// Meaning that the event loop will stop executing nextTicks and move on to the next timer
|
|
// (or other phase of the event loop, but we expect to be running in a sequence of timers here).
|
|
// Then, the remaining ticks will run after that timer, since they're still in the queue.
|
|
//
|
|
// This would completely break the timing we're trying to achieve here --
|
|
// The point of this patch is to execute immediates before the next timer!
|
|
// So, we need to work around this behavior. (both here and in our `process.nextTick` patch).
|
|
//
|
|
// We can sidestep this by catching the synchronous error and rethrowing it in a microtask.
|
|
// (NOTE: if we use `queueMicrotask`, it'll trigger `uncaughtException`, not `unhandledRejection`,
|
|
// because there's no promise being rejected.)
|
|
//
|
|
// This will make `uncaughtException` happen:
|
|
// - Before the next fast immediate (`scheduleWorkAfterNextTicksAndMicrotasks` also uses `queueMicrotask`).
|
|
// This is good, and matches usual observable behavior of immediates.
|
|
// - AFTER nextTicks scheduled from the immediate itself.
|
|
// This deviates from native setImmediate, which would call `uncaughtException` first,
|
|
// and skip ahead to the next task as explained above.
|
|
//
|
|
// This is technically an observable difference in behavior, but it seems niche enough that
|
|
// it shouldn't cause problems -- we don't expect user code to use `uncaughtException` for control flow,
|
|
// only error reporting, so subtly changing the timing shouldn't matter.
|
|
let didThrow = false;
|
|
let thrownValue = undefined;
|
|
queueMicrotask(()=>{
|
|
if (didThrow) {
|
|
debug == null ? void 0 : debug('scheduler :: rethrowing sync error from immediate in microtask');
|
|
throw thrownValue;
|
|
}
|
|
});
|
|
try {
|
|
if (args !== null) {
|
|
callback.apply(null, args);
|
|
} else {
|
|
callback();
|
|
}
|
|
} catch (err) {
|
|
// We'll rethrow the error in the microtask above.
|
|
didThrow = true;
|
|
thrownValue = err;
|
|
}
|
|
// Schedule the loop again in case there's more immediates after this one.
|
|
// Note that we can't just check if the queue is empty now, because new immediates
|
|
// might still be scheduled asynchronously, from an upcoming nextTick or microtask.
|
|
execution.state = 1;
|
|
scheduleWorkAfterNextTicksAndMicrotasks(execution);
|
|
}
|
|
function takeNextActiveQueueItem(execution) {
|
|
// Find the first (if any) queued immediate that wasn't cleared.
|
|
// We don't remove immediates from the array when they're cleared,
|
|
// so this requires some legwork to exclude (and possibly drop) cleared items.
|
|
const { queuedImmediates } = execution;
|
|
let firstActiveItem = null;
|
|
let firstActiveItemIndex = -1;
|
|
for(let i = 0; i < queuedImmediates.length; i++){
|
|
const item = queuedImmediates[i];
|
|
if (!item.isCleared) {
|
|
firstActiveItem = item;
|
|
firstActiveItemIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
if (firstActiveItem === null) {
|
|
// We didn't find an active item.
|
|
// If the queue isn't empty, then it must only contain cleared items. Empty it.
|
|
if (queuedImmediates.length > 0) {
|
|
queuedImmediates.length = 0;
|
|
}
|
|
return null;
|
|
}
|
|
// Remove all items up to and including `nextActiveItemIndex` from the queue.
|
|
// (if it's not the first item, then it must be preceded by cleared items, which we want to drop anyway)
|
|
if (firstActiveItemIndex === 0) {
|
|
// Fast path - drop the first item
|
|
// (`splice` creates a result array for the removed items, so this is more efficient)
|
|
queuedImmediates.shift();
|
|
} else {
|
|
queuedImmediates.splice(0, firstActiveItemIndex + 1);
|
|
}
|
|
return firstActiveItem;
|
|
}
|
|
function startCapturingImmediates() {
|
|
if (currentExecution !== null) {
|
|
bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError(`Cannot start capturing immediates again without finishing the previous task (state: ${ExecutionState[currentExecution.state]})`), "__NEXT_ERROR_CODE", {
|
|
value: "E954",
|
|
enumerable: false,
|
|
configurable: true
|
|
}));
|
|
}
|
|
wasEnabledAtLeastOnce = true;
|
|
const execution = {
|
|
state: 1,
|
|
queuedImmediates: []
|
|
};
|
|
currentExecution = execution;
|
|
return execution;
|
|
}
|
|
function stopCapturingImmediates(execution) {
|
|
if (execution.state === 4) {
|
|
return;
|
|
}
|
|
// This check enforces that we run performWork at least once before stopping
|
|
// to make sure that we've waited for all the nextTicks and microtasks
|
|
// that might've scheduled some immediates after sync code.
|
|
if (execution.state !== 2) {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError(`Cannot stop capturing immediates before execution is finished (state: ${ExecutionState[execution.state]})`), "__NEXT_ERROR_CODE", {
|
|
value: "E957",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
}
|
|
execution.state = 3;
|
|
if (currentExecution === execution) {
|
|
currentExecution = null;
|
|
}
|
|
}
|
|
function bail(execution, error) {
|
|
// Reset the state as best we can to prevent further crashes.
|
|
// Otherwise, any subsequent call to `DANGEROUSLY_runPendingImmediatesAfterCurrentTask`
|
|
// would error, requiring a server restart to fix.
|
|
if (currentExecution === execution) {
|
|
currentExecution = null;
|
|
}
|
|
execution.state = 4;
|
|
// If we have any queued immediates, schedule them with native `setImmediate` and clear the queue.
|
|
// We don't want to skip running them altogether, because that could lead to
|
|
// e.g. hanging promises (for `new Promise((resolve) => setImmediate(resolve))`),
|
|
// but we're in an inconsistent state and can't run them as fast immediates,
|
|
// so this is the next best thing.
|
|
for (const queueItem of execution.queuedImmediates){
|
|
if (queueItem.isCleared) {
|
|
continue;
|
|
}
|
|
scheduleQueuedImmediateAsNativeImmediate(queueItem);
|
|
}
|
|
execution.queuedImmediates.length = 0;
|
|
// Don't reset `pendingNextTicks` -- it will reset to 0 on its own as the nextTicks execute.
|
|
// If we set it to 0 here while we still have pending ticks, they'd decrement it below 0.
|
|
throw error;
|
|
}
|
|
function scheduleQueuedImmediateAsNativeImmediate(queueItem) {
|
|
const { callback, args, immediateObject } = queueItem;
|
|
const hasRef = immediateObject[INTERNALS].hasRef;
|
|
clearQueueItem(queueItem);
|
|
const nativeImmediate = args !== null ? originalSetImmediate(callback, ...args) : originalSetImmediate(callback);
|
|
if (!hasRef) {
|
|
nativeImmediate.unref();
|
|
}
|
|
// Make our fake immediate object proxy all relevant operations
|
|
// (clearing, ref(), unref(), hasRef()) to the actual native immediate.
|
|
proxyQueuedImmediateToNativeImmediate(immediateObject, nativeImmediate);
|
|
}
|
|
function clearQueueItem(originalQueueItem) {
|
|
const queueItem = originalQueueItem;
|
|
queueItem.isCleared = true;
|
|
queueItem.callback = null;
|
|
queueItem.args = null;
|
|
queueItem.immediateObject = null;
|
|
}
|
|
function patchedNextTick() {
|
|
if (currentExecution === null) {
|
|
return originalNextTick.apply(null, // @ts-expect-error: this is valid, but typescript doesn't get it
|
|
arguments);
|
|
}
|
|
if (arguments.length === 0 || typeof arguments[0] !== 'function') {
|
|
// Let the original nextTick error for invalid arguments
|
|
// so that we don't have to mirror the error message.
|
|
originalNextTick.apply(null, // @ts-expect-error: explicitly passing arguments that we know are invalid
|
|
arguments);
|
|
// We expect the above call to throw. If it didn't, something's broken.
|
|
bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError('Expected process.nextTick to reject invalid arguments'), "__NEXT_ERROR_CODE", {
|
|
value: "E966",
|
|
enumerable: false,
|
|
configurable: true
|
|
}));
|
|
}
|
|
debug == null ? void 0 : debug(`scheduler :: process.nextTick called (previous pending: ${pendingNextTicks})`);
|
|
const callback = arguments[0];
|
|
const args = arguments.length > 1 ? Array.prototype.slice.call(arguments, 1) : null;
|
|
pendingNextTicks += 1;
|
|
return originalNextTick(safelyRunNextTickCallback, callback, args);
|
|
}
|
|
function safelyRunNextTickCallback(callback, args) {
|
|
pendingNextTicks -= 1;
|
|
debug == null ? void 0 : debug(`scheduler :: process.nextTick executing (still pending: ${pendingNextTicks})`);
|
|
// Synchronous errors in nextTick break out of `processTicksAndRejections` and cause us
|
|
// to move on to the next timer without having executed the whole nextTick queue,
|
|
// which breaks our entire scheduling mechanism. See `performWork` for more details.
|
|
try {
|
|
if (args !== null) {
|
|
callback.apply(null, args);
|
|
} else {
|
|
callback();
|
|
}
|
|
} catch (err) {
|
|
// We want to make sure `nextTick` is cheap, so unlike `performWork`,
|
|
// we only queue the microtask if an error actually occurs.
|
|
// This (observably) changes the timing of `uncaughtException` even more,
|
|
// because it'll run after microtasks queued from the nextTick,
|
|
// but hopefully this is niche enough to not affect any real world code.
|
|
queueMicrotask(()=>{
|
|
debug == null ? void 0 : debug(`scheduler :: rethrowing sync error from nextTick in a microtask`);
|
|
throw err;
|
|
});
|
|
}
|
|
}
|
|
function patchedSetImmediate() {
|
|
if (currentExecution === null) {
|
|
return originalSetImmediate.apply(null, // @ts-expect-error: this is valid, but typescript doesn't get it
|
|
arguments);
|
|
}
|
|
if (arguments.length === 0 || typeof arguments[0] !== 'function') {
|
|
// Let the original setImmediate error for invalid arguments
|
|
// so that we don't have to mirror the error message.
|
|
originalSetImmediate.apply(null, // @ts-expect-error: explicitly passing arguments that we know are invalid
|
|
arguments);
|
|
// We expect the above call to throw. If it didn't, something's broken.
|
|
bail(currentExecution, Object.defineProperty(new _invarianterror.InvariantError('Expected setImmediate to reject invalid arguments'), "__NEXT_ERROR_CODE", {
|
|
value: "E965",
|
|
enumerable: false,
|
|
configurable: true
|
|
}));
|
|
}
|
|
const callback = arguments[0];
|
|
const args = arguments.length > 1 ? Array.prototype.slice.call(arguments, 1) : null;
|
|
// Normally, Node would capture and propagate the async context to the immediate.
|
|
// We'll be running it on our own queue, so we need to propagate it ourselves.
|
|
const callbackWithAsyncContext = (0, _asynclocalstorage.bindSnapshot)(callback);
|
|
const immediateObject = new NextImmediate();
|
|
const queueItem = {
|
|
isCleared: false,
|
|
callback: callbackWithAsyncContext,
|
|
args,
|
|
immediateObject
|
|
};
|
|
currentExecution.queuedImmediates.push(queueItem);
|
|
immediateObject[INTERNALS].queueItem = queueItem;
|
|
return immediateObject;
|
|
}
|
|
function patchedSetImmediatePromise(value, options) {
|
|
if (currentExecution === null) {
|
|
const originalPromisify = // @ts-expect-error: the types for `promisify.custom` are strange
|
|
originalSetImmediate[_nodeutil.promisify.custom];
|
|
return originalPromisify(value, options);
|
|
}
|
|
return new Promise((resolve, reject)=>{
|
|
// The abort signal makes the promise reject.
|
|
// If it is already aborted, we reject immediately.
|
|
const signal = options == null ? void 0 : options.signal;
|
|
if (signal && signal.aborted) {
|
|
return reject(signal.reason);
|
|
}
|
|
const immediate = patchedSetImmediate(resolve, value);
|
|
// Unref-ing only really has an observable effect if we bail out to a native immediate,
|
|
// but we do it for completeness
|
|
if ((options == null ? void 0 : options.ref) === false) {
|
|
immediate.unref();
|
|
}
|
|
if (signal) {
|
|
signal.addEventListener('abort', ()=>{
|
|
patchedClearImmediate(immediate);
|
|
reject(signal.reason);
|
|
}, {
|
|
once: true
|
|
});
|
|
}
|
|
});
|
|
}
|
|
patchedSetImmediate[_nodeutil.promisify.custom] = patchedSetImmediatePromise;
|
|
const patchedClearImmediate = (immediateObject)=>{
|
|
// NOTE: we defensively check for patched immediates even if we're not
|
|
// currently capturing immediates, because the objects returned from
|
|
// the patched setImmediate can be kept around for arbitrarily long.
|
|
// As an optimization, we only do this if the patch was enabled at least once --
|
|
// otherwise, no patched objects could've been created.
|
|
if (wasEnabledAtLeastOnce && immediateObject && typeof immediateObject === 'object' && INTERNALS in immediateObject) {
|
|
;
|
|
immediateObject[Symbol.dispose]();
|
|
} else {
|
|
originalClearImmediate(immediateObject);
|
|
}
|
|
};
|
|
//========================================================
|
|
const INTERNALS = Symbol.for('next.Immediate.internals');
|
|
function proxyQueuedImmediateToNativeImmediate(immediateObject, nativeImmediate) {
|
|
immediateObject[INTERNALS].hasRef = null;
|
|
immediateObject[INTERNALS].queueItem = null;
|
|
immediateObject[INTERNALS].nativeImmediate = nativeImmediate;
|
|
}
|
|
/** Implements a shim for the native `Immediate` class returned by `setImmediate` */ class NextImmediate {
|
|
hasRef() {
|
|
const internals = this[INTERNALS];
|
|
if (internals.queueItem) {
|
|
return internals.hasRef;
|
|
} else if (internals.nativeImmediate) {
|
|
return internals.nativeImmediate.hasRef();
|
|
} else {
|
|
// if we're no longer queued (cleared or executed), hasRef is always false
|
|
return false;
|
|
}
|
|
}
|
|
ref() {
|
|
const internals = this[INTERNALS];
|
|
if (internals.queueItem) {
|
|
internals.hasRef = true;
|
|
} else if (internals.nativeImmediate) {
|
|
internals.nativeImmediate.ref();
|
|
}
|
|
return this;
|
|
}
|
|
unref() {
|
|
const internals = this[INTERNALS];
|
|
if (internals.queueItem) {
|
|
internals.hasRef = false;
|
|
} else if (internals.nativeImmediate) {
|
|
internals.nativeImmediate.unref();
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Node invokes `_onImmediate` when an immediate is executed:
|
|
* https://github.com/nodejs/node/blob/42d363205715ffa5a4a6d90f4be1311487053d65/lib/internal/timers.js#L504
|
|
* It's visible on the public types, so we want to have it here for parity, but it's a noop.
|
|
* */ _onImmediate() {}
|
|
[Symbol.dispose]() {
|
|
// This is equivalent to `clearImmediate`.
|
|
const internals = this[INTERNALS];
|
|
if (internals.queueItem) {
|
|
// this is still queued. drop it.
|
|
const queueItem = internals.queueItem;
|
|
internals.queueItem = null;
|
|
clearQueueItem(queueItem);
|
|
} else if (internals.nativeImmediate) {
|
|
internals.nativeImmediate[Symbol.dispose]();
|
|
}
|
|
}
|
|
constructor(){
|
|
this[INTERNALS] = {
|
|
queueItem: null,
|
|
hasRef: true,
|
|
nativeImmediate: null
|
|
};
|
|
}
|
|
}
|
|
// ==========================================
|
|
const debug = process.env.NEXT_DEBUG_IMMEDIATES !== '1' ? undefined : (...args)=>{
|
|
if (process.env.NEXT_RUNTIME === 'edge') {
|
|
throw Object.defineProperty(new _invarianterror.InvariantError('Fast setImmediate is not available in the edge runtime.'), "__NEXT_ERROR_CODE", {
|
|
value: "E963",
|
|
enumerable: false,
|
|
configurable: true
|
|
});
|
|
} else {
|
|
const { inspect } = require('node:util');
|
|
const { writeFileSync } = require('node:fs');
|
|
let logLine = args.map((arg)=>typeof arg === 'string' ? arg : inspect(arg, {
|
|
colors: true
|
|
})).join(' ') + '\n';
|
|
logLine = '\x1B[2m' + logLine + '\x1B[22m' // styleText('dim', logLine)
|
|
;
|
|
writeFileSync(process.stdout.fd, logLine);
|
|
}
|
|
};
|
|
// ==========================================
|
|
install();
|
|
|
|
//# sourceMappingURL=fast-set-immediate.external.js.map
|