vike 0.4.229 → 0.4.230

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

@@ -2,9 +2,10 @@ import { assertServerRouting } from '../../utils/assertRoutingType.js';
 assertServerRouting();
 import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { assertHook } from '../../shared/hooks/getHook.js';
 import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
+import { execHook } from '../../shared/hooks/execHook.js';
+import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
 // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
 const isProd = import.meta.env.PROD;
 assertSingleInstance_onClientEntryServerRouting(isProd);
@@ -13,7 +14,6 @@ if (import.meta.env.DEV)
 hydrate();
 async function hydrate() {
     const pageContext = await createPageContextClientSide();
-    await executeOnRenderClientHook(pageContext, false);
-    assertHook(pageContext, 'onHydrationEnd');
-    await pageContext.exports.onHydrationEnd?.(pageContext);
+    await executeOnRenderClientHook(pageContext, preparePageContextForPublicUsageClient);
+    await execHook('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
 }

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

@@ -5,13 +5,23 @@ type GlobalContextClientWithServerRouting = GlobalContextSharedPublic & Pick<Glo
 type GlobalContextClientInternal = Awaited<ReturnType<typeof getGlobalContextClientInternal>>;
 declare const getGlobalContextClientInternal: () => Promise<{
     isGlobalContext: true;
+    _isOriginalObject: true;
     _virtualFileExports: unknown;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];
     _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
+    _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
     config: import("../../types/index.js").ConfigResolved;
-    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    pages: {
+        [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+            route: import("../../shared/page-configs/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
 } & {
     isClientSide: true;
 } & object>;

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

@@ -0,0 +1,9 @@
+export { preparePageContextForPublicUsageClient };
+export type { PageContextForPublicUsageClient };
+import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
+import type { PageContextInternalClient_ServerRouting } from '../../shared/types.js';
+import type { PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
+type PageContextForPublicUsageClient = PageContextPrepareMinimum & PageContextInternalClient_ServerRouting & PageConfigUserFriendlyOld;
+declare function preparePageContextForPublicUsageClient<PageContext extends PageContextForPublicUsageClient>(pageContext: PageContext): PageContext & {
+    Page: unknown;
+};

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

@@ -0,0 +1,5 @@
+export { preparePageContextForPublicUsageClient };
+import { preparePageContextForPublicUsageClientShared } from '../shared/preparePageContextForPublicUsageClientShared.js';
+function preparePageContextForPublicUsageClient(pageContext) {
+    return preparePageContextForPublicUsageClientShared(pageContext);
+}

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

@@ -11,3 +11,4 @@ export * from '../../utils/slice.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/augmentType.js';
+export * from '../../utils/changeEnumerable.js';

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

@@ -15,3 +15,4 @@ 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';
 export * from '../../utils/augmentType.js';
+export * from '../../utils/changeEnumerable.js';

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

@@ -4,13 +4,23 @@ export { createGetGlobalContextClient };
 import { type GlobalContextShared } from '../../shared/createGlobalContextShared.js';
 declare function createGetGlobalContextClient<GlobalContextAddendum extends object>(virtualFileExports: unknown, isClientRouting: boolean, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): () => Promise<{
     isGlobalContext: true;
+    _isOriginalObject: true;
     _virtualFileExports: unknown;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];
     _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
+    _userFriendlyConfigsGlobal: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
     config: import("../../types/index.js").ConfigResolved;
-    pages: import("../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    pages: {
+        [k: string]: import("../../shared/page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+            route: import("../../shared/page-configs/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
 } & Awaited<{
     /**
      * Whether the environment is client-side or server-side / pre-rendering.

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

@@ -1,7 +1,7 @@
 export { executeOnRenderClientHook };
 export type { PageContextBeforeRenderClient };
 import type { PageFile, PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
-import { type PageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
+import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
@@ -9,5 +9,5 @@ type PageContextBeforeRenderClient = {
     urlPathname?: string;
     pageId: string;
     _pageConfigs: PageConfigRuntime[];
-} & PageConfigUserFriendlyOld & PageContextForUserConsumptionClientSide;
-declare function executeOnRenderClientHook<PC extends PageContextBeforeRenderClient>(pageContext: PC, isClientRouting: boolean): Promise<void>;
+} & PageConfigUserFriendlyOld & PageContextForPublicUsageClientShared;
+declare function executeOnRenderClientHook<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

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

@@ -1,22 +1,17 @@
 export { executeOnRenderClientHook };
 import { assert, assertUsage } from '../server-routing-runtime/utils.js';
 import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
-import { preparePageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
-import { executeHook } from '../../shared/hooks/executeHook.js';
-async function executeOnRenderClientHook(pageContext, isClientRouting) {
-    const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting);
+import { execHookSingle } from '../../shared/hooks/execHook.js';
+async function executeOnRenderClientHook(pageContext, prepareForPublicUsage) {
     let hook = null;
-    let hookName;
     {
         const renderHook = getHookFromPageContext(pageContext, 'render');
         hook = renderHook;
-        hookName = 'render';
     }
     {
         const renderHook = getHookFromPageContext(pageContext, 'onRenderClient');
         if (renderHook) {
             hook = renderHook;
-            hookName = 'onRenderClient';
         }
     }
     if (!hook) {
@@ -42,16 +37,12 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
             assertUsage(false, errMsg);
         }
     }
-    assert(hook);
-    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, pageContext);
-    assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+    await execHookSingle(hook, pageContext, prepareForPublicUsage);
 }
 function getUrlToShowToUser(pageContext) {
     let url;
-    // try/catch to avoid passToClient assertUsage() (although: this may not be needed anymore, since we're now accessing pageContext and not pageContextForUserConsumption)
+    // try/catch to avoid passToClient assertUsage() (although: this may not be needed anymore, since we're now accessing pageContext and not pageContextForPublicUsage)
     try {
         url =
             // Client Routing

package/dist/esm/client/shared/{loadUserFilesClientSide.d.ts → loadPageConfigsLazyClientSide.d.ts}

@@ -1,4 +1,4 @@
-export { loadUserFilesClientSide };
+export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 export type { PageContextUserFiles };
 import { type PageFile, type PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
@@ -11,5 +11,5 @@ type PageContextUserFiles = {
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: PageConfigGlobalRuntime;
 };
-declare function loadUserFilesClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
+declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/esm/client/shared/{loadUserFilesClientSide.js → loadPageConfigsLazyClientSide.js}

@@ -1,12 +1,12 @@
-export { loadUserFilesClientSide };
+export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
-import { getPageConfigUserFriendly_oldDesign } from '../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getUserFriendlyConfigsPageLazy } from '../../shared/page-configs/getUserFriendlyConfigs.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../server-routing-runtime/utils.js';
 const stamp = '__whileFetchingAssets';
-async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
+async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;
@@ -30,7 +30,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs, pageCo
         }
         throw err;
     }
-    const pageContextExports = getPageConfigUserFriendly_oldDesign(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
+    const pageContextExports = getUserFriendlyConfigsPageLazy(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

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

@@ -0,0 +1,11 @@
+export { preparePageContextForPublicUsageClientShared };
+export { preparePageContextForPublicUsageClientMinimal };
+export type { PageContextForPublicUsageClientShared };
+import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
+import { type PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
+import type { PageContextInternalClient } from '../../shared/types.js';
+type PageContextForPublicUsageClientShared = PageContextPrepareMinimum & PageContextInternalClient & PageConfigUserFriendlyOld;
+declare function preparePageContextForPublicUsageClientShared<PageContext extends PageContextForPublicUsageClientShared>(pageContext: PageContext): PageContext & {
+    Page: unknown;
+};
+declare function preparePageContextForPublicUsageClientMinimal<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext;

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

@@ -0,0 +1,39 @@
+export { preparePageContextForPublicUsageClientShared };
+export { preparePageContextForPublicUsageClientMinimal };
+import { objectAssign } from '../server-routing-runtime/utils.js';
+import { assertPropertyGetters, preparePageContextForPublicUsage } from '../../shared/preparePageContextForPublicUsage.js';
+function preparePageContextForPublicUsageClientShared(pageContext) {
+    // TODO/now use proxy
+    const Page = pageContext.config?.Page ||
+        // TODO/next-major-release: remove
+        pageContext.exports?.Page;
+    objectAssign(pageContext, { Page });
+    // TODO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
+    assertPropertyGetters(pageContext);
+    // TODO/next-major-release: remove
+    // - Requires https://github.com/vikejs/vike-vue/issues/198
+    // - Last time I tried to remove it (https://github.com/vikejs/vike/commit/705fd23598d9d69bf46a52c8550216cd7117ce71) the tests were failing as expected: only the Vue integrations that used shallowReactive() failed.
+    supportVueReactiviy(pageContext);
+    return preparePageContextForPublicUsageClientMinimal(pageContext);
+}
+function preparePageContextForPublicUsageClientMinimal(pageContext) {
+    const pageContextPublic = preparePageContextForPublicUsage(pageContext);
+    return pageContextPublic;
+}
+// With Vue + Cient Routing, the `pageContext` is made reactive:
+// ```js
+// import { reactive } from 'vue'
+// // See /examples/vue-full/renderer/createVueApp.ts
+// const pageContextReactive = reactive(pageContext)
+// ```
+function supportVueReactiviy(pageContext) {
+    resolveGetters(pageContext);
+}
+// Remove propery descriptor getters because they break Vue's reactivity.
+// E.g. resolve the `pageContext.urlPathname` getter.
+function resolveGetters(pageContext) {
+    Object.entries(pageContext).forEach(([key, val]) => {
+        delete pageContext[key];
+        pageContext[key] = val;
+    });
+}

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

@@ -1,10 +1,9 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite, version, createBuilder } from 'vite';
-import assert from 'assert';
 import { isVikeCli } from '../cli/context.js';
 import { isPrerendering } from '../prerender/context.js';
-import { assertVersion } from './utils.js';
+import { assert, assertVersion } from './utils.js';
 /**
  * Programmatically trigger `$ vike build`
  *

package/dist/esm/node/plugin/index.js

@@ -21,6 +21,7 @@ import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.
 import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegression.js';
+import { replaceConstants } from './plugins/replaceConstants.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
@@ -38,7 +39,8 @@ function plugin(vikeVitePluginOptions = {}) {
         envVarsPlugin(),
         fileEnv(),
         workaroundCssModuleHmr(),
-        workaroundVite6HmrRegression()
+        workaroundVite6HmrRegression(),
+        replaceConstants()
     ];
     Object.assign(plugins, { __vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;

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

@@ -27,14 +27,14 @@ function pluginModuleBanner() {
                 if (id.startsWith(config.root))
                     id = id.slice(config.root.length + 1);
                 id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377
-                const s = new MagicString(code);
+                const magicString = new MagicString(code);
                 // Use legal comment so that esbuild doesn't remove it.
                 // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
                 // - https://esbuild.github.io/api/#legal-comments
-                s.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
+                magicString.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
                 return {
-                    code: s.toString(),
-                    map: s.generateMap({ hires: true, source: id })
+                    code: magicString.toString(),
+                    map: magicString.generateMap({ hires: true, source: id })
                 };
             }
         }

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -1,6 +1,6 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, assertIsImportPathNpmPackage, createDebugger, isArray, unique } from '../../utils.js';
+import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, unique } from '../../utils.js';
 import { getVikeConfig, isOverriden } from '../importUserCode/v1-design/getVikeConfig.js';
 import { analyzeClientEntries } from '../build/pluginBuildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
@@ -55,6 +55,11 @@ async function getPageDeps(config, pageConfigs) {
                         return;
                     if (definedAt.definedBy)
                         return;
+                    if (definedAt.importPathAbsolute) {
+                        const npmPackageName = getNpmPackageName(definedAt.importPathAbsolute);
+                        if (npmPackageName && config.optimizeDeps.exclude?.includes(npmPackageName))
+                            return;
+                    }
                     if (definedAt.filePathAbsoluteUserRootDir !== null) {
                         // Vite expects entries to be filesystem absolute paths (surprisingly so).
                         addEntry(definedAt.filePathAbsoluteFilesystem);

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

@@ -1,11 +1,12 @@
 export { envVarsPlugin };
 import MagicString from 'magic-string';
 import { loadEnv } from 'vite';
-import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, lowerFirst } from '../utils.js';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst } from '../utils.js';
 import { getModuleFilePathAbsolute } from '../shared/getFilePath.js';
 import { normalizeId } from '../shared/normalizeId.js';
 import { isViteServerBuild_safe } from '../shared/isViteServerBuild.js';
-// TODO/enventually: (after we implemented vike.config.js)
+import { applyRegExpWithMagicString } from '../shared/applyRegExWithMagicString.js';
+// TODO/enventually:
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
 //   - Or stop using Vite's `mode` implemention and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
@@ -22,7 +23,6 @@ function envVarsPlugin() {
         enforce: 'post',
         configResolved(config_) {
             config = config_;
-            config.command;
             envsAll = loadEnv(config.mode, config.envDir || config.root, '');
             config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
         },
@@ -38,21 +38,22 @@ function envVarsPlugin() {
                 return;
             const isBuild = config.command === 'build';
             const isClientSide = !isViteServerBuild_safe(config, options);
-            const s = new MagicString(code);
-            Object.entries(envsAll)
+            const magicString = new MagicString(code);
+            // Find & check
+            const replacements = Object.entries(envsAll)
                 .filter(([key]) => {
                 // Already handled by Vite
                 const envPrefix = !config.envPrefix ? [] : isArray(config.envPrefix) ? config.envPrefix : [config.envPrefix];
                 return !envPrefix.some((prefix) => key.startsWith(prefix));
             })
-                .forEach(([envName, envVal]) => {
+                .map(([envName, envVal]) => {
                 const envStatement = `import.meta.env.${envName}`;
-                const envStatementRegExStr = escapeRegex(envStatement) + '\\b';
+                const envStatementRegExpStr = escapeRegex(envStatement) + '\\b';
                 // Security check
                 {
                     const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_ALLOWLIST.includes(envName);
                     if (isPrivate && isClientSide) {
-                        if (!new RegExp(envStatementRegExStr).test(code))
+                        if (!new RegExp(envStatementRegExpStr).test(code))
                             return;
                         const modulePath = getModuleFilePathAbsolute(id, config);
                         const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
@@ -70,22 +71,19 @@ function envVarsPlugin() {
                     // Double check
                     assert(!(isPrivate && isClientSide) || !isBuild);
                 }
-                // Apply
-                applyEnvVar(s, envStatementRegExStr, envVal);
+                return { regExpStr: envStatementRegExpStr, replacement: envVal };
+            })
+                .filter(isNotNullish);
+            // Apply
+            replacements.forEach(({ regExpStr, replacement }) => {
+                applyRegExpWithMagicString(magicString, regExpStr, replacement);
             });
-            if (!s.hasChanged())
+            if (!magicString.hasChanged())
                 return null;
             return {
-                code: s.toString(),
-                map: s.generateMap({ hires: true, source: id })
+                code: magicString.toString(),
+                map: magicString.generateMap({ hires: true, source: id })
             };
         }
     };
 }
-function applyEnvVar(s, envStatementRegExStr, envVal) {
-    const envStatementRegEx = new RegExp(envStatementRegExStr, 'g');
-    let match;
-    while ((match = envStatementRegEx.exec(s.original))) {
-        s.overwrite(match.index, match.index + match[0].length, JSON.stringify(envVal));
-    }
-}

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -1,5 +1,5 @@
 export { getVirtualFileImportUserCode };
-import { assert, assertPosixPath, scriptFileExtensions, debugGlob, isVersionOrAbove, assertWarning } from '../../utils.js';
+import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionOrAbove, assertWarning } from '../../utils.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { version as viteVersion } from 'vite';
 import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
@@ -174,7 +174,9 @@ function getGlobRoots(config) {
 }
 function getGlobPath(globRootDir, fileType) {
     assertPosixPath(globRootDir);
-    let globPath = [...globRootDir.split('/'), '**', `*${fileType}.${scriptFileExtensions}`].filter(Boolean).join('/');
+    let globPath = [...globRootDir.split('/'), '**', `*${fileType}.${scriptFileExtensionPattern}`]
+        .filter(Boolean)
+        .join('/');
     if (!globPath.startsWith('/')) {
         globPath = '/' + globPath;
     }

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

@@ -19,6 +19,7 @@ const configDefinitionsBuiltIn = {
     },
     onCreatePageContext: {
         env: { server: true, client: true },
+        // Required because `onCreatePageContext()` is called before routing
         global: true,
         cumulative: true
     },
@@ -55,6 +56,10 @@ const configDefinitionsBuiltIn = {
     data: {
         env: { server: true }
     },
+    onData: {
+        env: { server: true, client: true },
+        cumulative: true
+    },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
         env: { server: true, client: 'if-client-routing' },
         eager: true

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

@@ -1,7 +1,7 @@
 export { crawlPlusFiles };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
-import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish } from '../../../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish } from '../../../../utils.js';
 import path from 'path';
 import { glob } from 'tinyglobby';
 import { exec } from 'child_process';
@@ -115,7 +115,7 @@ async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
 }
 // Same as gitLsFiles() but using tinyglobby
 async function tinyglobby(userRootDir, ignorePatterns) {
-    const pattern = `**/+*.${scriptFileExtensions}`;
+    const pattern = `**/+*.${scriptFileExtensionPattern}`;
     const options = {
         ignore: ignorePatterns,
         cwd: userRootDir,

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

@@ -7,7 +7,7 @@ import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsImportPathNpmPackage, genPromise, isVitest, isImportPathNpmPackageOrPathAlias, isImportPathRelative, requireResolveOptionalDir } from '../../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsImportPathNpmPackage, genPromise, isVitest, isImportPathNpmPackageOrPathAlias, isImportPathRelative, requireResolveOptionalDir } from '../../../../utils.js';
 import { transformPointerImports } from './pointerImports.js';
 import sourceMapSupport from 'source-map-support';
 import { getFilePathAbsoluteUserRootDir } from '../../../../shared/getFilePath.js';
@@ -26,7 +26,7 @@ async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig,
     }
     const { promise, resolve } = genPromise();
     esbuildCache.transpileCache[filePathAbsoluteFilesystem] = promise;
-    assertUsage(isPlainJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
+    assertUsage(isPlainScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
         assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
@@ -152,7 +152,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     const isVikeExtensionImport = (path.startsWith('vike-') && path.endsWith('/config')) || importPathResolved.endsWith('+config.js');
                     const isPointerImport = transformImports === 'all' ||
                         // .jsx, .vue, .svg, ... => obviously not config code => pointer import
-                        !isPlainJavaScriptFile(importPathResolved) ||
+                        !isPlainScriptFile(importPathResolved) ||
                         // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a config has been set by the user or by a Vike extension).
                         //  - Should we stop doing this? (And instead let Node.js directly load Vike extensions.)
                         //    - In principle, we can use the setting 'name' value of Vike extensions.

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

@@ -11,7 +11,7 @@ export type { VikeConfigObject };
 import type { PageConfigGlobalBuildTime, ConfigValueSource, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type ConfigDefinitions, type ConfigDefinitionInternal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import type { ResolvedConfig, UserConfig } from 'vite';
-import { type PageConfigUserFriendly, type PageConfigsUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { type PageConfigUserFriendly, type PageConfigsUserFriendly } from '../../../../../shared/page-configs/getUserFriendlyConfigs.js';
 import { type PlusFile } from './getVikeConfig/getPlusFilesAll.js';
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];

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

@@ -21,7 +21,7 @@ import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsRequire } from './getVikeConfig/assertExtensions.js';
-import { getPageConfigGlobalUserFriendly, getPageConfigUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from '../../../../../shared/page-configs/getUserFriendlyConfigs.js';
 import { getConfigValuesBase, isJsonValue } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
 import { getEnvVarObject } from '../../../shared/getEnvVarObject.js';
@@ -137,7 +137,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                global: getPageConfigGlobalUserFriendly({ pageConfigGlobalValues: {} }),
+                global: getUserFriendlyConfigsGlobal({ pageConfigGlobalValues: {} }),
                 pages: {},
                 vikeConfigDependencies: new Set()
             };
@@ -158,13 +158,19 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
     // global
     const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
-    const global = getPageConfigGlobalUserFriendly({ pageConfigGlobalValues });
+    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({ pageConfigGlobalValues });
     // pages
-    const pages = objectFromEntries(pageConfigs.map((pageConfig) => {
+    const userFriendlyConfigsPageEager = objectFromEntries(pageConfigs.map((pageConfig) => {
         const pageConfigValues = getConfigValues(pageConfig, true);
-        return getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues);
+        return getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
-    return { pageConfigs, pageConfigGlobal, global, pages, vikeConfigDependencies: esbuildCache.vikeConfigDependencies };
+    return {
+        pageConfigs,
+        pageConfigGlobal,
+        global: userFriendlyConfigsGlobal,
+        pages: userFriendlyConfigsPageEager,
+        vikeConfigDependencies: esbuildCache.vikeConfigDependencies
+    };
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const plusFilesAllOrdered = Object.values(plusFilesAll)

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

@@ -0,0 +1,3 @@
+export { replaceConstants };
+import type { Plugin } from 'vite';
+declare function replaceConstants(): Plugin;