@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/server/app-render/staged-rendering.js

@@ -3,8 +3,12 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    RENDER_STAGE_ADVANCE_ORDER: null,
     RenderStage: null,
-    StagedRenderingController: null
+    StagedRenderingController: null,
+    SyncIOMode: null,
+    getNextStage: null,
+    isAdvanceableRenderStage: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -13,57 +17,85 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    RENDER_STAGE_ADVANCE_ORDER: function() {
+        return RENDER_STAGE_ADVANCE_ORDER;
+    },
     RenderStage: function() {
         return RenderStage;
     },
     StagedRenderingController: function() {
         return StagedRenderingController;
+    },
+    SyncIOMode: function() {
+        return SyncIOMode;
+    },
+    getNextStage: function() {
+        return getNextStage;
+    },
+    isAdvanceableRenderStage: function() {
+        return isAdvanceableRenderStage;
     }
 });
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
 var RenderStage = /*#__PURE__*/ function(RenderStage) {
     RenderStage[RenderStage["Before"] = 1] = "Before";
-    RenderStage[RenderStage["EarlyStatic"] = 2] = "EarlyStatic";
-    RenderStage[RenderStage["Static"] = 3] = "Static";
-    RenderStage[RenderStage["EarlyRuntime"] = 4] = "EarlyRuntime";
-    RenderStage[RenderStage["Runtime"] = 5] = "Runtime";
-    RenderStage[RenderStage["Dynamic"] = 6] = "Dynamic";
-    RenderStage[RenderStage["Abandoned"] = 7] = "Abandoned";
+    //
+    RenderStage[RenderStage["ShellStatic"] = 11] = "ShellStatic";
+    RenderStage[RenderStage["Static"] = 13] = "Static";
+    //
+    RenderStage[RenderStage["ShellRuntime"] = 21] = "ShellRuntime";
+    RenderStage[RenderStage["Runtime"] = 23] = "Runtime";
+    //
+    RenderStage[RenderStage["Dynamic"] = 30] = "Dynamic";
+    //
+    RenderStage[RenderStage["Abandoned"] = 40] = "Abandoned";
     return RenderStage;
 }({});
+const RENDER_STAGE_ADVANCE_ORDER = [
+    11,
+    13,
+    21,
+    23,
+    30
+];
+function getNextStage(stage) {
+    return RENDER_STAGE_ADVANCE_ORDER[RENDER_STAGE_ADVANCE_ORDER.indexOf(stage) + 1];
+}
+function isAdvanceableRenderStage(stage) {
+    return 1 < stage && stage <= 30;
+}
+var SyncIOMode = /*#__PURE__*/ function(SyncIOMode) {
+    /** Sync IO does not error in any stage. */ SyncIOMode[SyncIOMode["Untracked"] = 1] = "Untracked";
+    /** Before `partialPrefetching`: Sync IO errors in static stages, and is allowed otherwise. */ SyncIOMode[SyncIOMode["AllowedInRuntimeOrDynamic"] = 2] = "AllowedInRuntimeOrDynamic";
+    /** After `partialPrefetching`: Sync IO errors in all stages other than dynamic. */ SyncIOMode[SyncIOMode["AllowedInDynamic"] = 3] = "AllowedInDynamic";
+    return SyncIOMode;
+}({});
 class StagedRenderingController {
-    constructor(abortSignal, abandonController, shouldTrackSyncIO){
-        this.abortSignal = abortSignal;
-        this.abandonController = abandonController;
-        this.shouldTrackSyncIO = shouldTrackSyncIO;
+    constructor({ abortSignal, abandonController, syncIO, finalStage }){
         this.currentStage = 1;
         this.syncInterruptReason = null;
-        this.staticStageEndTime = Infinity;
-        this.runtimeStageEndTime = Infinity;
-        this.staticStageListeners = [];
-        this.earlyRuntimeStageListeners = [];
-        this.runtimeStageListeners = [];
-        this.dynamicStageListeners = [];
-        this.staticStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
-        this.earlyRuntimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
-        this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
-        this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.triggers = {
+            [11]: createStageTrigger(),
+            [13]: createStageTrigger(),
+            //
+            [21]: createStageTrigger(),
+            [23]: createStageTrigger(),
+            //
+            [30]: createStageTrigger()
+        };
+        this.abortSignal = abortSignal;
+        this.abandonController = abandonController;
+        this.syncIOMode = syncIO;
+        this.finalStage = finalStage;
         if (abortSignal) {
             abortSignal.addEventListener('abort', ()=>{
                 // Reject all stage promises that haven't already been resolved.
-                // If a promise was already resolved via advanceStage, the reject
-                // is a no-op. The ignoreReject handler suppresses unhandled
-                // rejection warnings for promises that no one is awaiting.
+                // `cancelStageTrigger` is a noop if the trigger already resolved.
                 const { reason } = abortSignal;
-                this.staticStagePromise.promise.catch(ignoreReject);
-                this.staticStagePromise.reject(reason);
-                this.earlyRuntimeStagePromise.promise.catch(ignoreReject);
-                this.earlyRuntimeStagePromise.reject(reason);
-                this.runtimeStagePromise.promise.catch(ignoreReject);
-                this.runtimeStagePromise.reject(reason);
-                this.dynamicStagePromise.promise.catch(ignoreReject);
-                this.dynamicStagePromise.reject(reason);
+                for (const trigger of Object.values(this.triggers)){
+                    cancelStageTrigger(trigger, reason);
+                }
             }, {
                 once: true
             });
@@ -77,57 +109,47 @@ class StagedRenderingController {
         }
     }
     onStage(stage, callback) {
-        if (this.currentStage >= stage) {
-            callback();
-        } else if (stage === 3) {
-            this.staticStageListeners.push(callback);
-        } else if (stage === 4) {
-            this.earlyRuntimeStageListeners.push(callback);
-        } else if (stage === 5) {
-            this.runtimeStageListeners.push(callback);
-        } else if (stage === 6) {
-            this.dynamicStageListeners.push(callback);
-        } else {
-            // This should never happen
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
-                value: "E881",
-                enumerable: false,
-                configurable: true
-            });
-        }
+        addSyncTriggerListener(this.triggers[stage], callback);
     }
     shouldTrackSyncInterrupt() {
-        if (!this.shouldTrackSyncIO) {
+        if (this.syncIOMode === 1) {
             return false;
         }
         switch(this.currentStage){
             case 1:
                 // If we haven't started the render yet, it can't be interrupted.
                 return false;
-            case 2:
-            case 3:
+            case 11:
+            case 13:
                 return true;
-            case 4:
-                // EarlyRuntime is for runtime-prefetchable segments. Sync IO
-                // should error because it would abort a runtime prefetch.
-                return true;
-            case 5:
-                // Runtime is for non-prefetchable segments. Sync IO is fine there
-                // because in practice this segment will never be runtime prefetched
-                return false;
-            case 6:
-            case 7:
+            case 21:
+            case 23:
+                {
+                    switch(this.syncIOMode){
+                        case 2:
+                            {
+                                // Before `partialPrefetching`: Sync IO only errors in static stages.
+                                return false;
+                            }
+                        case 3:
+                            {
+                                return true;
+                            }
+                    }
+                // NOT a fallthrough, but eslint doesn't understand that
+                }
+            case 30:
+            case 40:
                 return false;
             default:
+                this.currentStage;
                 return false;
         }
     }
-    syncInterruptCurrentStageWithReason(reason) {
-        if (this.currentStage === 1) {
-            return;
-        }
-        // If the render has already been abandoned, there's nothing to interrupt.
-        if (this.currentStage === 7) {
+    /** Note: only call this if `shouldTrackSyncInterrupt()` returned true */ syncInterruptCurrentStageWithReason(reason) {
+        const { currentStage } = this;
+        if (currentStage === 1 || currentStage === 30 || currentStage === 40) {
+            // Not interruptible. Defensive noop.
             return;
         }
         // If Sync IO occurs during an abandonable render, we trigger the abandon.
@@ -142,41 +164,20 @@ class StagedRenderingController {
             // We don't release any more promises.
             // The caller is expected to abort the signal.
             this.syncInterruptReason = reason;
-            this.currentStage = 7;
+            this.currentStage = 40;
             return;
         }
         // If we're in a non-abandonable & non-abortable render,
         // we need to advance to the Dynamic stage and capture the interruption reason.
         // (in dev, this will be the restarted render)
-        switch(this.currentStage){
-            case 2:
-            case 3:
-            case 4:
-                {
-                    // EarlyRuntime is for runtime-prefetchable segments. Sync IO here
-                    // means the prefetch would be aborted too early.
-                    this.syncInterruptReason = reason;
-                    this.advanceStage(6);
-                    return;
-                }
-            case 5:
-                {
-                    // canSyncInterrupt returns false for Runtime, so we should
-                    // never get here. Defensive no-op.
-                    return;
-                }
-            case 6:
-            default:
-        }
+        this.syncInterruptReason = reason;
+        this.advanceStage(30);
     }
     getSyncInterruptReason() {
         return this.syncInterruptReason;
     }
-    getStaticStageEndTime() {
-        return this.staticStageEndTime;
-    }
-    getRuntimeStageEndTime() {
-        return this.runtimeStageEndTime;
+    getStageEndTime(stage) {
+        return this.triggers[getNextStage(stage)].triggeredAt ?? Infinity;
     }
     abandonRender() {
         // In staged rendering, only the initial render is abandonable.
@@ -189,129 +190,63 @@ class StagedRenderingController {
         // so we only want to unblock the next stage, not Dynamic, because
         // unblocking the dynamic stage would likely lead to wasted (uncached) IO.
         const { currentStage } = this;
-        switch(currentStage){
-            case 2:
-                {
-                    this.resolveStaticStage();
-                }
-            // intentional fallthrough
-            case 3:
-                {
-                    this.resolveEarlyRuntimeStage();
-                }
-            // intentional fallthrough
-            case 4:
-                {
-                    this.resolveRuntimeStage();
-                }
-            // intentional fallthrough
-            case 5:
-                {
-                    this.currentStage = 7;
-                    return;
-                }
-            case 6:
-            case 1:
-            case 7:
-                break;
-            default:
-                {
-                    currentStage;
-                }
+        if (currentStage === 1) {
+            throw Object.defineProperty(new _invarianterror.InvariantError("A render that hasn't started yet cannot be abandoned"), "__NEXT_ERROR_CODE", {
+                value: "E1300",
+                enumerable: false,
+                configurable: true
+            });
         }
-    }
-    advanceStage(stage) {
-        // If we're already at the target stage or beyond, do nothing.
-        // (this can happen e.g. if sync IO advanced us to the dynamic stage)
-        if (stage <= this.currentStage) {
+        if (currentStage === 30 || currentStage === 40) {
+            // We shouldn't ever trigger an abandon in these. Defensive noop.
             return;
         }
-        let currentStage = this.currentStage;
-        this.currentStage = stage;
-        if (currentStage < 3 && stage >= 3) {
-            this.resolveStaticStage();
-        }
-        if (currentStage < 4 && stage >= 4) {
-            this.resolveEarlyRuntimeStage();
+        // Resolve all stages after the current one, up to runtime (excluding dynamic)
+        const nextStageIx = RENDER_STAGE_ADVANCE_ORDER.indexOf(currentStage) + 1;
+        const dynamicStageIx = RENDER_STAGE_ADVANCE_ORDER.indexOf(30);
+        for(let i = nextStageIx; i < dynamicStageIx; i++){
+            this.resolveStage(RENDER_STAGE_ADVANCE_ORDER[i]);
         }
-        if (currentStage < 5 && stage >= 5) {
-            this.staticStageEndTime = performance.now() + performance.timeOrigin;
-            this.resolveRuntimeStage();
+        this.currentStage = 40;
+    }
+    advanceStage(targetStage) {
+        if (this.finalStage !== null && targetStage > this.finalStage) {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Attempted to advance to stage ${RenderStage[targetStage]} but the render is limited to ${RenderStage[this.finalStage]}`), "__NEXT_ERROR_CODE", {
+                value: "E1302",
+                enumerable: false,
+                configurable: true
+            });
         }
-        if (currentStage < 6 && stage >= 6) {
-            this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
-            this.resolveDynamicStage();
+        const { currentStage } = this;
+        if (currentStage === 30 || currentStage === 40) {
+            // Terminal stages, nowhere left to advance.
             return;
         }
-    }
-    /** Fire the `onStage` listeners for the static stage and unblock any promises waiting for it. */ resolveStaticStage() {
-        const staticListeners = this.staticStageListeners;
-        for(let i = 0; i < staticListeners.length; i++){
-            staticListeners[i]();
-        }
-        staticListeners.length = 0;
-        this.staticStagePromise.resolve();
-    }
-    /** Fire the `onStage` listeners for the early runtime stage and unblock any promises waiting for it. */ resolveEarlyRuntimeStage() {
-        const earlyRuntimeListeners = this.earlyRuntimeStageListeners;
-        for(let i = 0; i < earlyRuntimeListeners.length; i++){
-            earlyRuntimeListeners[i]();
+        // If we're already at the target stage or beyond, do nothing.
+        if (targetStage <= currentStage) {
+            return;
         }
-        earlyRuntimeListeners.length = 0;
-        this.earlyRuntimeStagePromise.resolve();
-    }
-    /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */ resolveRuntimeStage() {
-        const runtimeListeners = this.runtimeStageListeners;
-        for(let i = 0; i < runtimeListeners.length; i++){
-            runtimeListeners[i]();
+        this.currentStage = targetStage;
+        // Resolve all stages between the current stage and the target.
+        const nextStageIx = currentStage === 1 ? 0 : RENDER_STAGE_ADVANCE_ORDER.indexOf(currentStage) + 1;
+        const targetStageIx = RENDER_STAGE_ADVANCE_ORDER.indexOf(targetStage);
+        for(let i = nextStageIx; i <= targetStageIx; i++){
+            this.resolveStage(RENDER_STAGE_ADVANCE_ORDER[i]);
         }
-        runtimeListeners.length = 0;
-        this.runtimeStagePromise.resolve();
     }
-    /** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */ resolveDynamicStage() {
-        const dynamicListeners = this.dynamicStageListeners;
-        for(let i = 0; i < dynamicListeners.length; i++){
-            dynamicListeners[i]();
-        }
-        dynamicListeners.length = 0;
-        this.dynamicStagePromise.resolve();
+    resolveStage(stage) {
+        fireStageTrigger(this.triggers[stage]);
     }
     getStagePromise(stage) {
-        switch(stage){
-            case 3:
-                {
-                    return this.staticStagePromise.promise;
-                }
-            case 4:
-                {
-                    return this.earlyRuntimeStagePromise.promise;
-                }
-            case 5:
-                {
-                    return this.runtimeStagePromise.promise;
-                }
-            case 6:
-                {
-                    return this.dynamicStagePromise.promise;
-                }
-            default:
-                {
-                    stage;
-                    throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
-                        value: "E881",
-                        enumerable: false,
-                        configurable: true
-                    });
-                }
-        }
+        return this.triggers[stage].promise;
     }
     waitForStage(stage) {
         return this.getStagePromise(stage);
     }
     delayUntilStage(stage, displayName, resolvedValue) {
-        const ioTriggerPromise = this.getStagePromise(stage);
-        const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
-        // Analogously to `makeHangingPromise`, we might reject this promise if the signal is invoked.
+        const stagePromise = this.getStagePromise(stage);
+        const promise = process.env.NODE_ENV === 'development' ? makeDevtoolsIOPromiseFromIOTrigger(stagePromise, displayName, resolvedValue) : stagePromise.then(()=>resolvedValue);
+        // Analogously to `makeDynamicHangingPromise`, we might reject this promise if the signal is invoked.
         // (e.g. in the case where we don't want want the render to proceed to the dynamic stage and abort it).
         // We shouldn't consider this an unhandled rejection, so we attach a noop catch handler here to suppress this warning.
         if (this.abortSignal) {
@@ -339,5 +274,51 @@ function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValu
     }
     return promise;
 }
+function addSyncTriggerListener(trigger, listener) {
+    if (trigger.state === 'pending') {
+        trigger._listeners.push(listener);
+    } else {
+        listener();
+    }
+}
+function createStageTrigger() {
+    const { promise, resolve, reject } = (0, _promisewithresolvers.createPromiseWithResolvers)();
+    return {
+        state: 'pending',
+        triggeredAt: null,
+        promise,
+        _listeners: [],
+        _resolvePromise: resolve,
+        _rejectPromise: reject
+    };
+}
+function fireStageTrigger(trigger) {
+    if (trigger.state !== 'pending') {
+        return;
+    }
+    trigger.state = 'triggered';
+    trigger.triggeredAt = performance.now() + performance.timeOrigin;
+    try {
+        const { _listeners: listeners } = trigger;
+        for(let i = 0; i < listeners.length; i++){
+            listeners[i]();
+        }
+        listeners.length = 0;
+    } finally{
+        trigger._resolvePromise();
+    }
+}
+function cancelStageTrigger(trigger, reason) {
+    if (trigger.state !== 'pending') {
+        return;
+    }
+    trigger.state = 'cancelled';
+    // we didn't trigger, so don't save `triggeredAt`.
+    // We're not gonna fire the listeners, we may as well free them.
+    trigger._listeners.length = 0;
+    // Suppress unhandled rejection warnings for promises that no one is awaiting.
+    trigger.promise.catch(ignoreReject);
+    trigger._rejectPromise(reason);
+}
 
 //# sourceMappingURL=staged-rendering.js.map

package/dist/node_modules/next/dist/server/app-render/stale-time.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     StaleTimeIterable: null,
     createSelectStaleTime: null,
-    finishStaleTimeTracking: null,
     trackStaleTime: null
 });
 function _export(target, all) {
@@ -21,9 +20,6 @@ _export(exports, {
     createSelectStaleTime: function() {
         return createSelectStaleTime;
     },
-    finishStaleTimeTracking: function() {
-        return finishStaleTimeTracking;
-    },
     trackStaleTime: function() {
         return trackStaleTime;
     }
@@ -101,11 +97,5 @@ function trackStaleTime(store, iterable, selectStaleTime) {
         enumerable: true
     });
 }
-async function finishStaleTimeTracking(iterable) {
-    iterable.close();
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
-}
 
 //# sourceMappingURL=stale-time.js.map