@semiont/frontend 0.3.3 → 0.3.4

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

@@ -24,51 +24,68 @@ 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["Static"] = 2] = "Static";
-    RenderStage[RenderStage["Runtime"] = 3] = "Runtime";
-    RenderStage[RenderStage["Dynamic"] = 4] = "Dynamic";
-    RenderStage[RenderStage["Abandoned"] = 5] = "Abandoned";
+    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";
     return RenderStage;
 }({});
 class StagedRenderingController {
-    constructor(abortSignal = null, hasRuntimePrefetch){
+    constructor(abortSignal, abandonController, shouldTrackSyncIO){
         this.abortSignal = abortSignal;
-        this.hasRuntimePrefetch = hasRuntimePrefetch;
+        this.abandonController = abandonController;
+        this.shouldTrackSyncIO = shouldTrackSyncIO;
         this.currentStage = 1;
-        this.staticInterruptReason = null;
-        this.runtimeInterruptReason = null;
+        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.mayAbandon = false;
         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.
                 const { reason } = abortSignal;
-                if (this.currentStage < 3) {
-                    this.runtimeStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
-                    ;
-                    this.runtimeStagePromise.reject(reason);
-                }
-                if (this.currentStage < 4 || this.currentStage === 5) {
-                    this.dynamicStagePromise.promise.catch(ignoreReject) // avoid unhandled rejections
-                    ;
-                    this.dynamicStagePromise.reject(reason);
-                }
+                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);
+            }, {
+                once: true
+            });
+        }
+        if (abandonController) {
+            abandonController.signal.addEventListener('abort', ()=>{
+                this.abandonRender();
             }, {
                 once: true
             });
-            this.mayAbandon = true;
         }
     }
     onStage(stage, callback) {
         if (this.currentStage >= stage) {
             callback();
         } else if (stage === 3) {
-            this.runtimeStageListeners.push(callback);
+            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
@@ -79,57 +96,81 @@ class StagedRenderingController {
             });
         }
     }
-    canSyncInterrupt() {
-        // If we haven't started the render yet, it can't be interrupted.
-        if (this.currentStage === 1) {
+    shouldTrackSyncInterrupt() {
+        if (!this.shouldTrackSyncIO) {
             return false;
         }
-        const boundaryStage = this.hasRuntimePrefetch ? 4 : 3;
-        return this.currentStage < boundaryStage;
+        switch(this.currentStage){
+            case 1:
+                // If we haven't started the render yet, it can't be interrupted.
+                return false;
+            case 2:
+            case 3:
+                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:
+                return false;
+            default:
+                return false;
+        }
     }
     syncInterruptCurrentStageWithReason(reason) {
         if (this.currentStage === 1) {
             return;
         }
-        // If Sync IO occurs during the initial (abandonable) render, we'll retry it,
-        // so we want a slightly different flow.
-        // See the implementation of `abandonRenderImpl` for more explanation.
-        if (this.mayAbandon) {
-            return this.abandonRenderImpl();
+        // If the render has already been abandoned, there's nothing to interrupt.
+        if (this.currentStage === 7) {
+            return;
+        }
+        // If Sync IO occurs during an abandonable render, we trigger the abandon.
+        // The abandon listener will call abandonRender which advances through
+        // stages to let caches fill before marking as Abandoned.
+        if (this.abandonController) {
+            this.abandonController.abort();
+            return;
+        }
+        if (this.abortSignal) {
+            // If this is an abortable render, we capture the interruption reason and stop advancing.
+            // We don't release any more promises.
+            // The caller is expected to abort the signal.
+            this.syncInterruptReason = reason;
+            this.currentStage = 7;
+            return;
         }
-        // If we're in the final render, we cannot abandon it. We need to advance to the Dynamic stage
-        // and capture the interruption reason.
+        // 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:
                 {
-                    this.staticInterruptReason = reason;
-                    this.advanceStage(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 3:
+            case 5:
                 {
-                    // We only error for Sync IO in the runtime stage if the route
-                    // is configured to use runtime prefetching.
-                    // We do this to reflect the fact that during a runtime prefetch,
-                    // Sync IO aborts aborts the render.
-                    // Note that `canSyncInterrupt` should prevent us from getting here at all
-                    // if runtime prefetching isn't enabled.
-                    if (this.hasRuntimePrefetch) {
-                        this.runtimeInterruptReason = reason;
-                        this.advanceStage(4);
-                    }
+                    // canSyncInterrupt returns false for Runtime, so we should
+                    // never get here. Defensive no-op.
                     return;
                 }
-            case 4:
-            case 5:
+            case 6:
             default:
         }
     }
-    getStaticInterruptReason() {
-        return this.staticInterruptReason;
-    }
-    getRuntimeInterruptReason() {
-        return this.runtimeInterruptReason;
+    getSyncInterruptReason() {
+        return this.syncInterruptReason;
     }
     getStaticStageEndTime() {
         return this.staticStageEndTime;
@@ -138,16 +179,6 @@ class StagedRenderingController {
         return this.runtimeStageEndTime;
     }
     abandonRender() {
-        if (!this.mayAbandon) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('`abandonRender` called on a stage controller that cannot be abandoned.'), "__NEXT_ERROR_CODE", {
-                value: "E938",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        this.abandonRenderImpl();
-    }
-    abandonRenderImpl() {
         // In staged rendering, only the initial render is abandonable.
         // We can abandon the initial render if
         //   1. We notice a cache miss, and need to wait for caches to fill
@@ -155,24 +186,33 @@ class StagedRenderingController {
         //      (this might be a lazy intitialization of a module,
         //       so we still want to restart in this case and see if it still occurs)
         // In either case, we'll be doing another render after this one,
-        // so we only want to unblock the Runtime stage, not Dynamic, because
+        // 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.currentStage = 5;
-                    this.resolveRuntimeStage();
-                    return;
+                    this.resolveStaticStage();
                 }
+            // intentional fallthrough
             case 3:
                 {
-                    this.currentStage = 5;
-                    return;
+                    this.resolveEarlyRuntimeStage();
                 }
+            // intentional fallthrough
             case 4:
-            case 1:
+                {
+                    this.resolveRuntimeStage();
+                }
+            // intentional fallthrough
             case 5:
+                {
+                    this.currentStage = 7;
+                    return;
+                }
+            case 6:
+            case 1:
+            case 7:
                 break;
             default:
                 {
@@ -189,15 +229,37 @@ class StagedRenderingController {
         let currentStage = this.currentStage;
         this.currentStage = stage;
         if (currentStage < 3 && stage >= 3) {
+            this.resolveStaticStage();
+        }
+        if (currentStage < 4 && stage >= 4) {
+            this.resolveEarlyRuntimeStage();
+        }
+        if (currentStage < 5 && stage >= 5) {
             this.staticStageEndTime = performance.now() + performance.timeOrigin;
             this.resolveRuntimeStage();
         }
-        if (currentStage < 4 && stage >= 4) {
+        if (currentStage < 6 && stage >= 6) {
             this.runtimeStageEndTime = performance.now() + performance.timeOrigin;
             this.resolveDynamicStage();
             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]();
+        }
+        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++){
@@ -218,9 +280,17 @@ class StagedRenderingController {
         switch(stage){
             case 3:
                 {
-                    return this.runtimeStagePromise.promise;
+                    return this.staticStagePromise.promise;
                 }
             case 4:
+                {
+                    return this.earlyRuntimeStagePromise.promise;
+                }
+            case 5:
+                {
+                    return this.runtimeStagePromise.promise;
+                }
+            case 6:
                 {
                     return this.dynamicStagePromise.promise;
                 }

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    StaleTimeIterable: null,
+    createSelectStaleTime: null,
+    finishStaleTimeTracking: null,
+    trackStaleTime: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    StaleTimeIterable: function() {
+        return StaleTimeIterable;
+    },
+    createSelectStaleTime: function() {
+        return createSelectStaleTime;
+    },
+    finishStaleTimeTracking: function() {
+        return finishStaleTimeTracking;
+    },
+    trackStaleTime: function() {
+        return trackStaleTime;
+    }
+});
+const _constants = require("../../lib/constants");
+class StaleTimeIterable {
+    update(value) {
+        if (this._done) return;
+        this.currentValue = value;
+        if (this._resolve) {
+            this._resolve({
+                value,
+                done: false
+            });
+            this._resolve = null;
+        } else {
+            this._buffer.push(value);
+        }
+    }
+    close() {
+        if (this._done) return;
+        this._done = true;
+        if (this._resolve) {
+            this._resolve({
+                value: undefined,
+                done: true
+            });
+            this._resolve = null;
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: ()=>{
+                if (this._buffer.length > 0) {
+                    return Promise.resolve({
+                        value: this._buffer.shift(),
+                        done: false
+                    });
+                }
+                if (this._done) {
+                    return Promise.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                }
+                return new Promise((resolve)=>{
+                    this._resolve = resolve;
+                });
+            }
+        };
+    }
+    constructor(){
+        this._resolve = null;
+        this._done = false;
+        this._buffer = [];
+        /** The last value passed to `update()`. */ this.currentValue = 0;
+    }
+}
+function createSelectStaleTime(experimental) {
+    return (stale)=>{
+        var _experimental_staleTimes;
+        return stale === _constants.INFINITE_CACHE && typeof ((_experimental_staleTimes = experimental.staleTimes) == null ? void 0 : _experimental_staleTimes.static) === 'number' ? experimental.staleTimes.static : stale;
+    };
+}
+function trackStaleTime(store, iterable, selectStaleTime) {
+    let _stale = store.stale;
+    iterable.update(selectStaleTime(_stale));
+    Object.defineProperty(store, 'stale', {
+        get: ()=>_stale,
+        set: (value)=>{
+            _stale = value;
+            iterable.update(selectStaleTime(value));
+        },
+        configurable: true,
+        enumerable: true
+    });
+}
+async function finishStaleTimeTracking(iterable) {
+    iterable.close();
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+}
+
+//# sourceMappingURL=stale-time.js.map

package/standalone/node_modules/next/dist/server/app-render/stream-ops.js

@@ -0,0 +1,106 @@
+/**
+ * Compile-time switcher for stream operations.
+ *
+ * PR2: Simple re-export from the web implementation.
+ * A future change will add a conditional branch for node streams.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    chainStreams: null,
+    continueDynamicHTMLResume: null,
+    continueDynamicPrerender: null,
+    continueFizzStream: null,
+    continueStaticFallbackPrerender: null,
+    continueStaticPrerender: null,
+    createDocumentClosingStream: null,
+    createInlinedDataStream: null,
+    createOnHeadersCallback: null,
+    createPendingStream: null,
+    getClientPrerender: null,
+    getServerPrerender: null,
+    nodeReadableToWeb: null,
+    pipeRuntimePrefetchTransform: null,
+    processPrelude: null,
+    renderToFizzStream: null,
+    renderToFlightStream: null,
+    resumeAndAbort: null,
+    resumeToFizzStream: null,
+    streamToBuffer: null,
+    streamToString: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    chainStreams: function() {
+        return _streamopsweb.chainStreams;
+    },
+    continueDynamicHTMLResume: function() {
+        return _streamopsweb.continueDynamicHTMLResume;
+    },
+    continueDynamicPrerender: function() {
+        return _streamopsweb.continueDynamicPrerender;
+    },
+    continueFizzStream: function() {
+        return _streamopsweb.continueFizzStream;
+    },
+    continueStaticFallbackPrerender: function() {
+        return _streamopsweb.continueStaticFallbackPrerender;
+    },
+    continueStaticPrerender: function() {
+        return _streamopsweb.continueStaticPrerender;
+    },
+    createDocumentClosingStream: function() {
+        return _streamopsweb.createDocumentClosingStream;
+    },
+    createInlinedDataStream: function() {
+        return _streamopsweb.createInlinedDataStream;
+    },
+    createOnHeadersCallback: function() {
+        return _streamopsweb.createOnHeadersCallback;
+    },
+    createPendingStream: function() {
+        return _streamopsweb.createPendingStream;
+    },
+    getClientPrerender: function() {
+        return _streamopsweb.getClientPrerender;
+    },
+    getServerPrerender: function() {
+        return _streamopsweb.getServerPrerender;
+    },
+    nodeReadableToWeb: function() {
+        return _streamopsweb.nodeReadableToWeb;
+    },
+    pipeRuntimePrefetchTransform: function() {
+        return _streamopsweb.pipeRuntimePrefetchTransform;
+    },
+    processPrelude: function() {
+        return _streamopsweb.processPrelude;
+    },
+    renderToFizzStream: function() {
+        return _streamopsweb.renderToFizzStream;
+    },
+    renderToFlightStream: function() {
+        return _streamopsweb.renderToFlightStream;
+    },
+    resumeAndAbort: function() {
+        return _streamopsweb.resumeAndAbort;
+    },
+    resumeToFizzStream: function() {
+        return _streamopsweb.resumeToFizzStream;
+    },
+    streamToBuffer: function() {
+        return _streamopsweb.streamToBuffer;
+    },
+    streamToString: function() {
+        return _streamopsweb.streamToString;
+    }
+});
+const _streamopsweb = require("./stream-ops.web");
+
+//# sourceMappingURL=stream-ops.js.map