vike 0.4.179 → 0.4.180

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -105,6 +105,9 @@ const configDefinitionsBuiltIn = {
     cacheControl: {
         env: { server: true }
     },
+    injectScriptsAt: {
+        env: { server: true }
+    },
     name: {
         env: { config: true }
     },

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -9,13 +9,17 @@ const serializePageContextClientSide_js_1 = require("../serializePageContextClie
 const sanitizeJson_js_1 = require("./sanitizeJson.js");
 const inferHtmlTags_js_1 = require("./inferHtmlTags.js");
 const mergeScriptTags_js_1 = require("./mergeScriptTags.js");
+const helpers_js_1 = require("../../../../shared/page-configs/helpers.js");
+const getConfigValue_js_1 = require("../../../../shared/page-configs/getConfigValue.js");
 const globalContext_js_1 = require("../../globalContext.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const getConfigDefinedAt_js_1 = require("../../../../shared/page-configs/getConfigDefinedAt.js");
 const stamp = '__injectFilterEntry';
-function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript) {
+function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
     (0, utils_js_1.assert)([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
     const { isProduction } = (0, globalContext_js_1.getGlobalContext)();
+    const injectScriptsAt = getInjectScriptsAt(pageContext._pageId, pageContext._pageConfigs);
     const injectFilterEntries = pageAssets
         .filter((asset) => {
         if (asset.isEntry && asset.assetType === 'script') {
@@ -78,28 +82,39 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
     // ==========
     // JavaScript
     // ==========
-    // In order to avoid the race-condition depicted in https://github.com/vikejs/vike/issues/567
-    // 1. <script id="vike_pageContext" type="application/json"> must appear before the entry <script> (which loads Vike's client runtime).
-    // 2. <script id="vike_pageContext" type="application/json"> can't be async nor defer.
-    // Additionally:
-    // 3. the entry <script> can't be defer, otherwise progressive hydration while SSR streaming won't work.
-    // 4. the entry <script> should be towards the end of the HTML as performance-wise it's more interesting to parse
-    //    <div id="page-view"> before running the entry <script> which initiates the hydration.
-    // See https://github.com/vikejs/vike/pull/1271
+    // - The pageContext JSON should be fully sent before Vike's client runtime starts executing.
+    //   - Otherwise, race condition "SyntaxError: Unterminated string in JSON": https://github.com/vikejs/vike/issues/567
+    //   - <script id="vike_pageContext" type="application/json"> must appear before the entry <script> (which loads Vike's client runtime).
+    //   - <script id="vike_pageContext" type="application/json"> can't be async nor defer.
+    // - The entry <script> can't be defer, otherwise progressive hydration while SSR streaming won't work.
+    // - The entry <script> should be towards the end of the HTML as performance-wise it's more interesting to parse <div id="page-view"> before running the entry <script> which initiates the hydration.
+    //   - But with HTML streaming, in order to support [Progressive Rendering](https://vike.dev/streaming#progressive-rendering), the entry <script> should be injected early instead.
     const positionJavaScriptEntry = (() => {
+        if (injectScriptsAt !== null) {
+            if (pageContext._pageContextPromise) {
+                (0, utils_js_1.assertWarning)(injectScriptsAt === 'HTML_END' || !isStream, `You're setting injectScriptsAt to ${picocolors_1.default.code(JSON.stringify(injectScriptsAt))} while using HTML streaming with a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) which is contradictory: the pageContext promise is skipped.`, { onlyOnce: true });
+            }
+            return injectScriptsAt;
+        }
         if (pageContext._pageContextPromise) {
-            (0, utils_js_1.assertWarning)(!streamFromReactStreamingPackage, "[getHtmlTags()] We recommend against using streaming and a pageContext promise at the same time, because progressive hydration won't work.", { onlyOnce: true });
-            // If there is a pageContext._pageContextPromise (which is resolved after the stream has ended) then the pageContext JSON data needs to await for it: https://vike.dev/streaming#initial-data-after-stream-end
+            // - If there is a pageContext._pageContextPromise then <script id="vike_pageContext" type="application/json"> needs to await for it.
+            // - pageContext._pageContextPromise is typically resolved only after the page's components are rendered and the stream ended.
+            // - https://vike.dev/streaming#initial-data-after-stream-end
             return 'HTML_END';
         }
         if (streamFromReactStreamingPackage && !streamFromReactStreamingPackage.hasStreamEnded()) {
-            // If there is a stream then, in order to support progressive hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary
+            // If there is a stream then, in order to support progressive hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary.
             return 'STREAM';
         }
-        else {
-            return 'HTML_END';
-        }
+        return 'HTML_END';
     })();
+    if (pageContext._pageContextPromise && streamFromReactStreamingPackage) {
+        // - Should we show this warning for Solid as well? Solid seems to also support progressive rendering.
+        //   - https://github.com/vikejs/vike-solid/issues/95
+        // - Vue doesn't seem to support progressive rendering yet.
+        //   - https://github.com/vikejs/vike-vue/issues/85
+        (0, utils_js_1.assertWarning)(false, "We recommend against using HTML streaming and a pageContext promise (https://vike.dev/streaming#initial-data-after-stream-end) at the same time, because progressive hydration (https://vike.dev/streaming#progressive-rendering) won't work.", { onlyOnce: true });
+    }
     // <script id="vike_pageContext" type="application/json">
     if (!isHtmlOnly) {
         htmlTags.push({
@@ -195,3 +210,19 @@ function checkForWarnings(injectFilterEntries) {
         }
     });
 }
+function getInjectScriptsAt(pageId, pageConfigs) {
+    if (pageConfigs.length === 0)
+        return null; // only support V1 design
+    const pageConfig = (0, helpers_js_1.getPageConfig)(pageId, pageConfigs);
+    const configValue = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'injectScriptsAt');
+    if (!configValue)
+        return null;
+    const injectScriptsAt = configValue.value;
+    (0, utils_js_1.assert)(configValue.definedAtData);
+    const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', 'injectScriptsAt', configValue.definedAtData);
+    (0, utils_js_1.assertUsage)(injectScriptsAt === null ||
+        injectScriptsAt === 'HTML_BEGIN' ||
+        injectScriptsAt === 'HTML_END' ||
+        injectScriptsAt === 'STREAM', `${configDefinedAt} has an invalid value`);
+    return injectScriptsAt;
+}

package/dist/cjs/node/runtime/html/injectAssets/injectHtmlTags.js

@@ -1,7 +1,7 @@
 "use strict";
 // Unit tests at ./injectHtmlTags.spec.ts
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.injectAtClosingTag = exports.injectAtOpeningTag = exports.createHtmlHeadIfMissing = exports.injectHtmlTagsUsingStream = exports.injectHtmlTags = void 0;
+exports.injectAtClosingTag = exports.injectAtOpeningTag = exports.joinHtmlTags = exports.createHtmlHeadIfMissing = exports.injectHtmlTagsUsingStream = exports.injectHtmlTags = void 0;
 const utils_js_1 = require("../../utils.js");
 function injectHtmlTags(htmlString, htmlTags, position) {
     const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === position));
@@ -11,10 +11,10 @@ function injectHtmlTags(htmlString, htmlTags, position) {
     return htmlString;
 }
 exports.injectHtmlTags = injectHtmlTags;
+// Is it worth it? Should we remove this? https://github.com/vikejs/vike/pull/1740#issuecomment-2230540892
 function injectHtmlTagsUsingStream(htmlTags, streamFromReactStreamingPackage) {
     const htmlFragment = joinHtmlTags(htmlTags.filter((h) => h.position === 'STREAM'));
     if (htmlFragment) {
-        (0, utils_js_1.assert)(streamFromReactStreamingPackage);
         (0, utils_js_1.assert)(!streamFromReactStreamingPackage.hasStreamEnded());
         streamFromReactStreamingPackage.injectToStream(htmlFragment, { flush: true });
     }
@@ -24,6 +24,7 @@ function joinHtmlTags(htmlTags) {
     const htmlFragment = htmlTags.map((h) => resolveHtmlTag(h.htmlTag)).join('');
     return htmlFragment;
 }
+exports.joinHtmlTags = joinHtmlTags;
 function injectHtmlFragment(position, htmlFragment, htmlString) {
     if (position === 'HTML_BEGIN') {
         {

package/dist/cjs/node/runtime/html/injectAssets.js

@@ -9,7 +9,7 @@ const getViteDevScript_js_1 = require("./injectAssets/getViteDevScript.js");
 async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
     const pageAssets = await pageContext.__getPageAssets();
     const viteDevScript = await (0, getViteDevScript_js_1.getViteDevScript)();
-    const htmlTags = (0, getHtmlTags_js_1.getHtmlTags)(pageContext, null, injectFilter, pageAssets, viteDevScript);
+    const htmlTags = (0, getHtmlTags_js_1.getHtmlTags)(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
     let htmlString = htmlPartsToString(htmlParts, pageAssets);
     htmlString = injectToHtmlBegin(htmlString, htmlTags);
     htmlString = injectToHtmlEnd(htmlString, htmlTags);
@@ -21,17 +21,32 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
     let htmlTags;
     return {
         injectAtStreamBegin,
+        injectAtStreamAfterFirstChunk,
         injectAtStreamEnd
     };
     async function injectAtStreamBegin(htmlPartsBegin) {
         const pageAssets = await pageContext.__getPageAssets();
         const viteDevScript = await (0, getViteDevScript_js_1.getViteDevScript)();
-        htmlTags = (0, getHtmlTags_js_1.getHtmlTags)(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript);
+        htmlTags = (0, getHtmlTags_js_1.getHtmlTags)(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
         let htmlBegin = htmlPartsToString(htmlPartsBegin, pageAssets);
         htmlBegin = injectToHtmlBegin(htmlBegin, htmlTags);
-        (0, injectHtmlTags_js_1.injectHtmlTagsUsingStream)(htmlTags, streamFromReactStreamingPackage);
+        if (streamFromReactStreamingPackage) {
+            (0, injectHtmlTags_js_1.injectHtmlTagsUsingStream)(htmlTags, streamFromReactStreamingPackage);
+        }
         return htmlBegin;
     }
+    // Is it worth it? Should we remove this? https://github.com/vikejs/vike/pull/1740#issuecomment-2230540892
+    function injectAtStreamAfterFirstChunk() {
+        // React has its own stream injection mechanism, see injectHtmlTagsUsingStream()
+        if (streamFromReactStreamingPackage)
+            return null;
+        (0, utils_js_1.assert)(htmlTags);
+        const tags = htmlTags.filter((h) => h.position === 'STREAM');
+        if (tags.length === 0)
+            return null;
+        const htmlFragment = (0, injectHtmlTags_js_1.joinHtmlTags)(tags);
+        return htmlFragment;
+    }
     async function injectAtStreamEnd(htmlPartsEnd) {
         (0, utils_js_1.assert)(htmlTags);
         await resolvePageContextPromise(pageContext);

package/dist/cjs/node/runtime/html/renderHtml.js

@@ -55,7 +55,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
 }
 exports.renderDocumentHtml = renderDocumentHtml;
 async function renderHtmlStream(streamOriginal, injectString, pageContext, onErrorWhileStreaming, injectFilter) {
-    const opts = {
+    const processStreamOptions = {
         onErrorWhileStreaming,
         enableEagerStreaming: pageContext.enableEagerStreaming
     };
@@ -64,17 +64,18 @@ async function renderHtmlStream(streamOriginal, injectString, pageContext, onErr
         if ((0, react_streaming_js_1.isStreamFromReactStreamingPackage)(streamOriginal) && !streamOriginal.disabled) {
             streamFromReactStreamingPackage = streamOriginal;
         }
-        const { injectAtStreamBegin, injectAtStreamEnd } = (0, injectAssets_js_1.injectHtmlTagsToStream)(pageContext, streamFromReactStreamingPackage, injectFilter);
-        (0, utils_js_1.objectAssign)(opts, {
-            injectStringAtBegin: async () => {
-                return await injectAtStreamBegin(injectString.htmlPartsBegin);
-            },
-            injectStringAtEnd: async () => {
-                return await injectAtStreamEnd(injectString.htmlPartsEnd);
-            }
-        });
+        const { injectAtStreamBegin, injectAtStreamAfterFirstChunk, injectAtStreamEnd } = (0, injectAssets_js_1.injectHtmlTagsToStream)(pageContext, streamFromReactStreamingPackage, injectFilter);
+        processStreamOptions.injectStringAtBegin = async () => {
+            return await injectAtStreamBegin(injectString.htmlPartsBegin);
+        };
+        processStreamOptions.injectStringAtEnd = async () => {
+            return await injectAtStreamEnd(injectString.htmlPartsEnd);
+        };
+        processStreamOptions.injectStringAfterFirstChunk = () => {
+            return injectAtStreamAfterFirstChunk();
+        };
     }
-    const streamWrapper = await (0, stream_js_1.processStream)(streamOriginal, opts);
+    const streamWrapper = await (0, stream_js_1.processStream)(streamOriginal, processStreamOptions);
     return streamWrapper;
 }
 function isTemplateWrapped(something) {

package/dist/cjs/node/runtime/html/serializePageContextClientSide.js

@@ -46,17 +46,27 @@ function serializePageContextClientSide(pageContext) {
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const propName = JSON.stringify(prop);
-            const varName = h(`pageContext[${propName}]`);
+            const propName1 = (0, utils_js_1.getPropAccessNotation)(prop);
+            const propName2 = JSON.stringify(prop);
+            const varName = `pageContext${propName1}`;
             try {
                 serialize(pageContext[prop], varName);
             }
             catch (err) {
                 hasWarned = true;
                 propsNonSerializable.push(prop);
+                // useConfig() wrong usage
+                if (prop === '_configFromHook') {
+                    let pathString = '';
+                    if ((0, stringify_1.isJsonSerializerError)(err)) {
+                        pathString = err.pathString;
+                    }
+                    (0, utils_js_1.assertUsage)(false, `Cannot serialize config ${h(pathString)} set by useConfig(), see https://vike.dev/useConfig#serialization-error`);
+                }
+                // Non-serializable pageContext set by the user
                 let msg = [
-                    `${varName} cannot be serialized and, therefore, cannot be passed to the client.`,
-                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`
+                    `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
+                    `Make sure ${h(varName)} is serializable, or remove ${h(propName2)} from ${h('passToClient')}.`
                 ].join(' ');
                 if ((0, stringify_1.isJsonSerializerError)(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;

package/dist/cjs/node/runtime/html/stream.js

@@ -198,7 +198,7 @@ function pipeToStreamWritableNode(htmlRender, writable) {
     (0, utils_js_1.assert)(false);
 }
 exports.pipeToStreamWritableNode = pipeToStreamWritableNode;
-async function processStream(streamOriginal, { injectStringAtBegin, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }) {
+async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
     let streamOriginalEnded = false;
@@ -210,6 +210,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
     let resolve;
     let reject;
     let promiseHasResolved = false;
+    let injectStringAfterFirstChunk_done = false;
     const streamWrapperPromise = new Promise((resolve_, reject_) => {
         resolve = (streamWrapper) => {
             promiseHasResolved = true;
@@ -223,8 +224,8 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
     let resolveReadyToWrite;
     const promiseReadyToWrite = new Promise((r) => (resolveReadyToWrite = r));
     if (injectStringAtBegin) {
-        const injectionBegin = await injectStringAtBegin();
-        writeStream(injectionBegin); // Adds injectionBegin to buffer
+        const injectedChunk = await injectStringAtBegin();
+        writeStream(injectedChunk); // Adds injectedChunk to buffer
         flushStream(); // Sets shouldFlushStream to true
     }
     // We call onStreamEvent() also when the stream ends in order to properly handle the situation when the stream didn't emit any data
@@ -254,6 +255,12 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         onData(chunk) {
             onStreamDataOrEnd(() => {
                 writeStream(chunk);
+                if (injectStringAfterFirstChunk && !injectStringAfterFirstChunk_done) {
+                    const injectedChunk = injectStringAfterFirstChunk();
+                    if (injectedChunk !== null)
+                        writeStream(injectedChunk);
+                    injectStringAfterFirstChunk_done = true;
+                }
             });
         },
         async onEnd(
@@ -268,8 +275,8 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                     streamOriginalEnded = true;
                 });
                 if (injectStringAtEnd) {
-                    const injectEnd = await injectStringAtEnd();
-                    writeStream(injectEnd);
+                    const injectedChunk = await injectStringAtEnd();
+                    writeStream(injectedChunk);
                 }
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
                 (0, utils_js_1.assert)(isReady());

package/dist/cjs/node/runtime/renderPage/executeOnRenderHtmlHook.js

@@ -28,7 +28,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     const onErrorWhileStreaming = (err) => {
         // Should the stream inject the following?
         // ```
-        // <script>console.error("An error occurred on the server while streaming the app to HTML. Check the server logs for more information.")</script>
+        // <script>console.error("An error occurred on the server side while streaming the page to HTML, see server logs.")</script>
         // ```
         (0, loggerRuntime_js_1.logRuntimeError)(err, pageContext._httpRequestId);
         if (!pageContext.errorWhileRendering) {

package/dist/cjs/node/runtime/renderPage.js

@@ -247,8 +247,7 @@ function logHttpResponse(urlOriginal, httpRequestId, pageContextReturn) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(msg, httpRequestId, isNominal ? 'info' : 'error');
 }
 function getPageContextHttpResponseNullWithError(err, pageContextInit) {
-    const pageContextHttpResponseNull = {};
-    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, pageContextInit);
+    const pageContextHttpResponseNull = createPageContext(pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: err
@@ -256,14 +255,20 @@ function getPageContextHttpResponseNullWithError(err, pageContextInit) {
     return pageContextHttpResponseNull;
 }
 function getPageContextHttpResponseNull(pageContextInit) {
-    const pageContextHttpResponseNull = {};
-    (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, pageContextInit);
+    const pageContextHttpResponseNull = createPageContext(pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextHttpResponseNull, {
         httpResponse: null,
         errorWhileRendering: null
     });
     return pageContextHttpResponseNull;
 }
+function createPageContext(pageContextInit) {
+    const pageContext = {
+        _isPageContextObject: true
+    };
+    Object.assign(pageContext, pageContextInit);
+    return pageContext;
+}
 async function renderPageNominal(pageContext) {
     (0, utils_js_1.objectAssign)(pageContext, { errorWhileRendering: null });
     // Route
@@ -347,8 +352,7 @@ function normalizeUrl(pageContextInit, httpRequestId) {
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`URL normalized from ${picocolors_1.default.cyan(urlOriginal)} to ${picocolors_1.default.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
     const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
-    const pageContextHttpResponse = {};
-    (0, utils_js_1.objectAssign)(pageContextHttpResponse, pageContextInit);
+    const pageContextHttpResponse = createPageContext(pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -384,8 +388,7 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
-    const pageContextHttpResponse = {};
-    (0, utils_js_1.objectAssign)(pageContextHttpResponse, pageContextInit);
+    const pageContextHttpResponse = createPageContext(pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -401,9 +404,8 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
             const abortCall = pageContextAbort._abortCall;
             (0, utils_js_1.assert)(abortCall);
             (0, utils_js_1.assertUsage)(errorPageId, `You called ${picocolors_1.default.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
-            const pageContext = {
-                _pageId: errorPageId
-            };
+            const pageContext = createPageContext({});
+            (0, utils_js_1.objectAssign)(pageContext, { _pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit);
             (0, utils_js_1.objectAssign)(pageContext, renderContext);
@@ -427,8 +429,7 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = {};
-        (0, utils_js_1.objectAssign)(pageContextReturn, pageContextInit);
+        const pageContextReturn = createPageContext(pageContextInit);
         (0, utils_js_1.objectAssign)(pageContextReturn, pageContextAbort);
         const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, (() => {
             const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;

package/dist/cjs/node/runtime/utils.js

@@ -71,3 +71,4 @@ __exportStar(require("../../utils/isArrayOfStrings.js"), exports);
 __exportStar(require("../../utils/escapeHtml.js"), exports);
 __exportStar(require("../../utils/normalizeHeaders.js"), exports);
 __exportStar(require("../../utils/isVikeReactApp.js"), exports);
+__exportStar(require("../../utils/getPropAccessNotation.js"), exports);

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -157,6 +157,10 @@ function valueToJson(value, configName, definedAtData, importStatements) {
         configValueSerialized = (0, stringify_1.stringify)(value, {
             valueName,
             forbidReactElements: true,
+            // Replace import strings with import variables.
+            // - We don't need this anymore and could remove it.
+            //   - We temporarily needed it for nested document configs (`config.document.{title,description,favicon}`), but we finally decided to go for flat document configs instead (`config.{title,description,favicon}`).
+            //   - https://github.com/vikejs/vike-react/pull/113
             replacer(_, value) {
                 if (typeof value === 'string') {
                     const importData = (0, transformFileImports_js_1.parsePointerImportData)(value);

package/dist/cjs/shared/route/index.js

@@ -18,12 +18,12 @@ const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
 const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-async function route(pageContextForRoute) {
-    (0, debug_js_1.debug)('Pages routes:', pageContextForRoute._pageRoutes);
-    (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContextForRoute);
+async function route(pageContext) {
+    (0, debug_js_1.debug)('Pages routes:', pageContext._pageRoutes);
+    (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
     const pageContextFromRoute = {};
     // onBeforeRoute()
-    const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContextForRoute);
+    const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext);
     if (pageContextFromOnBeforeRouteHook) {
         if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
             (0, utils_js_1.assert)(pageContextFromOnBeforeRouteHook._pageId);
@@ -34,8 +34,6 @@ async function route(pageContextForRoute) {
         }
     }
     // We take into account pageContext.urlLogical set by onBeforeRoute()
-    const pageContext = {};
-    (0, utils_js_1.objectAssign)(pageContext, pageContextForRoute);
     (0, utils_js_1.objectAssign)(pageContext, pageContextFromOnBeforeRouteHook);
     // Vike's routing
     const allPageIds = pageContext._allPageIds;

package/dist/cjs/utils/augmentType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.augmentType = void 0;
+const assert_js_1 = require("./assert.js");
+/** Help TypeScript augment the type of objects. */
+function augmentType(thing, clone) {
+    // @ts-ignore
+    (0, assert_js_1.assert)(thing === clone);
+}
+exports.augmentType = augmentType;

package/dist/cjs/utils/getPropAccessNotation.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPropAccessNotation = void 0;
 function getPropAccessNotation(key) {
-    return typeof key === 'string' && /^[a-z0-9\$_]+$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+    return typeof key === 'string' && isKeyDotNotationCompatible(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
 }
 exports.getPropAccessNotation = getPropAccessNotation;
+function isKeyDotNotationCompatible(key) {
+    return /^[a-z0-9\$_]+$/i.test(key);
+}

package/dist/cjs/utils/objectAssign.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectAssign = void 0;
+const assert_js_1 = require("./assert.js");
 // Same as Object.assign() but:
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters added by getPageContextUrlComputed()
 function objectAssign(obj, objAddendum) {
     if (objAddendum) {
+        (0, assert_js_1.assert)(!('_isPageContextObject' in objAddendum));
         Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
     }
 }

package/dist/cjs/utils/projectInfo.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.179';
+const PROJECT_VERSION = '0.4.180';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -11,6 +11,7 @@ declare function createPageContext(urlOriginal: string): Promise<{
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    _isPageContextObject: boolean;
 } & {
     urlParsed: import("../../shared/getPageContextUrlComputed.js").Url;
     urlPathname: string;

package/dist/esm/client/client-routing-runtime/createPageContext.js

@@ -24,7 +24,8 @@ async function createPageContext(urlOriginal) {
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
         _pageRoutes: pageRoutes,
-        _onBeforeRouteHook: onBeforeRouteHook
+        _onBeforeRouteHook: onBeforeRouteHook,
+        _isPageContextObject: true
     };
     const pageContextUrlComputed = getPageContextUrlComputed(pageContext);
     objectAssign(pageContext, pageContextUrlComputed);

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.d.ts

@@ -16,7 +16,7 @@ type PageContextSerialized = {
 declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
     routeParams: Record<string, string>;
 };
-declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageContextExports): Promise<{
+declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageContextExports): Promise<PageContextSerialized & PageContext & PageContextExports & {
     isHydration: true;
     _hasPageContextFromClient: false;
     _hasPageContextFromServer: true;
@@ -25,9 +25,11 @@ declare function getPageContextFromHooks_isNotHydration(pageContext: {
     _pageId: string;
 } & PageContext & PageContextExports, isErrorPage: boolean): Promise<{
     is404ServerSideRouted: boolean;
-    pageContextFromHooks?: undefined;
+    pageContextAugmented?: undefined;
 } | {
-    pageContextFromHooks: {
+    pageContextAugmented: {
+        _pageId: string;
+    } & PageContext & PageContextExports & {
         isHydration: false;
         _hasPageContextFromClient: boolean;
     } & {