@semiont/frontend 0.3.3 → 0.3.4

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

@@ -0,0 +1,163 @@
+/**
+ * Web stream operations for the rendering pipeline.
+ * Loaded by stream-ops.ts (re-export in this PR, conditional switcher later).
+ */ "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 _nodewebstreamshelper.chainStreams;
+    },
+    continueDynamicHTMLResume: function() {
+        return _nodewebstreamshelper.continueDynamicHTMLResume;
+    },
+    continueDynamicPrerender: function() {
+        return _nodewebstreamshelper.continueDynamicPrerender;
+    },
+    continueFizzStream: function() {
+        return continueFizzStream;
+    },
+    continueStaticFallbackPrerender: function() {
+        return _nodewebstreamshelper.continueStaticFallbackPrerender;
+    },
+    continueStaticPrerender: function() {
+        return _nodewebstreamshelper.continueStaticPrerender;
+    },
+    createDocumentClosingStream: function() {
+        return _nodewebstreamshelper.createDocumentClosingStream;
+    },
+    createInlinedDataStream: function() {
+        return createInlinedDataStream;
+    },
+    createOnHeadersCallback: function() {
+        return createOnHeadersCallback;
+    },
+    createPendingStream: function() {
+        return createPendingStream;
+    },
+    getClientPrerender: function() {
+        return getClientPrerender;
+    },
+    getServerPrerender: function() {
+        return getServerPrerender;
+    },
+    nodeReadableToWeb: function() {
+        return nodeReadableToWeb;
+    },
+    pipeRuntimePrefetchTransform: function() {
+        return pipeRuntimePrefetchTransform;
+    },
+    processPrelude: function() {
+        return _apprenderprerenderutils.processPrelude;
+    },
+    renderToFizzStream: function() {
+        return renderToFizzStream;
+    },
+    renderToFlightStream: function() {
+        return renderToFlightStream;
+    },
+    resumeAndAbort: function() {
+        return resumeAndAbort;
+    },
+    resumeToFizzStream: function() {
+        return resumeToFizzStream;
+    },
+    streamToBuffer: function() {
+        return _nodewebstreamshelper.streamToBuffer;
+    },
+    streamToString: function() {
+        return streamToString;
+    }
+});
+const _server = require("react-dom/server");
+const _static = require("react-dom/static");
+const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
+const _useflightresponse = require("./use-flight-response");
+const _apprenderprerenderutils = require("./app-render-prerender-utils");
+function continueFizzStream(renderStream, opts) {
+    return (0, _nodewebstreamshelper.continueFizzStream)(renderStream, opts);
+}
+const nodeReadableToWeb = undefined;
+function createInlinedDataStream(source, nonce, formState) {
+    return (0, _useflightresponse.createInlinedDataReadableStream)(source, nonce, formState);
+}
+function createPendingStream() {
+    return new ReadableStream();
+}
+function createOnHeadersCallback(appendHeader) {
+    return (headers)=>{
+        headers.forEach((value, key)=>{
+            appendHeader(key, value);
+        });
+    };
+}
+async function resumeAndAbort(element, postponed, opts) {
+    return (0, _server.resume)(element, postponed, opts);
+}
+function renderToFlightStream(ComponentMod, payload, clientModules, opts) {
+    return ComponentMod.renderToReadableStream(payload, clientModules, opts);
+}
+async function streamToString(stream) {
+    return (0, _nodewebstreamshelper.streamToString)(stream);
+}
+async function renderToFizzStream(element, streamOptions) {
+    const stream = await (0, _nodewebstreamshelper.renderToInitialFizzStream)({
+        ReactDOMServer: {
+            renderToReadableStream: _server.renderToReadableStream
+        },
+        element,
+        streamOptions
+    });
+    return {
+        stream,
+        allReady: stream.allReady,
+        abort: undefined
+    };
+}
+async function resumeToFizzStream(element, postponedState, streamOptions) {
+    const stream = await (0, _server.resume)(element, postponedState, streamOptions);
+    return {
+        stream,
+        allReady: stream.allReady,
+        abort: undefined
+    };
+}
+function getServerPrerender(ComponentMod) {
+    return ComponentMod.prerender;
+}
+const getClientPrerender = _static.prerender;
+function pipeRuntimePrefetchTransform(stream, sentinel, isPartial, staleTime) {
+    return stream.pipeThrough((0, _nodewebstreamshelper.createRuntimePrefetchTransformStream)(sentinel, isPartial, staleTime));
+}
+
+//# sourceMappingURL=stream-ops.web.js.map

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

@@ -40,20 +40,26 @@ const segmentSchema = _superstruct.default.union([
         // need to store it as that representation.
         _superstruct.default.string(),
         // Dynamic param type
-        dynamicParamTypesSchema
+        dynamicParamTypesSchema,
+        // Static siblings at the same URL level. Used by the client router to
+        // determine if a prefetch can be reused when navigating to a static
+        // sibling of a dynamic route. null means siblings are unknown.
+        _superstruct.default.nullable(_superstruct.default.array(_superstruct.default.string()))
     ])
 ]);
 const flightRouterStateSchema = _superstruct.default.tuple([
     segmentSchema,
     _superstruct.default.record(_superstruct.default.string(), _superstruct.default.lazy(()=>flightRouterStateSchema)),
-    _superstruct.default.optional(_superstruct.default.nullable(_superstruct.default.string())),
+    _superstruct.default.optional(_superstruct.default.nullable(_superstruct.default.tuple([
+        _superstruct.default.string(),
+        _superstruct.default.string()
+    ]))),
     _superstruct.default.optional(_superstruct.default.nullable(_superstruct.default.union([
         _superstruct.default.literal('refetch'),
-        _superstruct.default.literal('refresh'),
         _superstruct.default.literal('inside-shared-layout'),
         _superstruct.default.literal('metadata-only')
     ]))),
-    _superstruct.default.optional(_superstruct.default.boolean())
+    _superstruct.default.optional(_superstruct.default.number())
 ]);
 
 //# sourceMappingURL=types.js.map

package/standalone/node_modules/next/dist/server/app-render/use-flight-response.js

@@ -109,6 +109,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
         }
         switch(workUnitStore.type){
             case 'prerender-client':
+            case 'validation-client':
                 const responseOnNextTick = new Promise((resolve)=>{
                     process.nextTick(()=>{
                         resolve(newResponse);
@@ -124,6 +125,7 @@ function getFlightStream(flightStream, debugStream, debugEndTime, nonce) {
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
+            case 'generate-static-params':
                 break;
             default:
                 workUnitStore;
@@ -200,7 +202,7 @@ function writeFlightDataInstruction(controller, scriptStart, chunk) {
         // Instead let's inline it in base64.
         // Credits to Devon Govett (devongovett) for the technique.
         // https://github.com/devongovett/rsc-html-stream
-        const base64 = btoa(String.fromCodePoint(...chunk));
+        const base64 = typeof Buffer !== 'undefined' ? Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).toString('base64') : btoa(String.fromCodePoint(...chunk));
         htmlInlinedData = (0, _htmlescape.htmlEscapeJsonString)(JSON.stringify([
             INLINE_FLIGHT_PAYLOAD_BINARY,
             base64

package/standalone/node_modules/next/dist/server/app-render/vary-params.js

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    accumulateRootVaryParam: null,
+    accumulateVaryParam: null,
+    createResponseVaryParamsAccumulator: null,
+    createVaryParamsAccumulator: null,
+    createVaryingParams: null,
+    createVaryingSearchParams: null,
+    emptyVaryParamsAccumulator: null,
+    finishAccumulatingVaryParams: null,
+    getMetadataVaryParamsAccumulator: null,
+    getMetadataVaryParamsThenable: null,
+    getRootParamsVaryParamsAccumulator: null,
+    getVaryParamsThenable: null,
+    getViewportVaryParamsAccumulator: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    accumulateRootVaryParam: function() {
+        return accumulateRootVaryParam;
+    },
+    accumulateVaryParam: function() {
+        return accumulateVaryParam;
+    },
+    createResponseVaryParamsAccumulator: function() {
+        return createResponseVaryParamsAccumulator;
+    },
+    createVaryParamsAccumulator: function() {
+        return createVaryParamsAccumulator;
+    },
+    createVaryingParams: function() {
+        return createVaryingParams;
+    },
+    createVaryingSearchParams: function() {
+        return createVaryingSearchParams;
+    },
+    emptyVaryParamsAccumulator: function() {
+        return emptyVaryParamsAccumulator;
+    },
+    finishAccumulatingVaryParams: function() {
+        return finishAccumulatingVaryParams;
+    },
+    getMetadataVaryParamsAccumulator: function() {
+        return getMetadataVaryParamsAccumulator;
+    },
+    getMetadataVaryParamsThenable: function() {
+        return getMetadataVaryParamsThenable;
+    },
+    getRootParamsVaryParamsAccumulator: function() {
+        return getRootParamsVaryParamsAccumulator;
+    },
+    getVaryParamsThenable: function() {
+        return getVaryParamsThenable;
+    },
+    getViewportVaryParamsAccumulator: function() {
+        return getViewportVaryParamsAccumulator;
+    }
+});
+const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
+function createSegmentVaryParamsAccumulator() {
+    const accumulator = {
+        varyParams: new Set(),
+        status: 'pending',
+        value: new Set(),
+        then (onfulfilled) {
+            if (onfulfilled) {
+                if (accumulator.status === 'pending') {
+                    accumulator.resolvers.push(onfulfilled);
+                } else {
+                    onfulfilled(accumulator.value);
+                }
+            }
+        },
+        resolvers: []
+    };
+    return accumulator;
+}
+/**
+ * A singleton accumulator that's already resolved to an empty Set. Use this for
+ * segments where we know upfront that no params will be accessed, such as
+ * client components or segments without user code.
+ *
+ * Benefits:
+ * - No need to accumulate or resolve later
+ * - Resilient: resolves correctly even if other tracking fails
+ * - Memory efficient: reuses the same object
+ */ const emptySet = new Set();
+const emptyVaryParamsAccumulator = {
+    varyParams: emptySet,
+    status: 'fulfilled',
+    value: emptySet,
+    then (onfulfilled) {
+        if (onfulfilled) {
+            onfulfilled(emptySet);
+        }
+    },
+    resolvers: []
+};
+function createResponseVaryParamsAccumulator() {
+    // Create the head and rootParams accumulators as top-level fields.
+    // Segment accumulators are added to the segments set as they are created.
+    const head = createSegmentVaryParamsAccumulator();
+    const rootParams = createSegmentVaryParamsAccumulator();
+    const segments = new Set();
+    return {
+        head,
+        rootParams,
+        segments
+    };
+}
+function createVaryParamsAccumulator() {
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-runtime':
+                {
+                    const responseAccumulator = workUnitStore.varyParamsAccumulator;
+                    if (responseAccumulator !== null) {
+                        const accumulator = createSegmentVaryParamsAccumulator();
+                        responseAccumulator.segments.add(accumulator);
+                        return accumulator;
+                    }
+                    return null;
+                }
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+            case 'request':
+            case 'cache':
+            case 'private-cache':
+            case 'prerender-client':
+            case 'validation-client':
+            case 'unstable-cache':
+            case 'generate-static-params':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    return null;
+}
+function getMetadataVaryParamsAccumulator() {
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-runtime':
+                {
+                    const responseAccumulator = workUnitStore.varyParamsAccumulator;
+                    if (responseAccumulator !== null) {
+                        return responseAccumulator.head;
+                    }
+                    return null;
+                }
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+            case 'request':
+            case 'cache':
+            case 'private-cache':
+            case 'prerender-client':
+            case 'validation-client':
+            case 'unstable-cache':
+            case 'generate-static-params':
+                return null;
+            default:
+                workUnitStore;
+        }
+    }
+    return null;
+}
+function getVaryParamsThenable(accumulator) {
+    return accumulator;
+}
+function getMetadataVaryParamsThenable() {
+    const accumulator = getMetadataVaryParamsAccumulator();
+    if (accumulator !== null) {
+        return getVaryParamsThenable(accumulator);
+    }
+    return null;
+}
+const getViewportVaryParamsAccumulator = getMetadataVaryParamsAccumulator;
+function getRootParamsVaryParamsAccumulator() {
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-runtime':
+                {
+                    const responseAccumulator = workUnitStore.varyParamsAccumulator;
+                    if (responseAccumulator !== null) {
+                        return responseAccumulator.rootParams;
+                    }
+                    return null;
+                }
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+            case 'request':
+            case 'cache':
+            case 'private-cache':
+            case 'prerender-client':
+            case 'validation-client':
+            case 'unstable-cache':
+            case 'generate-static-params':
+                return null;
+            default:
+                workUnitStore;
+        }
+    }
+    return null;
+}
+function accumulateVaryParam(accumulator, paramName) {
+    accumulator.varyParams.add(paramName);
+}
+function accumulateRootVaryParam(paramName) {
+    const rootParamsAccumulator = getRootParamsVaryParamsAccumulator();
+    if (rootParamsAccumulator !== null) {
+        accumulateVaryParam(rootParamsAccumulator, paramName);
+    }
+}
+function createVaryingParams(accumulator, originalParamsObject, optionalCatchAllParamName) {
+    if (optionalCatchAllParamName !== null) {
+        // When there's an optional catch-all param with no value (e.g.,
+        // [[...slug]] at /), the param doesn't exist as a property on the params
+        // object. Use a Proxy to track all param access — both existing params
+        // and the missing optional param — including enumeration patterns like
+        // Object.keys(), spread, for...in, and `in` checks.
+        return new Proxy(originalParamsObject, {
+            get (target, prop, receiver) {
+                if (typeof prop === 'string') {
+                    if (prop === optionalCatchAllParamName || Object.prototype.hasOwnProperty.call(target, prop)) {
+                        accumulateVaryParam(accumulator, prop);
+                    }
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+            has (target, prop) {
+                if (prop === optionalCatchAllParamName) {
+                    accumulateVaryParam(accumulator, optionalCatchAllParamName);
+                }
+                return Reflect.has(target, prop);
+            },
+            ownKeys (target) {
+                // Enumerating the params object means the user's code may depend on
+                // which params are present, so conservatively track the optional
+                // param as accessed.
+                accumulateVaryParam(accumulator, optionalCatchAllParamName);
+                return Reflect.ownKeys(target);
+            }
+        });
+    }
+    // When there's no optional catch-all, all params exist as properties on the
+    // object, so we can use defineProperty getters instead of a Proxy. This is
+    // faster because the engine can optimize property access on regular objects
+    // more aggressively than Proxy trap calls.
+    const underlyingParamsWithVarying = {};
+    for(const paramName in originalParamsObject){
+        Object.defineProperty(underlyingParamsWithVarying, paramName, {
+            get () {
+                accumulateVaryParam(accumulator, paramName);
+                return originalParamsObject[paramName];
+            },
+            enumerable: true
+        });
+    }
+    return underlyingParamsWithVarying;
+}
+function createVaryingSearchParams(accumulator, originalSearchParamsObject) {
+    const underlyingSearchParamsWithVarying = {};
+    for(const searchParamName in originalSearchParamsObject){
+        Object.defineProperty(underlyingSearchParamsWithVarying, searchParamName, {
+            get () {
+                // TODO: Unlike path params, we don't vary track each search param
+                // individually. The entire search string is treated as a single param.
+                // This may change in the future.
+                accumulateVaryParam(accumulator, '?');
+                return originalSearchParamsObject[searchParamName];
+            },
+            enumerable: true
+        });
+    }
+    return underlyingSearchParamsWithVarying;
+}
+async function finishAccumulatingVaryParams(responseAccumulator) {
+    const rootVaryParams = responseAccumulator.rootParams.varyParams;
+    // Resolve head
+    finishSegmentAccumulator(responseAccumulator.head, rootVaryParams);
+    // Resolve each segment
+    for (const segmentAccumulator of responseAccumulator.segments){
+        finishSegmentAccumulator(segmentAccumulator, rootVaryParams);
+    }
+    // Now that the thenables are resolved, Flight should be able to flush the
+    // vary params into the response stream. This work gets scheduled internally
+    // by Flight using a microtask as soon as we notify the thenable listeners.
+    //
+    // We need to ensure that Flight's pending queues are emptied before this
+    // function returns; the caller will abort the prerender immediately after.
+    // We can't use a macrotask, because that would allow dynamic IO to sneak
+    // into the response. So we use microtasks instead.
+    //
+    // The exact number of awaits here isn't important (indeed, one seems to be
+    // sufficient, at the time of writing), as long as we wait enough ticks for
+    // Flight to finish writing the response.
+    //
+    // Anything that remains in Flight's internal queue after these awaits must
+    // be actual dynamic IO, not caused by pending vary params tasks. In other
+    // words, failing to do this would cause us to treat a fully static prerender
+    // as if it were partially dynamic.
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+}
+function finishSegmentAccumulator(accumulator, rootVaryParams) {
+    if (accumulator.status !== 'pending') {
+        return;
+    }
+    const merged = new Set(accumulator.varyParams);
+    for (const param of rootVaryParams){
+        merged.add(param);
+    }
+    accumulator.value = merged;
+    accumulator.status = 'fulfilled';
+    for (const resolver of accumulator.resolvers){
+        resolver(merged);
+    }
+    accumulator.resolvers = [];
+}
+
+//# sourceMappingURL=vary-params.js.map