vike 0.4.225-commit-37a36a5 → 0.4.225-commit-b8fc36e

package/dist/esm/node/api/prepareViteApiCall.js

@@ -4,61 +4,84 @@ export { assertViteRoot };
 export { normalizeViteRoot };
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
 import { clearContextApiOperation, setContextApiOperation } from './context.js';
-import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfig2, getVikeConfigFromCliOrEnv } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import path from 'path';
-import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './utils.js';
+import { assert, assertUsage, getGlobalObject, isObject, pick, toPosixPath } from './utils.js';
 import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
+import { getEnvVarObject } from '../plugin/shared/getEnvVarObject.js';
 const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
 async function prepareViteApiCall(options, operation) {
     clear();
     setContextApiOperation(operation, options);
-    const viteConfigFromOptions = options.viteConfig;
-    return enhanceViteConfig(viteConfigFromOptions, operation);
+    const viteConfigFromUserApiOptions = options.viteConfig;
+    return resolveConfigs(viteConfigFromUserApiOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
     clearContextApiOperation();
     clearGlobalContext();
 }
-async function enhanceViteConfig(viteConfigFromOptions, operation) {
-    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
-    await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
+async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
+    const viteInfo = await getViteInfo(viteConfigFromUserApiOptions, operation);
+    await assertViteRoot2(viteInfo.root, viteInfo.viteConfigFromUserEnhanced, operation);
     const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
-    const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
+    const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
     return {
         vikeConfig,
-        viteConfigEnhanced
+        viteConfigFromUserEnhanced
     };
 }
-function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
+// Apply +vite
+// - For example, Vike extensions adding Vite plugins
+function applyVikeViteConfig(viteConfigFromUserEnhanced, vikeConfig) {
     const viteConfigs = vikeConfig.global._from.configsCumulative.vite;
     if (!viteConfigs)
-        return viteConfigEnhanced;
+        return viteConfigFromUserEnhanced;
     viteConfigs.values.forEach((v) => {
         assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
-        viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, v.value);
+        viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, v.value);
         assertUsage(!findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
-    return viteConfigEnhanced;
+    return viteConfigFromUserEnhanced;
 }
 async function getViteRoot(operation) {
     if (!globalObject.root)
-        await getInfoFromVite(undefined, operation);
+        await getViteInfo(undefined, operation);
     assert(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfigFromOptions, operation) {
-    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
-    const root = normalizeViteRoot(
-    // `viteConfigFromOptions.root` before `viteConfigFromUserViteFile.root` replicates Vite's precedence:
+async function getViteInfo(viteConfigFromUserApiOptions, operation) {
+    let viteConfigFromUserEnhanced = viteConfigFromUserApiOptions;
+    // Precedence:
+    //  1) viteConfigFromUserEnvVar (highest precendence)
+    //  2) viteConfigFromUserVikeConfig
+    //  2) viteConfigFromUserApiOptions
+    //  3) viteConfigFromUserViteFile (lowest precendence)
+    // Resolve Vike's +mode setting
+    {
+        const viteConfigFromUserVikeConfig = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, ['mode']);
+        if (Object.keys(viteConfigFromUserVikeConfig).length > 0) {
+            viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserVikeConfig);
+        }
+    }
+    // Resolve VITE_CONFIG
+    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar) {
+        viteConfigFromUserEnhanced = mergeConfig(viteConfigFromUserEnhanced ?? {}, viteConfigFromUserEnvVar);
+    }
+    // Resolve vite.config.js
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromUserEnhanced, operation);
+    // Correct precedence, replicates Vite:
     // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    viteConfigFromOptions?.root ?? viteConfigFromUserViteFile?.root ?? process.cwd());
+    const viteConfigResolved = mergeConfig(viteConfigFromUserViteFile ?? {}, viteConfigFromUserEnhanced ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
     globalObject.root = root;
+    // - Find options `vike(options)` set in vite.config.js
+    //   - TODO/next-major: remove
+    // - Add Vike's Vite plugin if missing
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfigFromOptions;
-    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
-    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
+    const found = findVikeVitePlugin(viteConfigResolved);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -66,16 +89,16 @@ async function getInfoFromVite(viteConfigFromOptions, operation) {
         // Add Vike to plugins if not present.
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await import('../plugin/index.js');
-        viteConfigEnhanced = {
-            ...viteConfigFromOptions,
-            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
+        viteConfigFromUserEnhanced = {
+            ...viteConfigFromUserEnhanced,
+            plugins: [...(viteConfigFromUserEnhanced?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced);
+        const res = findVikeVitePlugin(viteConfigFromUserEnhanced);
         assert(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     assert(vikeVitePluginOptions);
-    return { root, vikeVitePluginOptions, viteConfigEnhanced };
+    return { root, vikeVitePluginOptions, viteConfigFromUserEnhanced };
 }
 function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
@@ -93,8 +116,8 @@ function findVikeVitePlugin(viteConfig) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfigFromOptions, operation) {
-    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
+async function loadViteConfigFile(viteConfigFromUserApiOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromUserApiOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {
@@ -126,8 +149,8 @@ function normalizeViteRoot(root) {
     path.resolve(root));
 }
 const errMsg = `A Vite plugin is modifying Vite's setting ${pc.cyan('root')} which is forbidden`;
-async function assertViteRoot2(root, viteConfigEnhanced, operation) {
-    const args = getResolveConfigArgs(viteConfigEnhanced, operation);
+async function assertViteRoot2(root, viteConfigFromUserEnhanced, operation) {
+    const args = getResolveConfigArgs(viteConfigFromUserEnhanced, operation);
     // We can eventually this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
     const viteConfigResolved = await resolveConfig(...args);
     assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);

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

@@ -8,8 +8,8 @@ import { prepareViteApiCall } from './prepareViteApiCall.js';
  * https://vike.dev/api#prerender
  */
 async function prerender(options = {}) {
-    const { viteConfigEnhanced } = await prepareViteApiCall(options, 'prerender');
-    options.viteConfig = viteConfigEnhanced;
+    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'prerender');
+    options.viteConfig = viteConfigFromUserEnhanced;
     const { viteConfig } = await runPrerenderFromAPI(options);
     return {
         viteConfig

package/dist/esm/node/api/preview.js

@@ -7,8 +7,8 @@ import { preview as previewVite } from 'vite';
  * https://vike.dev/api#preview
  */
 async function preview(options = {}) {
-    const { viteConfigEnhanced } = await prepareViteApiCall(options, 'preview');
-    const server = await previewVite(viteConfigEnhanced);
+    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'preview');
+    const server = await previewVite(viteConfigFromUserEnhanced);
     return {
         viteServer: server,
         viteConfig: server.config

package/dist/esm/node/api/utils.d.ts

@@ -3,3 +3,4 @@ export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/path.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/assertVersion.js';
+export * from '../../utils/pick.js';

package/dist/esm/node/api/utils.js

@@ -7,3 +7,4 @@ export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/path.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/assertVersion.js';
+export * from '../../utils/pick.js';

package/dist/esm/node/cli/parseCli.js

@@ -6,7 +6,7 @@ const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
     { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
-    { name: 'prerender', desc: 'Pre-render pages (only needed when partial.disableAutoRun is true)' }
+    { name: 'prerender', desc: 'Pre-render pages (only needed when prerender.disableAutoRun is true)' }
 ];
 function parseCli() {
     const command = getCommand();
@@ -57,10 +57,16 @@ function showHelp() {
         `vike@${PROJECT_VERSION}`,
         '',
         'Usage:',
-        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${pc.dim('$')} ${pc.bold(`vike ${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${pc.dim(`# ${c.desc}`)}`),
+        ...[...commands, { name: '-v', desc: "Print Vike's installed version" }].map((c) => `  ${pc.dim('$')} vike ${c.name.startsWith('-') ? pc.cyan(`${c.name}`) : pc.bold(`${c.name}`)}${' '.repeat(nameMaxLength - c.name.length)}${TAB}${pc.dim(`# ${c.desc}`)}`),
         '',
-        `Vike settings can be passed over the ${pc.cyan('VIKE_CONFIG')} environment variable or as ${pc.cyan('CLI options')} such as --host.`,
-        `Vite settings can be passed over the ${pc.cyan('VITE_CONFIG')} environment variable.`,
+        'Common CLI options:',
+        [`vike dev ${pc.cyan('--host')}`, `vike dev ${pc.cyan('--port')} 80`, `vike build ${pc.cyan('--mode')} staging`]
+            .map((o) => `  ${pc.dim('$')} ${o}`)
+            .join('\n'),
+        '',
+        `More Vike settings can be passed over the ${pc.cyan('VIKE_CONFIG')} environment variable or as ${pc.cyan('CLI options')}.`,
+        `More Vite settings can be passed over the ${pc.cyan('VITE_CONFIG')} environment variable.`,
+        ``,
         `See ${pc.underline('https://vike.dev/cli')} for more information.`
     ].join('\n'));
     process.exit(1);

package/dist/esm/node/plugin/plugins/build/pluginAutoFullBuild.js

@@ -124,8 +124,8 @@ function isPrerenderForceExit() {
 }
 function getFullBuildInlineConfig(config) {
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    if (config._viteConfigEnhanced) {
-        return config._viteConfigEnhanced;
+    if (config._viteConfigFromUserEnhanced) {
+        return config._viteConfigFromUserEnhanced;
     }
     else {
         return {

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -10,7 +10,7 @@ declare module 'vite' {
         _vikeVitePluginOptions?: unknown;
         _root?: string;
         _baseViteOriginal?: string;
-        _viteConfigEnhanced?: InlineConfig;
+        _viteConfigFromUserEnhanced?: InlineConfig;
         _vike?: VikeConfigPublic;
         _vikeConfigObject?: VikeConfigObject;
     }

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

@@ -1,13 +1,11 @@
 export { commonConfig };
 export { getVikeConfigPublic };
-import { mergeConfig } from 'vite';
 import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
 import path from 'path';
 import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
-import { getEnvVarObject } from '../shared/getEnvVarObject.js';
 import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
 import { getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
@@ -91,10 +89,6 @@ function commonConfig(vikeVitePluginOptions) {
                         // Set `--host` for Docker/Podman
                         setDefault('host', true, configFromUser, configFromVike);
                     }
-                    // VITE_CONFIG
-                    const configFromEnvVar = getEnvVarObject('VITE_CONFIG');
-                    if (configFromEnvVar)
-                        configFromVike = mergeConfig(configFromVike, configFromEnvVar);
                     return configFromVike;
                 }
             }

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

@@ -131,6 +131,10 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true
     },
+    mode: {
+        env: { config: true },
+        global: true
+    },
     injectScriptsAt: {
         env: { server: true }
     },

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

@@ -5,6 +5,7 @@ export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
+export { getVikeConfigFromCliOrEnv };
 export { isOverriden };
 export type { VikeConfigObject };
 import type { PageConfigGlobalBuildTime, ConfigValueSource, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
@@ -26,6 +27,13 @@ declare function getVikeConfig(config: ResolvedConfig, { doNotRestartViteOnError
 declare function getVikeConfig2(userRootDir: string, isDev: boolean, vikeVitePluginOptions: unknown): Promise<VikeConfigObject>;
 declare function getVikeConfigOptional(): Promise<null | VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig | UserConfig): boolean;
+declare function getVikeConfigFromCliOrEnv(): {
+    vikeConfigFromCliOrEnv: {
+        [x: string]: unknown;
+    };
+    configFromCliOptions: import("../../../../cli/parseCli.js").CliOptions | null;
+    configFromEnvVar: Record<string, unknown> | null;
+};
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitions, configName: string): ConfigDefinitionInternal | null;
 declare function getConfVal(plusFile: PlusFile, configName: string): null | {
     value: unknown;

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

@@ -5,6 +5,7 @@ export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
+export { getVikeConfigFromCliOrEnv };
 export { isOverriden };
 import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance } from '../../../utils.js';
 import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
@@ -305,7 +306,7 @@ function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDef
                 : 'to a value that is global';
             const what = isConditionallyGlobal ? 'global values' : pc.cyan(configName);
             const errEnd = configFilePathsGlobal.length > 0
-                ? `define ${what} at a global config file such as ${joinEnglish(configFilePathsGlobal, 'or')} instead`
+                ? `define ${what} at a global config file such as ${joinEnglish(configFilePathsGlobal.map(pc.bold), 'or')} instead`
                 : `create a global config file (e.g. /pages/+config.js) and define ${what} there instead`;
             // When updating this error message => also update error message at https://vike.dev/warning/global-config
             const errMsg = `${errBeg} ${errMid}: ${errEnd} (https://vike.dev/warning/global-config).`;
@@ -390,15 +391,14 @@ function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
     if (apiOperation?.options.vikeConfig) {
         addSources(apiOperation.options.vikeConfig, { definedBy: 'api', operation: apiOperation.operation }, false);
     }
+    const { configFromCliOptions, configFromEnvVar } = getVikeConfigFromCliOrEnv();
     // Vike CLI options
-    const cliOptions = getCliOptions();
-    if (cliOptions) {
-        addSources(cliOptions, { definedBy: 'cli' }, true);
+    if (configFromCliOptions) {
+        addSources(configFromCliOptions, { definedBy: 'cli' }, true);
     }
     // VIKE_CONFIG [highest precedence]
-    const configFromEnv = getEnvVarObject('VIKE_CONFIG');
-    if (configFromEnv) {
-        addSources(configFromEnv, { definedBy: 'env' }, false);
+    if (configFromEnvVar) {
+        addSources(configFromEnvVar, { definedBy: 'env' }, false);
     }
     return;
     function addSources(configValues, definedBy, exitOnError) {
@@ -411,6 +411,19 @@ function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
         });
     }
 }
+function getVikeConfigFromCliOrEnv() {
+    const configFromCliOptions = getCliOptions();
+    const configFromEnvVar = getEnvVarObject('VIKE_CONFIG');
+    const vikeConfigFromCliOrEnv = {
+        ...configFromCliOptions, // Lower precedence
+        ...configFromEnvVar // Higher precedence
+    };
+    return {
+        vikeConfigFromCliOrEnv,
+        configFromCliOptions,
+        configFromEnvVar
+    };
+}
 function getSourceNonConfigFile(configName, value, definedAt) {
     assert(includes(objectKeys(configDefinitionsBuiltIn), configName));
     const configDef = configDefinitionsBuiltIn[configName];

package/dist/esm/node/plugin/shared/getEnvVarObject.js

@@ -18,8 +18,15 @@ function parseJson5(valueStr, what) {
         value = JSON5.parse(valueStr);
     }
     catch (err) {
+        if (isNotJavaScriptLike(valueStr)) {
+            // Interpret as string
+            return valueStr;
+        }
         console.error(err);
         assertUsage(false, `Cannot parse ${pc.cyan(what)} (see error above) because it's set to the following which isn't a valid JSON5 string: ${pc.bold(valueStr)}`);
     }
     return value;
 }
+function isNotJavaScriptLike(valueStr) {
+    return ![':', ',', '{', '}', '(', ')'].some((c) => valueStr.includes(c));
+}

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

@@ -15,8 +15,8 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     };
     let defaultLocalValue = false;
     {
-        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.value !== null)[0];
-        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.value ?? defaultValueForObject))) {
+        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.enable !== null)[0];
+        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.enable ?? defaultValueForObject))) {
             defaultLocalValue = true;
         }
     }
@@ -47,7 +47,7 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const values = configValue.value;
     assert(isArray(values));
     const value = values[0];
-    // TODO/now I believe this assert() can fail
+    // If it's set to an object in a local config then Vike considers it a global config and it's skipped from local inheritance, thus we can assume the value to be a boolean.
     assert(typeof value === 'boolean');
     assert(isArray(configValue.definedAtData));
     const prerenderConfigLocal = { value };

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

@@ -38,8 +38,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await prepareViteApiCall({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
+        const { viteConfigFromUserEnhanced } = await prepareViteApiCall({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigFromUserEnhanced }, '$ vike prerender');
     }
     catch (err) {
         console.error(err);
@@ -304,20 +304,16 @@ async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNo
     })));
 }
 async function createPageContext(urlOriginal, prerenderContext, globalContext) {
-    const pageContext = {
+    const pageContextInit = { urlOriginal };
+    objectAssign(pageContextInit, prerenderContext.pageContextInit);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true, {});
+    assert(pageContext.isPrerendering === true);
+    objectAssign(pageContext, {
         _urlHandler: null,
         _urlRewrite: null,
         _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
-    };
-    const pageContextInit = {
-        urlOriginal
-    };
-    objectAssign(pageContextInit, prerenderContext.pageContextInit);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        objectAssign(pageContext, pageContextInitEnhanced);
-    }
+    });
     return pageContext;
 }
 async function callOnPrerenderStartHook(prerenderContext, globalContext) {

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

@@ -1,6 +1,7 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
 export type { PageContextSerialization };
+export { getPropKeys };
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 type PageContextSerialization = {
@@ -20,3 +21,4 @@ declare function serializePageContextAbort(pageContext: Record<string, unknown>
 } | {
     abortStatusCode: number;
 })): string;
+declare function getPropKeys(prop: string): string[];

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

@@ -1,11 +1,13 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
+// For ./serializePageContextClientSide.spec.ts
+export { getPropKeys };
 import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
-import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, unique } from '../utils.js';
+import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, isObject, unique } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
-import { notSerializable } from '../../../shared/notSerializable.js';
+import { NOT_SERIALIZABLE } from '../../../shared/NOT_SERIALIZABLE.js';
 import { pageContextInitIsPassedToClient } from '../../../shared/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 const PASS_TO_CLIENT = [
@@ -25,12 +27,8 @@ const PASS_TO_CLIENT = [
 const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
-    const pageContextClient = {};
-    passToClient.forEach((prop) => {
-        // We set non-existing props to `undefined`, in order to pass the list of passToClient values to the client-side
-        pageContextClient[prop] = pageContext[prop];
-    });
-    if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
+    const pageContextClient = applyPassToClient(passToClient, pageContext);
+    if (passToClient.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient] = true;
     }
     let pageContextSerialized;
@@ -42,14 +40,15 @@ function serializePageContextClientSide(pageContext) {
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const propName1 = getPropAccessNotation(prop);
-            const propName2 = JSON.stringify(prop);
-            const varName = `pageContext${propName1}`;
+            const res = getPropVal(pageContext, prop);
+            if (!res)
+                return;
+            const { value } = res;
+            const varName = `pageContext${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
-                serialize(pageContext[prop], varName);
+                serialize(value, varName);
             }
             catch (err) {
-                hasWarned = true;
                 propsNonSerializable.push(prop);
                 // useConfig() wrong usage
                 if (prop === '_configFromHook') {
@@ -62,7 +61,7 @@ function serializePageContextClientSide(pageContext) {
                 // Non-serializable pageContext set by the user
                 let msg = [
                     `${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')}.`
+                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`
                 ].join(' ');
                 if (isJsonSerializerError(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
@@ -75,11 +74,12 @@ function serializePageContextClientSide(pageContext) {
                 }
                 // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
                 assertWarning(false, msg, { onlyOnce: false });
+                hasWarned = true;
             }
         });
         assert(hasWarned);
         propsNonSerializable.forEach((prop) => {
-            pageContextClient[prop] = notSerializable;
+            pageContextClient[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
         });
         try {
             pageContextSerialized = serialize(pageContextClient);
@@ -138,3 +138,57 @@ function serializePageContextAbort(pageContext) {
     }
     return serialize(pageContext);
 }
+function applyPassToClient(passToClient, pageContext) {
+    const pageContextClient = {};
+    passToClient.forEach((prop) => {
+        // Get value from pageContext
+        const res = getPropVal(pageContext, prop);
+        if (!res)
+            return;
+        const { value } = res;
+        // Set value to pageContextClient
+        setPropVal(pageContextClient, prop, value);
+    });
+    return pageContextClient;
+}
+// Get a nested property from an object using a dot-separated path such as 'user.id'
+function getPropVal(obj, prop) {
+    const keys = getPropKeys(prop);
+    let value = obj;
+    for (const key of keys) {
+        if (isObject(value) && key in value) {
+            value = value[key];
+        }
+        else {
+            return null; // Property or intermediate property doesn't exist
+        }
+    }
+    return { value };
+}
+// Set a nested property in an object using a dot-separated path such as 'user.id'
+function setPropVal(obj, prop, val) {
+    const keys = getPropKeys(prop);
+    let currentObj = obj;
+    // Creating intermediate objects if necessary
+    for (let i = 0; i <= keys.length - 2; i++) {
+        const key = keys[i];
+        if (!(key in currentObj)) {
+            // Create intermediate object
+            currentObj[key] = {};
+        }
+        if (!isObject(currentObj[key])) {
+            // Skip value upon data structure conflict
+            return;
+        }
+        currentObj = currentObj[key];
+    }
+    // Set the final key to the value
+    const finalKey = keys[keys.length - 1];
+    currentObj[finalKey] = val;
+}
+function getPropKeys(prop) {
+    // Like `prop.split('.')` but with added support for `\` escaping, see serializePageContextClientSide.spec.ts
+    return prop
+        .split(/(?<!\\)\./) // Split on unescaped dots
+        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
+}

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

@@ -7,5 +7,8 @@ function preparePageContextForUserConsumptionServerSide(pageContext) {
     assert(isPlainObject(pageContext.routeParams));
     assert('Page' in pageContext);
     assert(typeof pageContext.isClientSideNavigation === 'boolean');
+    assert(pageContext._isPageContextObject);
+    assert(pageContext.isClientSide === false);
+    assert(typeof pageContext.isPrerendering === 'boolean');
     preparePageContextForUserConsumption(pageContext);
 }