vike 0.4.237-commit-e549c30 → 0.4.237-commit-fd8294f

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js

@@ -1,28 +1,47 @@
 export { getConfigValueSourcesRelevant };
+export { getConfigValueSourceRelevantAnyEnv };
 export { isRuntimeEnvMatch };
-import { assert } from '../../utils.js';
+export { isConfigSourceValueNull };
+import { assert, assertIsNotBrowser } from '../../utils.js';
+assertIsNotBrowser();
 function getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig) {
     const configDef = pageConfig.configDefinitions[configName];
     assert(configDef);
     let sourcesRelevant = pageConfig.configValueSources[configName];
     if (!sourcesRelevant)
         return [];
-    if (!configDef.cumulative) {
+    // Ignore configs with value `undefined`
+    sourcesRelevant = sourcesRelevant.filter((source) => !isConfigSourceValueUndefined(source));
+    // Environment filtering
+    sourcesRelevant = sourcesRelevant.filter((source) => isRuntimeEnvMatch(source.configEnv, runtimeEnv));
+    // Overriding - non-cumulative configs
+    if (!configDef.cumulative && sourcesRelevant.length > 1) {
         const source = sourcesRelevant[0];
-        if (source) {
-            sourcesRelevant = [source];
-        }
-        else {
-            assert(sourcesRelevant.length === 0);
-        }
+        assert(source);
+        sourcesRelevant = [source];
     }
-    else {
-        // isOverridden() must be called before isRuntimeEnvMatch() is called (otherwise isOverridden() will return a wrong value)
-        sourcesRelevant = sourcesRelevant.filter((source) => !isOverridden(source, configName, pageConfig));
+    // Overriding - cumulative configs
+    if (configDef.cumulative && sourcesRelevant.length > 0) {
+        sourcesRelevant = applyFilenameSuffix(sourcesRelevant);
     }
-    sourcesRelevant = sourcesRelevant.filter((source) => isRuntimeEnvMatch(source.configEnv, runtimeEnv));
     return sourcesRelevant;
 }
+function getConfigValueSourceRelevantAnyEnv(configName, pageConfig) {
+    const configDef = pageConfig.configDefinitions[configName];
+    assert(configDef);
+    assert(!configDef.cumulative); // So far, this function is only used by non-cumulative configs
+    let sourcesRelevant = pageConfig.configValueSources[configName];
+    if (!sourcesRelevant)
+        return null;
+    // Ignore configs with value `undefined`
+    sourcesRelevant = sourcesRelevant.filter((source) => !isConfigSourceValueUndefined(source));
+    const source = sourcesRelevant[0];
+    if (!source)
+        return null;
+    if (isConfigSourceValueNull(source))
+        return null;
+    return source;
+}
 function isRuntimeEnvMatch(configEnv, runtimeEnv) {
     if ('isForConfig' in runtimeEnv)
         return !!configEnv.config;
@@ -52,14 +71,25 @@ function isRuntimeEnvMatch(configEnv, runtimeEnv) {
     }
     return true;
 }
-function isOverridden(source, configName, pageConfig) {
-    const configDef = pageConfig.configDefinitions[configName];
-    assert(configDef);
-    if (configDef.cumulative)
-        return false;
-    const sources = pageConfig.configValueSources[configName];
-    assert(sources);
-    const idx = sources.indexOf(source);
-    assert(idx >= 0);
-    return idx > 0;
+// Setting a config to `undefined` should be equivalent to not setting it at all
+function isConfigSourceValueUndefined(source) {
+    if (!source.valueIsLoaded)
+        return null;
+    return source.value === undefined;
+}
+// Setting a config to `null` enables the user to suppress inherited config by overriding it with `null` (this only works when setting the config value to `null` inside a +config.js file — it doesn't work when setting the config value to `null` with a +{configName}.js file).
+function isConfigSourceValueNull(source) {
+    if (!source.valueIsLoaded)
+        return null;
+    return source.value === null;
+}
+function applyFilenameSuffix(sourcesRelevant) {
+    const getFileName = (source) => source.plusFile?.filePath.fileName ?? '';
+    // Apply `clear`: truncate at first clear file
+    const clearIndex = sourcesRelevant.findIndex((source) => getFileName(source).includes('.clear.'));
+    if (clearIndex !== -1)
+        sourcesRelevant = sourcesRelevant.slice(0, clearIndex + 1);
+    // Apply `default`: exclude defaults if any non-defaults exist, otherwise keep only first default
+    const nonDefaults = sourcesRelevant.filter((source) => !getFileName(source).includes('.default.'));
+    return nonDefaults.length > 0 ? nonDefaults : sourcesRelevant.slice(0, 1);
 }

package/dist/esm/node/vite/shared/getOutDirs.js

@@ -7,7 +7,7 @@ import { isViteServerSide, isViteServerSide_withoutEnv } from './isViteServerSid
 const debug = createDebugger('vike:outDir');
 function getOutDirs(configGlobal, viteEnv) {
     debug('getOutDirs()', new Error().stack);
-    const outDir = getOutDirFromResolvedConfig(configGlobal);
+    const outDir = getOutDirFromResolvedConfig(configGlobal, viteEnv);
     assertOutDirResolved(outDir, configGlobal, viteEnv);
     const outDirs = getOutDirsAll(outDir, configGlobal.root);
     assertNormalization(outDirs.outDirRoot);
@@ -114,7 +114,8 @@ function assertOutDirResolved(outDir, configGlobal, viteEnv) {
     assert('/client'.length === '/server'.length);
     const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
     const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
-    if (isViteServerSide_withoutEnv(configGlobal, viteEnv)) {
+    const isServerSide = isViteServerSide_withoutEnv(configGlobal, viteEnv);
+    if (isServerSide) {
         assertUsage(outDir.endsWith('/server'), wrongUsage);
     }
     else {
@@ -128,8 +129,8 @@ function getOutDirFromViteUserConfig(config) {
     outDir = normalizeOutDir(outDir);
     return outDir;
 }
-function getOutDirFromResolvedConfig(config) {
-    let outDir = config.build.outDir;
+function getOutDirFromResolvedConfig(config, viteEnv) {
+    let outDir = viteEnv?.config.build?.outDir ?? config.build.outDir;
     assert(outDir);
     outDir = normalizeOutDir(outDir);
     return outDir;

package/dist/esm/node/vite/shared/isViteServerSide.d.ts

@@ -9,8 +9,8 @@ type ViteEnv = {
     name?: string;
     config: EnvironmentOptions | Environment['config'];
 };
-declare function isViteServerSide_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv): boolean;
 declare function isViteServerSide(configGlobal: ResolvedConfig | UserConfig, viteEnv: ViteEnv): boolean;
+declare function isViteServerSide_withoutEnv(configGlobal: ResolvedConfig | UserConfig, viteEnv?: ViteEnv | undefined): boolean;
 declare function isViteClientSide(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_onlySsrEnv(configGlobal: ResolvedConfig, viteEnv: ViteEnv): boolean;
 declare function isViteServerSide_extraSafe(config: ResolvedConfig, options: {

package/dist/esm/node/vite/shared/isViteServerSide.js

@@ -4,16 +4,16 @@ export { isViteServerSide_withoutEnv };
 export { isViteServerSide_onlySsrEnv };
 export { isViteServerSide_extraSafe };
 import { assert } from '../../../utils/assert.js';
-function isViteServerSide_withoutEnv(configGlobal, viteEnv) {
+function isViteServerSide_impl(configGlobal, viteEnv) {
     assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
     const isServerSide1 = !viteEnv?.config.consumer ? null : viteEnv.config.consumer !== 'client';
-    const isServerSide2 = !viteEnv?.name ? null : viteEnv.name !== 'client'; // I can't think of a use case for creating another client-side environment
-    const isServerSide3 = !viteEnv ? null : !!viteEnv.config.build?.ssr;
-    const isServerSide4 = !!configGlobal.build?.ssr;
+    const isServerSide2 = !viteEnv?.config.build ? null : getBuildSsrValue(viteEnv.config.build.ssr);
+    const isServerSide3 = !configGlobal.build ? null : getBuildSsrValue(configGlobal.build.ssr);
+    const isServerSide4 = viteEnv?.name === 'ssr' ? true : viteEnv?.name === 'client' ? false : null;
     const debug = {
-        envIsUndefined: !viteEnv,
-        envName: viteEnv?.name ?? null,
-        envConsumer: viteEnv?.config.consumer ?? null,
+        viteEnvIsUndefined: !viteEnv,
+        viteEnvName: viteEnv?.name ?? null,
+        viteEnvConsumer: viteEnv?.config.consumer ?? null,
         configEnvBuildSsr: viteEnv?.config.build?.ssr ?? null,
         configGlobalBuildSsr: configGlobal.build?.ssr ?? null,
         isServerSide1,
@@ -22,25 +22,36 @@ function isViteServerSide_withoutEnv(configGlobal, viteEnv) {
         isServerSide4,
     };
     if (isServerSide1 !== null) {
-        assert(isServerSide1 === isServerSide2 || isServerSide2 === null, debug);
+        // assert(isServerSide1 === isServerSide4 || isServerSide4 === null, debug)
         /* This assertion can fail, seems to be a Vite bug?
-        assert(isServerSide1 === isServerSide3, debug)
+        assert(isServerSide1 === isServerSide2, debug)
         */
         return isServerSide1;
     }
     if (isServerSide2 !== null) {
-        /* This assertion can fail, seems to be a Vite bug?
-        assert(isServerSide2 === isServerSide3, debug)
-        */
+        // assert(isServerSide2 === isServerSide4 || isServerSide4 === null, debug)
         return isServerSide2;
     }
     if (isServerSide3 !== null) {
+        // assert(isServerSide3 === isServerSide4 || isServerSide4 === null, debug)
         return isServerSide3;
     }
-    return isServerSide4;
+    if (isServerSide4 !== null) {
+        return isServerSide4;
+    }
+    assert(!viteEnv);
+    return !!configGlobal.build?.ssr;
+}
+function getBuildSsrValue(buildSsr) {
+    if (buildSsr === undefined)
+        return null;
+    return !!buildSsr;
 }
 function isViteServerSide(configGlobal, viteEnv) {
-    return isViteServerSide_withoutEnv(configGlobal, viteEnv);
+    return isViteServerSide_impl(configGlobal, viteEnv);
+}
+function isViteServerSide_withoutEnv(configGlobal, viteEnv) {
+    return isViteServerSide_impl(configGlobal, viteEnv);
 }
 function isViteClientSide(configGlobal, viteEnv) {
     return !isViteServerSide(configGlobal, viteEnv);
@@ -51,20 +62,36 @@ function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
 }
 // Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
 function isViteServerSide_extraSafe(config, options, viteEnv) {
+    const isServerSide = isViteServerSide(config, viteEnv);
+    const debug = {
+        configCommand: config.command,
+        configBuildSsr: config.build.ssr,
+        optionsIsUndefined: options === undefined,
+        optionsSsr: options?.ssr,
+        isServerSide,
+    };
+    if (true) {
+        const res = options?.ssr;
+        if (typeof res === 'boolean') {
+            assert(res === isServerSide, debug);
+            return res;
+        }
+        return isServerSide;
+    }
     if (config.command === 'build') {
         const res = config.build.ssr;
-        assert(typeof res === 'boolean');
-        assert(res === options?.ssr || options?.ssr === undefined);
-        assert(res === isViteServerSide(config, viteEnv));
+        assert(typeof res === 'boolean', debug);
+        assert(res === options?.ssr || options?.ssr === undefined, debug);
+        assert(res === isServerSide, debug);
         return res;
     }
     else {
         const res = options?.ssr;
-        assert(typeof res === 'boolean');
+        assert(typeof res === 'boolean', debug);
         /* This assertion can fail, seems to be a Vite bug? It's very unexpected.
         if (typeof config.build.ssr === 'boolean') assert(res === config.build.ssr)
         */
-        assert(res === isViteServerSide(config, viteEnv));
+        assert(res === isServerSide, debug);
         return res;
     }
 }

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.d.ts

@@ -4,9 +4,10 @@ export type { ConfigDefinitions };
 export type { ConfigDefinitionsInternal };
 export type { ConfigDefinitionInternal };
 export type { ConfigEffect };
-import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath, PageConfigBuildTime } from '../../../../types/PageConfig.js';
+import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath } from '../../../../types/PageConfig.js';
 import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../types/Config.js';
 import { type ConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
+import type { PageConfigBuildTimeBeforeComputed } from '../resolveVikeConfigInternal.js';
 /** The meta definition of a config.
  *
  * https://vike.dev/meta
@@ -75,7 +76,7 @@ type ConfigEffect = (config: {
 }) => Config | undefined;
 /** For Vike internal use */
 type ConfigDefinitionInternal = Omit<ConfigDefinition_, 'env'> & {
-    _computed?: (pageConfig: Omit<PageConfigBuildTime, 'configValuesComputed'>) => unknown;
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
     _valueIsFilePath?: true;
     _userEffectDefinedAtFilePath?: DefinedAtFilePath;
     env: ConfigEnvInternal;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -1,7 +1,7 @@
 export { configDefinitionsBuiltIn };
 import { assert, assertUsage } from '../../utils.js';
 import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
-import { getConfigValueSourcesRelevant } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -108,7 +108,9 @@ const configDefinitionsBuiltIn = {
             }, pageConfig))
                 .flat(1)
                 // Server-only
-                .filter((source) => !source.configEnv.client);
+                .filter((source) => !source.configEnv.client)
+                // Config value isn't `null`
+                .filter((source) => !isConfigSourceValueNull(source));
             return sources.length > 0;
         },
     },
@@ -120,22 +122,19 @@ const configDefinitionsBuiltIn = {
         env: { server: true, client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
             {
-                const source = getConfigValueSource(configValueSources, 'clientHooks');
+                const source = getConfigValueSourceRelevantAnyEnv('clientHooks', pageConfig);
                 if (source) {
                     assert(source.valueIsLoaded);
-                    if (source.value !== null) {
-                        const { value } = source;
-                        const definedAt = getConfigDefinedAt('Config', 'clientHooks', source.definedAt);
-                        assertUsage(typeof value === 'boolean', `${definedAt} should be a boolean`);
-                        return value;
-                    }
+                    const { value, definedAt } = source;
+                    const configDefinedAt = getConfigDefinedAt('Config', 'clientHooks', definedAt);
+                    assertUsage(typeof value === 'boolean', `${configDefinedAt} should be a boolean`);
+                    return value;
                 }
             }
-            return (isConfigSet(configValueSources, 'onRenderClient') &&
-                isConfigSet(configValueSources, 'Page') &&
-                !!getConfigEnv(configValueSources, 'Page')?.client);
+            return (isConfigSet(pageConfig, 'onRenderClient') &&
+                isConfigSet(pageConfig, 'Page') &&
+                !!getConfigEnv(pageConfig, 'Page')?.client);
         },
     },
     // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
@@ -143,10 +142,7 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
-            return !isConfigSet(configValueSources, 'onBeforeRender')
-                ? null
-                : getConfigEnv(configValueSources, 'onBeforeRender');
+            return !isConfigSet(pageConfig, 'onBeforeRender') ? null : getConfigEnv(pageConfig, 'onBeforeRender');
         },
     },
     // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
@@ -154,8 +150,7 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         eager: true,
         _computed: (pageConfig) => {
-            const { configValueSources } = pageConfig;
-            return !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data');
+            return !isConfigSet(pageConfig, 'data') ? null : getConfigEnv(pageConfig, 'data');
         },
     },
     hooksTimeout: {
@@ -243,11 +238,11 @@ const configDefinitionsBuiltIn = {
         cumulative: true,
     },
 };
-function getConfigEnv(configValueSources, configName) {
-    const configValueSource = getConfigValueSource(configValueSources, configName);
-    if (!configValueSource)
+function getConfigEnv(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    if (!source)
         return null;
-    const { configEnv } = configValueSource;
+    const { configEnv } = source;
     const env = {};
     if (configEnv.client)
         env.client = true;
@@ -255,18 +250,7 @@ function getConfigEnv(configValueSources, configName) {
         env.server = true;
     return env;
 }
-function isConfigSet(configValueSources, configName) {
-    const source = getConfigValueSource(configValueSources, configName);
-    return (!!source &&
-        !(source.valueIsLoaded &&
-            // Enable users to suppress inherited config by overriding it with `null`
-            source.value === null));
-}
-function getConfigValueSource(configValueSources, configName) {
-    const sources = configValueSources[configName];
-    if (!sources)
-        return null;
-    const configValueSource = sources[0];
-    assert(configValueSource);
-    return configValueSource;
+function isConfigSet(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    return !!source;
 }

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -8,6 +8,7 @@ export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 export type { VikeConfigInternal };
+export type { PageConfigBuildTimeBeforeComputed };
 export { getVikeConfig };
 export type { VikeConfig };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../types/PageConfig.js';
@@ -57,6 +58,7 @@ declare function getVikeConfigFromCliOrEnv(): {
     configFromCliOptions: import("../../cli/parseCli.js").CliOptions | null;
     configFromEnvVar: Record<string, unknown> | null;
 };
+type PageConfigBuildTimeBeforeComputed = Omit<PageConfigBuildTime, 'configValuesComputed'>;
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitionsInternal, configName: string): ConfigDefinitionInternal | null;
 declare function getConfVal(plusFile: PlusFile, configName: string): null | {
     value: unknown;

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

@@ -0,0 +1,3 @@
+export { loadAndParseVirtualFilePageEntry };
+import type { PageConfigRuntime, PageConfigRuntimeLoaded } from '../../types/PageConfig.js';
+declare function loadAndParseVirtualFilePageEntry(pageConfig: PageConfigRuntime, isDev: boolean): Promise<PageConfigRuntimeLoaded>;

package/dist/esm/shared/page-configs/{loadPageEntry.js → loadAndParseVirtualFilePageEntry.js}

@@ -1,7 +1,7 @@
-export { loadPageEntry };
+export { loadAndParseVirtualFilePageEntry };
 import { assert, objectAssign } from '../utils.js';
 import { parseConfigValuesSerialized } from './serialize/parsePageConfigsSerialized.js';
-async function loadPageEntry(pageConfig, isDev) {
+async function loadAndParseVirtualFilePageEntry(pageConfig, isDev) {
     if ('isPageEntryLoaded' in pageConfig &&
         // We don't need to cache in dev, since Vite already caches the virtual module
         !isDev) {

package/dist/esm/shared/page-configs/resolveVikeConfigPublic.js

@@ -1,3 +1,8 @@
+// TO-DO/soon: rename PageConfig names
+// - Use `Internal` suffix, i.e. {Page,Global}ConfigInternal
+//   - While keeping {Page,Global}ConfigPublic or remove Public suffix and rename it to {Page,Global}Config ?
+// - rename EagerLoaded EagerlyLoaded
+// - remove `LazyLoaded` suffix
 // TO-DO/soon/same-api: use public API internally?
 // TO-DO/soon/flat-pageContext: rename definedAt => definedBy
 export { resolveVikeConfigPublicGlobal };

package/dist/esm/shared/route/execHookOnBeforeRoute.d.ts

@@ -1,7 +1,7 @@
 export { execHookOnBeforeRoute };
-import type { PageContextForRoute, PageContextFromRoute } from './index.js';
-declare function execHookOnBeforeRoute(pageContext: PageContextForRoute): Promise<null | ({
+import type { PageContextBeforeRoute, PageContextAfterRoute } from './index.js';
+declare function execHookOnBeforeRoute(pageContext: PageContextBeforeRoute): Promise<null | ({
     _routingProvidedByOnBeforeRouteHook: true;
-} & PageContextFromRoute) | {
+} & PageContextAfterRoute) | {
     _routingProvidedByOnBeforeRouteHook: false;
 }>;

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

@@ -23,7 +23,6 @@ async function execHookOnBeforeRoute(pageContext) {
             }
             objectAssign(pageContextFromOnBeforeRouteHook, {
                 _routingProvidedByOnBeforeRouteHook: true,
-                _debugRouteMatches: 'CUSTOM_ROUTING',
             });
             return pageContextFromOnBeforeRouteHook;
         }

package/dist/esm/shared/route/index.d.ts

@@ -1,19 +1,18 @@
 export { route };
-export type { PageContextForRoute };
-export type { PageContextFromRoute };
+export type { PageContextBeforeRoute };
+export type { PageContextAfterRoute };
 export type { PageRoutes };
 export type { RouteMatches };
 import { type PageContextUrlInternal, type PageContextUrlSource } from '../getPageContextUrlComputed.js';
 import type { PageRoutes, RouteType } from './loadPageRoutes.js';
 import type { GlobalContextInternal } from '../createGlobalContextShared.js';
-type PageContextForRoute = PageContextUrlInternal & {
+type PageContextBeforeRoute = PageContextUrlInternal & {
     _globalContext: GlobalContextInternal;
 } & PageContextUrlSource;
-type PageContextFromRoute = {
+type PageContextAfterRoute = {
     pageId: string | null;
     routeParams: Record<string, string>;
     _routingProvidedByOnBeforeRouteHook?: boolean;
-    _debugRouteMatches: RouteMatches;
 };
 type RouteMatch = {
     pageId: string;
@@ -23,4 +22,4 @@ type RouteMatch = {
     routeParams: Record<string, string>;
 };
 type RouteMatches = 'CUSTOM_ROUTING' | RouteMatch[];
-declare function route(pageContext: PageContextForRoute, skipOnBeforeRouteHook?: true): Promise<PageContextFromRoute>;
+declare function route(pageContext: PageContextBeforeRoute, skipOnBeforeRouteHook?: true): Promise<PageContextAfterRoute>;

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

@@ -81,7 +81,6 @@ async function route(pageContext, skipOnBeforeRouteHook) {
     resolvePrecedence(routeMatches);
     const winner = routeMatches[0] ?? null;
     debug(`Route matches for URL ${pc.cyan(urlPathname)} (in precedence order):`, routeMatches);
-    objectAssign(pageContextFromRoute, { _debugRouteMatches: routeMatches });
     // For vite-plugin-vercel https://github.com/magne4000/vite-plugin-vercel/blob/main/packages/vike-integration/vike.ts#L173
     objectAssign(pageContextFromRoute, { _routeMatch: winner });
     if (!winner) {

package/dist/esm/types/Config.d.ts

@@ -404,11 +404,9 @@ type ConfigBuiltIn = {
     /** @deprecated See https://vike.dev/disableAutoFullBuild */
     disableAutoFullBuild?: boolean | 'prerender';
     /**
-     * Use builder.buildApp() to orchestrate the build process.
-     *
-     * @experimental
+     * @deprecated It's value is now always true.
      */
-    vite6BuilderApp?: boolean;
+    vite6BuilderApp?: true;
     /** The Base URL of your server.
      *
      * https://vike.dev/base-url

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.237-commit-e549c30";
+export declare const PROJECT_VERSION: "0.4.237-commit-fd8294f";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.237-commit-e549c30';
+export const PROJECT_VERSION = '0.4.237-commit-fd8294f';

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

@@ -0,0 +1,3 @@
+export { updateType };
+/** Help TypeScript update the type of dynamically modified objects. */
+declare function updateType<Thing, Clone>(thing: Thing, clone: Clone): asserts thing is Thing & Clone;

package/dist/esm/utils/updateType.js

@@ -0,0 +1,7 @@
+export { updateType };
+import { assert } from './assert.js';
+/** Help TypeScript update the type of dynamically modified objects. */
+function updateType(thing, clone) {
+    // @ts-ignore
+    assert(thing === clone);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.237-commit-e549c30",
+  "version": "0.4.237-commit-fd8294f",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -129,10 +129,10 @@
   },
   "dependencies": {
     "@brillout/import": "^0.2.6",
-    "@brillout/json-serializer": "^0.5.17",
+    "@brillout/json-serializer": "^0.5.20",
     "@brillout/picocolors": "^1.0.26",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.7.12",
+    "@brillout/vite-plugin-server-entry": "^0.7.13",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
@@ -263,7 +263,7 @@
     "react-streaming": "^0.4.3",
     "rimraf": "^5.0.5",
     "typescript": "^5.8.3",
-    "vite": "^7.0.6"
+    "vite": "^7.1.3"
   },
   "scripts": {
     "dev": "tsc --watch",

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

@@ -1,52 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debugPageFiles = debugPageFiles;
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const utils_js_1 = require("../utils.js");
-function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies, }) {
-    const debug = (0, utils_js_1.createDebugger)('vike:pageFiles', { serialization: { emptyArray: 'None' } });
-    const padding = '   - ';
-    debug('All page files:', printPageFiles(pageContext._globalContext._pageFilesAll, true));
-    debug(`URL:`, pageContext.urlOriginal);
-    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._debugRouteMatches));
-    debug(`pageId:`, pageContext.pageId);
-    debug('Page type:', isHtmlOnly ? 'HTML-only' : 'SSR/SPA');
-    debug(`Routing type:`, !isHtmlOnly && isClientRouting ? 'Client Routing' : 'Server Routing');
-    debug('Server-side page files:', printPageFiles(pageFilesLoaded));
-    (0, utils_js_1.assert)(samePageFiles(pageFilesLoaded, pageFilesServerSide));
-    debug('Client-side page files:', printPageFiles(pageFilesClientSide));
-    debug('Client-side entries:', clientEntries);
-    debug('Client-side dependencies:', clientDependencies);
-    return;
-    function printRouteMatches(debugRouteMatches) {
-        if (debugRouteMatches === 'ROUTING_ERROR') {
-            return 'Routing Failed';
-        }
-        if (debugRouteMatches === 'CUSTOM_ROUTING') {
-            return 'Custom Routing';
-        }
-        return debugRouteMatches;
-    }
-    function printPageFiles(pageFiles, genericPageFilesLast = false) {
-        if (pageFiles.length === 0) {
-            return 'None';
-        }
-        return ('\n' +
-            pageFiles
-                .sort((p1, p2) => p1.filePath.localeCompare(p2.filePath))
-                .sort((0, utils_js_1.makeFirst)((p) => (p.isRendererPageFile ? !genericPageFilesLast : null)))
-                .sort((0, utils_js_1.makeFirst)((p) => (p.isDefaultPageFile ? !genericPageFilesLast : null)))
-                .map((p) => p.filePath)
-                .map((s) => s.split('_default.page.').join(`${picocolors_1.default.blue('_default')}.page.`))
-                .map((s) => s.split('/renderer/').join(`/${picocolors_1.default.red('renderer')}/`))
-                .map((s) => padding + s)
-                .join('\n'));
-    }
-}
-function samePageFiles(pageFiles1, pageFiles2) {
-    return (pageFiles1.every((p1) => pageFiles2.some((p2) => p2.filePath === p1.filePath)) &&
-        pageFiles2.every((p2) => pageFiles1.some((p1) => p1.filePath === p2.filePath)));
-}

package/dist/esm/node/runtime/renderPage/debugPageFiles.d.ts

@@ -1,23 +0,0 @@
-export { debugPageFiles };
-export type { PageContextDebugRouteMatches };
-import type { RouteMatches } from '../../../shared/route/index.js';
-import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
-import type { PageFile } from '../../../shared/getPageFiles.js';
-import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageContextDebugRouteMatches = {
-    _debugRouteMatches: 'ROUTING_ERROR' | RouteMatches;
-};
-declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies, }: {
-    pageContext: {
-        urlOriginal: string;
-        pageId: string;
-        _globalContext: GlobalContextServerInternal;
-    } & PageContextDebugRouteMatches;
-    isHtmlOnly: boolean;
-    isClientRouting: boolean;
-    pageFilesLoaded: PageFile[];
-    pageFilesClientSide: PageFile[];
-    pageFilesServerSide: PageFile[];
-    clientEntries: string[];
-    clientDependencies: ClientDependency[];
-}): void;