vike 0.4.171-commit-ea3808a → 0.4.171-commit-978d69d

package/dist/cjs/node/plugin/plugins/extractAssetsPlugin.js

@@ -102,7 +102,7 @@ function extractAssetsPlugin() {
                 }
                 // If the import path resolves to a file in `node_modules/`, we ignore that file:
                 //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
-                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is non-standard; we can safely not support this case. (I'm not aware of any library that does this.)
+                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is unconventional; we can safely not support this case. (I'm not aware of any library that does this.)
                 (0, utils_js_1.assertPosixPath)(file);
                 if (file.includes('/node_modules/')) {
                     return emptyModule(file, importer);

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

@@ -898,7 +898,7 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
             const configValueSource = sources[0];
             if ('value' in configValueSource) {
                 configValues[configName] = {
-                    type: 'classic',
+                    type: 'standard',
                     value: configValueSource.value,
                     definedAtData: getDefinedAtFile(configValueSource)
                 };

package/dist/cjs/node/prerender/runPrerender.js

@@ -245,7 +245,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
         }
-        const prerenderResult = await (0, executeHook_js_1.executeHook)(() => hookFn(), { hookName, hookFilePath, hookTimeout });
+        const prerenderResult = await (0, executeHook_js_1.executeHook)(() => hookFn(), { hookName, hookFilePath, hookTimeout }, null);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
             {
@@ -420,7 +420,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             });
             return prerenderContext.pageContexts;
         }
-    }), onPrerenderStartHook);
+    }), onPrerenderStartHook, null);
     if (result === null || result === undefined) {
         return;
     }

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

@@ -762,17 +762,17 @@ async function loadStreamNodeModule() {
     const { Readable, Writable } = streamModule;
     return { Readable, Writable };
 }
-function getStreamName(type, standard) {
-    let standardName = (0, utils_js_1.capitalizeFirstLetter)(standard);
-    if (standardName === 'Node') {
-        standardName = 'Node.js';
+function getStreamName(kind, type) {
+    let typeName = (0, utils_js_1.capitalizeFirstLetter)(type);
+    if (typeName === 'Node') {
+        typeName = 'Node.js';
     }
-    const typeName = (0, utils_js_1.capitalizeFirstLetter)(type);
-    if (type !== 'pipe') {
-        return `a ${typeName} ${standardName} Stream`;
+    const kindName = (0, utils_js_1.capitalizeFirstLetter)(kind);
+    if (kind !== 'pipe') {
+        return `a ${kindName} ${typeName} Stream`;
     }
-    if (type === 'pipe') {
-        return `a ${standardName} Stream Pipe`;
+    if (kind === 'pipe') {
+        return `a ${typeName} Stream Pipe`;
     }
     (0, utils_js_1.assert)(false);
 }

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

@@ -16,7 +16,7 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
     }
     (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
     if (dataHook) {
-        const hookResult = await (0, executeHook_js_1.executeHook)(() => dataHook.hookFn(pageContext), dataHook);
+        const hookResult = await (0, executeHook_js_1.executeHook)(() => dataHook.hookFn(pageContext), dataHook, pageContext);
         // Note: hookResult can be anything (e.g. an object) and is to be assigned to pageContext.data
         const pageContextFromHook = {
             data: hookResult
@@ -24,7 +24,7 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
         Object.assign(pageContext, pageContextFromHook);
     }
     if (onBeforeRenderHook) {
-        const hookResult = await (0, executeHook_js_1.executeHook)(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook);
+        const hookResult = await (0, executeHook_js_1.executeHook)(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook, pageContext);
         (0, assertOnBeforeRenderHookReturn_js_1.assertOnBeforeRenderHookReturn)(hookResult, onBeforeRenderHook.hookFilePath);
         const pageContextFromHook = hookResult?.pageContext;
         Object.assign(pageContext, pageContextFromHook);

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

@@ -18,7 +18,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     const { renderHook, hookFn } = getRenderHook(pageContext);
     (0, utils_js_1.objectAssign)(pageContext, { _renderHook: renderHook });
     (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
-    const hookReturnValue = await (0, executeHook_js_1.executeHook)(() => hookFn(pageContext), renderHook);
+    const hookReturnValue = await (0, executeHook_js_1.executeHook)(() => hookFn(pageContext), renderHook, pageContext);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     (0, utils_js_1.objectAssign)(pageContext, { _pageContextPromise: pageContextPromise });

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

@@ -100,8 +100,8 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
         }
     };
-    function getFixMsg(type, standard) {
-        const streamName = (0, stream_js_1.getStreamName)(type, standard);
+    function getFixMsg(kind, type) {
+        const streamName = (0, stream_js_1.getStreamName)(kind, type);
         (0, utils_js_1.assert)(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
         (0, utils_js_1.assert)(renderHook);
         const { hookFilePath, hookName } = renderHook;

package/dist/cjs/shared/getPageContext.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageContext = void 0;
+var executeHook_js_1 = require("./hooks/executeHook.js");
+Object.defineProperty(exports, "getPageContext", { enumerable: true, get: function () { return executeHook_js_1.getPageContext; } });

package/dist/cjs/shared/getPageFiles/getExports.js

@@ -40,7 +40,7 @@ function getPageContextExports(pageFiles, pageConfig) {
         sources[configName].push(src);
     };
     const from = {
-        configsOverridable: {},
+        configsStandard: {},
         configsCumulative: {},
         configsComputed: {}
     };
@@ -58,6 +58,15 @@ function getPageContextExports(pageFiles, pageConfig) {
                 configDefinedAt,
                 configDefinedByFile: configValueFilePathToShowToUser
             });
+            if (configValue.type === 'standard') {
+                const src = {
+                    type: 'configsStandard',
+                    value: configValue.value,
+                    definedAt: (0, getConfigDefinedAt_js_1.getDefinedAtString)(configValue.definedAtData, configName)
+                };
+                addSrc(src, configName);
+                from.configsStandard[configName] = src;
+            }
             if (configValue.type === 'cumulative') {
                 const src = {
                     type: 'configsCumulative',
@@ -74,15 +83,6 @@ function getPageContextExports(pageFiles, pageConfig) {
                 addSrc(src, configName);
                 from.configsCumulative[configName] = src;
             }
-            if (configValue.type === 'classic') {
-                const src = {
-                    type: 'configsOverridable',
-                    value: configValue.value,
-                    definedAt: (0, getConfigDefinedAt_js_1.getDefinedAtString)(configValue.definedAtData, configName)
-                };
-                addSrc(src, configName);
-                from.configsOverridable[configName] = src;
-            }
             if (configValue.type === 'computed') {
                 const src = {
                     type: 'configsComputed',

package/dist/cjs/shared/hooks/executeHook.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUserHookError = exports.executeHook = void 0;
+exports.isUserHookError = exports.getPageContext = exports.executeHook = void 0;
 const assert_js_1 = require("../../utils/assert.js");
 const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
 const humanizeTime_js_1 = require("../../utils/humanizeTime.js");
 const isObject_js_1 = require("../../utils/isObject.js");
 const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/executeHook.ts', {
-    userHookErrors: new WeakMap()
+    userHookErrors: new WeakMap(),
+    pageContext: null
 });
 function isUserHookError(err) {
     if (!(0, isObject_js_1.isObject)(err))
@@ -14,7 +15,7 @@ function isUserHookError(err) {
     return globalObject.userHookErrors.get(err) ?? false;
 }
 exports.isUserHookError = isUserHookError;
-function executeHook(hookFnCaller, hook) {
+function executeHook(hookFnCaller, hook, pageContext) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
     let resolve;
     let reject;
@@ -45,6 +46,7 @@ function executeHook(hookFnCaller, hook) {
         }, timeoutErr);
     (async () => {
         try {
+            providePageContext(pageContext);
             const ret = await hookFnCaller();
             resolve(ret);
         }
@@ -61,3 +63,20 @@ exports.executeHook = executeHook;
 function isNotDisabled(timeout) {
     return !!timeout && timeout !== Infinity;
 }
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function getPageContext() {
+    return globalObject.pageContext;
+}
+exports.getPageContext = getPageContext;
+function providePageContext(pageContext) {
+    globalObject.pageContext = pageContext;
+    // Promise.resolve() is quicker than process.nextTick() and setImmediate()
+    // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
+    Promise.resolve().then(() => {
+        globalObject.pageContext = null;
+    });
+}

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

@@ -53,7 +53,7 @@ function parseConfigValuesImported(configValuesImported) {
             (0, utils_js_1.assert)(val);
             const { value, importPath, exportName } = val;
             configValues[configName] = {
-                type: 'classic',
+                type: 'standard',
                 value,
                 definedAtData: {
                     // importPath cannot be relative to the current file, since the current file is a virtual file

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

@@ -23,7 +23,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     const res = prepareForUserConsumption(pageContext);
     if (res)
         pageContextForUserConsumption = res;
-    const hookResult = await (0, executeHook_js_1.executeHook)(() => guard(pageContextForUserConsumption), hook);
+    const hookResult = await (0, executeHook_js_1.executeHook)(() => guard(pageContextForUserConsumption), hook, pageContext);
     (0, utils_js_1.assertUsage)(hookResult === undefined, `${errIntro} ${hook.hookFilePath} returns a value, but guard() shouldn't return any value`);
 }
 exports.executeGuardHook = executeGuardHook;

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

@@ -42,7 +42,7 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.hookFn(pageContext);
     (0, resolveRouteFunction_js_1.assertSyncRouting)(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
-    hookReturn = await (0, executeHook_js_1.executeHook)(() => hookReturn, onBeforeRouteHook);
+    hookReturn = await (0, executeHook_js_1.executeHook)(() => hookReturn, onBeforeRouteHook, pageContext);
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     (0, utils_js_1.assertUsage)(hookReturn === null ||
         hookReturn === undefined ||

package/dist/cjs/utils/getPropAccessNotation.js

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

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.171-commit-ea3808a';
+const PROJECT_VERSION = '0.4.171-commit-978d69d';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

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

@@ -108,7 +108,7 @@ async function executeHookClientSide(hookName, pageContext) {
         return null;
     }
     const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, true);
-    const hookResult = await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook);
+    const hookResult = await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook, pageContext);
     const pageContextFromHook = {};
     if (hookName === 'onBeforeRender') {
         assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
@@ -221,7 +221,7 @@ async function fetchPageContextFromServer(pageContext) {
     }
     // Is there a reason for having two different properties? Can't we use only one property? I guess/think the isServerSideError property was an attempt (a bad idea really) for rendering the error page even though an error occured on the server-side (which is a bad idea because the added complexity is non-negligible while the added value is minuscule since the error page usually doesn't have any (meaningful / server-side) hooks).
     if ('serverSideError' in pageContextFromServer || isServerSideError in pageContextFromServer) {
-        throw getProjectError(`The pageContext object couldn't be fetched from the server as an error occurred on the server-side. Check your server logs.`);
+        throw getProjectError(`pageContext couldn't be fetched from server: an error occurred on the server-side (see your server logs)`);
     }
     assert(hasProp(pageContextFromServer, '_pageId', 'string'));
     processPageContextFromServer(pageContextFromServer);

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

@@ -51,7 +51,7 @@ async function renderPageClientSide(renderArgs) {
                     const hook = onPageTransitionStartHook;
                     const { hookFn } = hook;
                     try {
-                        await executeHook(() => hookFn(pageContext), hook);
+                        await executeHook(() => hookFn(pageContext), hook, pageContext);
                     }
                     catch (err) {
                         await onError(err);
@@ -353,7 +353,7 @@ async function renderPageClientSide(renderArgs) {
             if (hook) {
                 const { hookFn } = hook;
                 try {
-                    await executeHook(() => hookFn(pageContext), hook);
+                    await executeHook(() => hookFn(pageContext), hook, pageContext);
                 }
                 catch (err) {
                     await onError(err);
@@ -377,7 +377,7 @@ async function renderPageClientSide(renderArgs) {
             if (hook) {
                 const { hookFn } = hook;
                 try {
-                    await executeHook(() => hookFn(pageContext), hook);
+                    await executeHook(() => hookFn(pageContext), hook, pageContext);
                 }
                 catch (err) {
                     await onError(err);

package/dist/esm/client/server-routing-runtime/utils.d.ts

@@ -12,3 +12,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js';
+export * from '../../utils/getPropAccessNotation.js';

package/dist/esm/client/server-routing-runtime/utils.js

@@ -16,3 +16,4 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/unique.js'; // Only used by Server Routing (not needed for Client Routing)
+export * from '../../utils/getPropAccessNotation.js';

package/dist/esm/client/shared/executeOnRenderClientHook.js

@@ -45,7 +45,7 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const renderHook = hook.hookFn;
     assert(hookName);
     // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
-    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hook);
+    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hook, pageContext);
     assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
 function getUrlToShowToUser(pageContext) {

package/dist/esm/client/shared/getPageContextProxyForUser.d.ts

@@ -5,7 +5,8 @@ type PageContextForPassToClientWarning = {
     _hasPageContextFromClient: boolean;
 };
 /**
- * - Throw error when pageContext value isn't serializable
- * - Throw error when pageContext prop is missing in passToClient
+ * Throw error when pageContext value isn't:
+ * - serializable, or
+ * - defined.
  */
 declare function getPageContextProxyForUser<PageContext extends Record<string, unknown> & PageContextForPassToClientWarning>(pageContext: PageContext): PageContext;

package/dist/esm/client/shared/getPageContextProxyForUser.js

@@ -1,10 +1,11 @@
 export { getPageContextProxyForUser };
-import { assert, assertUsage, assertWarning, getGlobalObject } from '../server-routing-runtime/utils.js';
+import { assert, assertUsage, assertWarning, getGlobalObject, getPropAccessNotation } from '../server-routing-runtime/utils.js';
 import { notSerializable } from '../../shared/notSerializable.js';
 const globalObject = getGlobalObject('getPageContextProxyForUser.ts', {});
 /**
- * - Throw error when pageContext value isn't serializable
- * - Throw error when pageContext prop is missing in passToClient
+ * Throw error when pageContext value isn't:
+ * - serializable, or
+ * - defined.
  */
 function getPageContextProxyForUser(pageContext) {
     assert([true, false].includes(pageContext._hasPageContextFromServer));
@@ -12,66 +13,45 @@ function getPageContextProxyForUser(pageContext) {
     return new Proxy(pageContext, {
         get(_, prop) {
             const val = pageContext[prop];
-            const propName = JSON.stringify(prop);
-            assertUsage(val !== notSerializable, `pageContext[${propName}] couldn't be serialized and, therefore, is missing on the client-side. Check the server logs for more information.`);
-            assertIsDefined(pageContext, prop);
+            const propName = getPropAccessNotation(prop);
+            assertUsage(val !== notSerializable, `pageContext${propName} couldn't be serialized and, therefore, is missing on the client-side. Check the server logs for more information.`);
+            passToClientHint(pageContext, prop, propName);
             return val;
         }
     });
 }
-function assertIsDefined(pageContext, prop) {
-    // We disable assertIsDefined() for the next attempt to read `prop`, because of how Vue's reactivity work. When changing a reactive object:
-    //  - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextOldReactive.routeParams = pageContextNew.routeParams` and `pageContextOldReactive` has no `routeParams`.
-    //  - Vue seems to read __v_raw before reading the property
-    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
+function passToClientHint(pageContext, prop, propName) {
+    if (handleVueReactivity(prop))
         return;
-    ignoreNextRead(prop);
+    // `prop in pageContext` is the trick we use to know the passToClient value on the client-side, as we set a value to all passToClient props, even `undefined` ones:
+    // ```html
+    // <script id="vike_pageContext" type="application/json">{"pageProps":"!undefined"}</script>
+    // ```
     if (prop in pageContext)
         return;
-    if (isExpected(prop))
+    if (isWhitelisted(prop))
         return;
-    // - If no pageContext was fetchd from the server, then adding props to passToClient is useless.
-    // - Showing a warning, even though no pageContext was fetched from the server, is actually erroneous as the client runtime cannot deduce the passToClient list.
+    // The trick described above (`prop in pageContext`) doesn't work if Vike doesn't fetch any pageContext from the server.
+    // - There would still be some value to show a warning, but it isn't worth it because of the confusion that the first recommendation (adding `prop` to `passToClient`) wouldn't actually remove the warning, and only the second recommendation (using `prop in pageContext` instead of `pageContext[prop]`) would work.
     if (!pageContext._hasPageContextFromServer)
         return;
-    const propName = JSON.stringify(prop);
-    /* This handling would be the clearest but, unfortunately, it's fundamentally problematic:
-     *  - It would force the pageContext value consumer to be synchronized with the pageContext value provider. For example, if vike-react wants to conditionally do something dependening on wehther some optional pageContext value was provided by some optional vike-react-* integration package.
-     *  - If a pageContext value is set by an optional hook, then it's expected that the value is undefined if the hook doesn't exist.
-    const errMsg = `pageContext[${propName}] is \`undefined\` on the client-side. If it's defined on the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), otherwise make sure your client-side hooks always define it (e.g. set it to \`null\` instead of \`undefined\`).`
-    assertUsage(false, errMsg)
-    */
-    if (!pageContext._hasPageContextFromClient) {
-        // We can safely assume that the property is missing in passToClient, because the server-side defines all passToClient properties even if they have an undefined value:
-        // ```
-        // <script id="vike_pageContext" type="application/json">{"_pageId":"/pages/admin","user":"!undefined","pageProps":"!undefined","title":"!undefined","abortReason":"!undefined","_urlRewrite":null}</script>
-        // ```
-        // Note how properties have "!undefined" values => we can tell whether an undefined pageContext value exists in passToClient.
-        assertUsage(false, `pageContext[${propName}] isn't available on the client-side because ${propName} is missing in passToClient, see https://vike.dev/passToClient`);
+    const errMsg = `pageContext${propName} isn't defined on the client-side, see https://vike.dev/passToClient#error`;
+    if (
+    // TODO/next-major-release always make it an error.
+    // - Remove pageContext._hasPageContextFromClient logic (IIRC this is its only use case).
+    pageContext._hasPageContextFromClient) {
+        assertWarning(false, errMsg, { onlyOnce: false, showStackTrace: true });
     }
     else {
-        // Do nothing, not even a warning, because we don't know whether the user expects that the pageContext value can be undefined. (E.g. a pageContext value that is defined by an optional hook.)
-        // TODO/next-major-release make it an assertUsage()
-        assertWarning(false, [
-            `pageContext[${propName}] isn't defined on the client-side:`,
-            `1. if it's defined by the server-side then add ${propName} to passToClient (https://vike.dev/passToClient), or`,
-            `2. if it's expected that it may not be defined:`,
-            '   ```js',
-            '   // ❌ Replace code like this:',
-            `   const val = pageContext[${propName}] ?? someDefaultValue`,
-            '   // ✅ With that:',
-            `   const val = ${propName} in pageContext ? pageContext[${propName}] : someDefaultValue`,
-            '   ```',
-            `See stack track below to find where pageContext[${propName}] is being accessed.`
-        ].join('\n'), { showStackTrace: true, onlyOnce: false });
+        assertUsage(false, errMsg);
     }
 }
-const IGNORE_LIST = [
+const WHITELIST = [
     'then',
-    'toJSON' // Vue tries to get `toJSON`
+    'toJSON' // Vue triggers `toJSON`
 ];
-function isExpected(prop) {
-    if (IGNORE_LIST.includes(prop))
+function isWhitelisted(prop) {
+    if (WHITELIST.includes(prop))
         return true;
     if (typeof prop === 'symbol')
         return true; // Vue tries to access some symbols
@@ -81,9 +61,16 @@ function isExpected(prop) {
         return true; // Vue internals upon `reactive(pageContext)`
     return false;
 }
-function ignoreNextRead(prop) {
+// Handle Vue's reactivity.
+// When changing a reactive object:
+// - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextReactive.routeParams = pageContextNew.routeParams` and `pageContextReactive` has no `routeParams`.
+// - Vue seems to read __v_raw before reading the property.
+function handleVueReactivity(prop) {
+    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
+        return true;
     globalObject.prev = prop;
     window.setTimeout(() => {
         globalObject.prev = undefined;
     }, 0);
+    return false;
 }

package/dist/esm/node/plugin/plugins/extractAssetsPlugin.js

@@ -101,7 +101,7 @@ function extractAssetsPlugin() {
                 }
                 // If the import path resolves to a file in `node_modules/`, we ignore that file:
                 //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
-                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is non-standard; we can safely not support this case. (I'm not aware of any library that does this.)
+                //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is unconventional; we can safely not support this case. (I'm not aware of any library that does this.)
                 assertPosixPath(file);
                 if (file.includes('/node_modules/')) {
                     return emptyModule(file, importer);

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

@@ -892,7 +892,7 @@ function getConfigValues(configValueSources, configValuesComputed, configDefinit
             const configValueSource = sources[0];
             if ('value' in configValueSource) {
                 configValues[configName] = {
-                    type: 'classic',
+                    type: 'standard',
                     value: configValueSource.value,
                     definedAtData: getDefinedAtFile(configValueSource)
                 };

package/dist/esm/node/prerender/runPrerender.js

@@ -217,7 +217,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
         }
-        const prerenderResult = await executeHook(() => hookFn(), { hookName, hookFilePath, hookTimeout });
+        const prerenderResult = await executeHook(() => hookFn(), { hookName, hookFilePath, hookTimeout }, null);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
             {
@@ -392,7 +392,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             });
             return prerenderContext.pageContexts;
         }
-    }), onPrerenderStartHook);
+    }), onPrerenderStartHook, null);
     if (result === null || result === undefined) {
         return;
     }

package/dist/esm/node/runtime/html/stream.d.ts

@@ -80,5 +80,5 @@ type StreamPipeWrapped = {
 };
 declare function pipeStream(pipe: StreamPipe): StreamPipeWrapped;
 declare function streamToString(stream: StreamProviderAny): Promise<string>;
-declare function getStreamName(type: 'pipe' | 'readable' | 'writable', standard: 'web' | 'node'): `a ${string} Stream` | `a ${string} Stream Pipe`;
+declare function getStreamName(kind: 'pipe' | 'readable' | 'writable', type: 'web' | 'node'): `a ${string} Stream` | `a ${string} Stream Pipe`;
 declare function inferStreamName(stream: StreamProviderNormalized): `a ${string} Stream` | `a ${string} Stream Pipe`;

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

@@ -758,17 +758,17 @@ async function loadStreamNodeModule() {
     const { Readable, Writable } = streamModule;
     return { Readable, Writable };
 }
-function getStreamName(type, standard) {
-    let standardName = capitalizeFirstLetter(standard);
-    if (standardName === 'Node') {
-        standardName = 'Node.js';
+function getStreamName(kind, type) {
+    let typeName = capitalizeFirstLetter(type);
+    if (typeName === 'Node') {
+        typeName = 'Node.js';
     }
-    const typeName = capitalizeFirstLetter(type);
-    if (type !== 'pipe') {
-        return `a ${typeName} ${standardName} Stream`;
+    const kindName = capitalizeFirstLetter(kind);
+    if (kind !== 'pipe') {
+        return `a ${kindName} ${typeName} Stream`;
     }
-    if (type === 'pipe') {
-        return `a ${standardName} Stream Pipe`;
+    if (kind === 'pipe') {
+        return `a ${typeName} Stream Pipe`;
     }
     assert(false);
 }

package/dist/esm/node/runtime/renderPage/executeOnBeforeRenderAndDataHooks.js

@@ -14,7 +14,7 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
     }
     preparePageContextForUserConsumptionServerSide(pageContext);
     if (dataHook) {
-        const hookResult = await executeHook(() => dataHook.hookFn(pageContext), dataHook);
+        const hookResult = await executeHook(() => dataHook.hookFn(pageContext), dataHook, pageContext);
         // Note: hookResult can be anything (e.g. an object) and is to be assigned to pageContext.data
         const pageContextFromHook = {
             data: hookResult
@@ -22,7 +22,7 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
         Object.assign(pageContext, pageContextFromHook);
     }
     if (onBeforeRenderHook) {
-        const hookResult = await executeHook(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook);
+        const hookResult = await executeHook(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook, pageContext);
         assertOnBeforeRenderHookReturn(hookResult, onBeforeRenderHook.hookFilePath);
         const pageContextFromHook = hookResult?.pageContext;
         Object.assign(pageContext, pageContextFromHook);

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

@@ -13,7 +13,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     const { renderHook, hookFn } = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: renderHook });
     preparePageContextForUserConsumptionServerSide(pageContext);
-    const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook);
+    const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook, pageContext);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     objectAssign(pageContext, { _pageContextPromise: pageContextPromise });

package/dist/esm/node/runtime/renderPage/getHttpResponseBody.js

@@ -95,8 +95,8 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
             }
         }
     };
-    function getFixMsg(type, standard) {
-        const streamName = getStreamName(type, standard);
+    function getFixMsg(kind, type) {
+        const streamName = getStreamName(kind, type);
         assert(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
         assert(renderHook);
         const { hookFilePath, hookName } = renderHook;

package/dist/esm/shared/VikeNamespace.d.ts

@@ -9,6 +9,7 @@ declare global {
          *  - You can refine the type of `Config['Page']`.
          *  - You can define the type of custom configurations created with `config.meta` (https://vike.dev/meta)
          *
+         *  https://vike.dev/meta#typescript
          */
         interface Config {
         }
@@ -22,6 +23,14 @@ declare global {
          */
         interface PageContext {
         }
+        /** Refine the `pageContext.config` type.
+         *
+         *  It's used for cumulative configs: the `pageContext.config[configName]` type is an `array` whereas `Config[configName]` isn't.
+         *
+         *  https://vike.dev/meta#typescript
+         */
+        interface ConfigResolved {
+        }
     }
     /** This namespace is only used by:
      *  - `vike-react`

package/dist/esm/shared/getPageContext.d.ts

@@ -0,0 +1 @@
+export { getPageContext } from './hooks/executeHook.js';

package/dist/esm/shared/getPageContext.js

@@ -0,0 +1 @@
+export { getPageContext } from './hooks/executeHook.js';

package/dist/esm/shared/getPageFiles/getExports.d.ts

@@ -41,8 +41,8 @@ type PageContextExports = {
     pageExports: Record<string, unknown>;
 };
 type From = {
-    configsOverridable: Record<string, // configName
-    SourceConfigsOverridable>;
+    configsStandard: Record<string, // configName
+    SourceConfigsStandard>;
     configsCumulative: Record<string, // configName
     SourceConfigsCumulative>;
     configsComputed: Record<string, // configName
@@ -53,9 +53,9 @@ SourceAny>;
 type Sources = Record<string, // configName
 SourceAny[]>;
 type SourceAny = SourceConfigs;
-type SourceConfigs = SourceConfigsOverridable | SourceConfigsCumulative | SourceConfigsComputed;
-type SourceConfigsOverridable = {
-    type: 'configsOverridable';
+type SourceConfigs = SourceConfigsStandard | SourceConfigsCumulative | SourceConfigsComputed;
+type SourceConfigsStandard = {
+    type: 'configsStandard';
     value: unknown;
     definedAt: string;
 };

package/dist/esm/shared/getPageFiles/getExports.js

@@ -35,7 +35,7 @@ function getPageContextExports(pageFiles, pageConfig) {
         sources[configName].push(src);
     };
     const from = {
-        configsOverridable: {},
+        configsStandard: {},
         configsCumulative: {},
         configsComputed: {}
     };
@@ -53,6 +53,15 @@ function getPageContextExports(pageFiles, pageConfig) {
                 configDefinedAt,
                 configDefinedByFile: configValueFilePathToShowToUser
             });
+            if (configValue.type === 'standard') {
+                const src = {
+                    type: 'configsStandard',
+                    value: configValue.value,
+                    definedAt: getDefinedAtString(configValue.definedAtData, configName)
+                };
+                addSrc(src, configName);
+                from.configsStandard[configName] = src;
+            }
             if (configValue.type === 'cumulative') {
                 const src = {
                     type: 'configsCumulative',
@@ -69,15 +78,6 @@ function getPageContextExports(pageFiles, pageConfig) {
                 addSrc(src, configName);
                 from.configsCumulative[configName] = src;
             }
-            if (configValue.type === 'classic') {
-                const src = {
-                    type: 'configsOverridable',
-                    value: configValue.value,
-                    definedAt: getDefinedAtString(configValue.definedAtData, configName)
-                };
-                addSrc(src, configName);
-                from.configsOverridable[configName] = src;
-            }
             if (configValue.type === 'computed') {
                 const src = {
                     type: 'configsComputed',

package/dist/esm/shared/hooks/executeHook.d.ts

@@ -1,5 +1,14 @@
 export { executeHook };
+export { getPageContext };
 export { isUserHookError };
+import type { PageContextClient, PageContextServer } from '../types.js';
 import type { Hook, HookLoc } from './getHook.js';
+type PageContextUnknown = null | Record<string, unknown>;
 declare function isUserHookError(err: unknown): false | HookLoc;
-declare function executeHook<T = unknown>(hookFnCaller: () => T, hook: Omit<Hook, 'hookFn'>): Promise<T>;
+declare function executeHook<T = unknown>(hookFnCaller: () => T, hook: Omit<Hook, 'hookFn'>, pageContext: PageContextUnknown): Promise<T>;
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+declare function getPageContext<PageContext = PageContextClient | PageContextServer>(): null | PageContext;

package/dist/esm/shared/hooks/executeHook.js

@@ -1,18 +1,20 @@
 export { executeHook };
+export { getPageContext };
 export { isUserHookError };
 import { getProjectError, assertWarning } from '../../utils/assert.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { humanizeTime } from '../../utils/humanizeTime.js';
 import { isObject } from '../../utils/isObject.js';
 const globalObject = getGlobalObject('utils/executeHook.ts', {
-    userHookErrors: new WeakMap()
+    userHookErrors: new WeakMap(),
+    pageContext: null
 });
 function isUserHookError(err) {
     if (!isObject(err))
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-function executeHook(hookFnCaller, hook) {
+function executeHook(hookFnCaller, hook, pageContext) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
     let resolve;
     let reject;
@@ -43,6 +45,7 @@ function executeHook(hookFnCaller, hook) {
         }, timeoutErr);
     (async () => {
         try {
+            providePageContext(pageContext);
             const ret = await hookFnCaller();
             resolve(ret);
         }
@@ -58,3 +61,19 @@ function executeHook(hookFnCaller, hook) {
 function isNotDisabled(timeout) {
     return !!timeout && timeout !== Infinity;
 }
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function getPageContext() {
+    return globalObject.pageContext;
+}
+function providePageContext(pageContext) {
+    globalObject.pageContext = pageContext;
+    // Promise.resolve() is quicker than process.nextTick() and setImmediate()
+    // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
+    Promise.resolve().then(() => {
+        globalObject.pageContext = null;
+    });
+}

package/dist/esm/shared/page-configs/Config/PageContextConfig.d.ts

@@ -1,8 +1,8 @@
 export type { PageContextConfig };
 import type { VikePackages } from '../../VikeNamespace.js';
 import type { ConfigBuiltIn } from '../Config.js';
-import type { Combine, IsNotEmpty, XOR5 } from './helpers.ts';
-type PageContextConfig = ConfigBuiltIn & Vike.Config & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
+import type { Combine, IsNotEmpty, XOR5 } from './helpers.js';
+type PageContextConfig = ConfigBuiltIn & Vike.ConfigResolved & Omit<Vike.Config, keyof Vike.ConfigResolved> & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
 type ConfigVikePackagesIntersection = VikePackages.ConfigVikeReact & VikePackages.ConfigVikeVue & VikePackages.ConfigVikeSolid & VikePackages.ConfigVikeSvelte & VikePackages.ConfigVikeAngular;
 type ConfigVikePackagesCombined = Combine<VikePackages.ConfigVikeReact, Combine<VikePackages.ConfigVikeVue, Combine<VikePackages.ConfigVikeSolid, Combine<VikePackages.ConfigVikeSvelte, VikePackages.ConfigVikeAngular>>>>;
 type ConfigVikePackagesNotEmptyXor = XOR5<IsNotEmpty<VikePackages.ConfigVikeReact>, IsNotEmpty<VikePackages.ConfigVikeVue>, IsNotEmpty<VikePackages.ConfigVikeSolid>, IsNotEmpty<VikePackages.ConfigVikeSvelte>, IsNotEmpty<VikePackages.ConfigVikeAngular>>;

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -6,7 +6,7 @@ export type { ConfigEnvInternal };
 export type { PageConfigGlobalRuntime };
 export type { PageConfigGlobalBuildTime };
 export type { ConfigValue };
-export type { ConfigValueClassic };
+export type { ConfigValueStandard };
 export type { ConfigValueCumulative };
 export type { ConfigValueComputed };
 export type { ConfigValues };
@@ -86,10 +86,10 @@ type ConfigValuesComputed = Record<string, {
     configEnv: ConfigEnvInternal;
     value: unknown;
 }>;
-type ConfigValue = ConfigValueClassic | ConfigValueCumulative | ConfigValueComputed;
+type ConfigValue = ConfigValueStandard | ConfigValueCumulative | ConfigValueComputed;
 /** Defined by a unique source (thus unique file path). */
-type ConfigValueClassic = {
-    type: 'classic';
+type ConfigValueStandard = {
+    type: 'standard';
     value: unknown;
     definedAtData: DefinedAtFile;
 };

package/dist/esm/shared/page-configs/serialize/PageConfigSerialized.d.ts

@@ -2,7 +2,7 @@ export type { PageConfigRuntimeSerialized };
 export type { PageConfigGlobalRuntimeSerialized };
 export type { ConfigValueSerialized };
 export type { ConfigValueImported };
-import type { ConfigValueClassic, ConfigValueComputed, ConfigValueCumulative, PageConfigRuntime } from '../PageConfig.js';
+import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, PageConfigRuntime } from '../PageConfig.js';
 /** Page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
 type PageConfigRuntimeSerialized = Omit<PageConfigRuntime, 'configValues'> & {
     /** Config values that are serializable and loaded eagerly such as config.passToClient */
@@ -14,7 +14,7 @@ type PageConfigGlobalRuntimeSerialized = {
     configValuesImported: ConfigValueImported[];
 };
 /** Value is serialized */
-type ConfigValueSerialized = (Omit<ConfigValueClassic, 'value'> & {
+type ConfigValueSerialized = (Omit<ConfigValueStandard, 'value'> & {
     valueSerialized: string;
 }) | (Omit<ConfigValueCumulative, 'value'> & {
     valueSerialized: string;

package/dist/esm/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -51,7 +51,7 @@ function parseConfigValuesImported(configValuesImported) {
             assert(val);
             const { value, importPath, exportName } = val;
             configValues[configName] = {
-                type: 'classic',
+                type: 'standard',
                 value,
                 definedAtData: {
                     // importPath cannot be relative to the current file, since the current file is a virtual file

package/dist/esm/shared/route/executeGuardHook.js

@@ -21,7 +21,7 @@ async function executeGuardHook(pageContext, prepareForUserConsumption) {
     const res = prepareForUserConsumption(pageContext);
     if (res)
         pageContextForUserConsumption = res;
-    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook);
+    const hookResult = await executeHook(() => guard(pageContextForUserConsumption), hook, pageContext);
     assertUsage(hookResult === undefined, `${errIntro} ${hook.hookFilePath} returns a value, but guard() shouldn't return any value`);
 }
 function findPageGuard(pageId, pageFilesAll) {

package/dist/esm/shared/route/executeOnBeforeRouteHook.js

@@ -36,7 +36,7 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
     let hookReturn = onBeforeRouteHook.hookFn(pageContext);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
     // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
-    hookReturn = await executeHook(() => hookReturn, onBeforeRouteHook);
+    hookReturn = await executeHook(() => hookReturn, onBeforeRouteHook, pageContext);
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||
         hookReturn === undefined ||

package/dist/esm/utils/getPropAccessNotation.d.ts

@@ -1,2 +1 @@
-export { getPropAccessNotation };
-declare function getPropAccessNotation(key: string): `.${string}` | `[${string}]`;
+export declare function getPropAccessNotation(key: unknown): `.${string}` | `[${string}]`;

package/dist/esm/utils/getPropAccessNotation.js

@@ -1,7 +1,3 @@
-export { getPropAccessNotation };
-function getPropAccessNotation(key) {
-    return isKeyDotNotationCompatible(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
-}
-function isKeyDotNotationCompatible(key) {
-    return /^[a-z0-9\$_]+$/i.test(key);
+export function getPropAccessNotation(key) {
+    return typeof key === 'string' && /^[a-z0-9\$_]+$/i.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
 }

package/dist/esm/utils/projectInfo.d.ts

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.171-commit-ea3808a";
+declare const PROJECT_VERSION: "0.4.171-commit-978d69d";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.171-commit-ea3808a";
+    projectVersion: "0.4.171-commit-978d69d";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-const PROJECT_VERSION = '0.4.171-commit-ea3808a';
+const PROJECT_VERSION = '0.4.171-commit-978d69d';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.171-commit-ea3808a",
+  "version": "0.4.171-commit-978d69d",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -106,6 +106,15 @@
       "types": "./dist/esm/shared/abort.d.ts",
       "default": "./dist/esm/shared/abort.js"
     },
+    "./getPageContext": {
+      "worker": "./dist/esm/shared/getPageContext.js",
+      "edge-light": "./dist/esm/shared/getPageContext.js",
+      "require": "./dist/cjs/shared/getPageContext.js",
+      "node": "./dist/esm/shared/getPageContext.js",
+      "browser": "./dist/esm/shared/getPageContext.js",
+      "types": "./dist/esm/shared/getPageContext.d.ts",
+      "default": "./dist/esm/shared/getPageContext.js"
+    },
     "./__internal": {
       "require": "./dist/cjs/__internal/index.js",
       "node": "./dist/esm/__internal/index.js",