vike 0.4.221-commit-937dbfb → 0.4.222-commit-207e079

package/dist/cjs/node/shared/resolveBase.js

@@ -4,21 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveBase = resolveBase;
-exports.resolveBaseRuntime = resolveBaseRuntime;
-exports.resolveBaseFromResolvedConfig = resolveBaseFromResolvedConfig;
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
-    let baseViteOriginal = config._baseViteOriginal;
-    (0, utils_js_1.assert)(baseViteOriginal === null || typeof baseViteOriginal == 'string');
-    return resolveBase(baseViteOriginal, baseServer, baseAssets);
-}
-function resolveBaseRuntime(globalContext) {
-    const baseViteOriginal = globalContext.viteConfigRuntime._baseViteOriginal;
-    const baseServerUnresolved = globalContext.config.baseServer ?? null;
-    const baseAssetsUnresolved = globalContext.config.baseAssets ?? null;
-    return resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved);
-}
 function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
     if (baseViteOriginal === '/__UNSET__')
         baseViteOriginal = null;

package/dist/cjs/shared/getPageConfigsRuntime.js

@@ -10,7 +10,16 @@ function getPageConfigsRuntime(virtualFileExports) {
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
     // TODO/now: re-use this call, instead of calling it twice
     const globalConfig = (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)(pageConfigGlobal);
-    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig };
+    // TODO/now DEDUPE
+    const pageConfigsUserFriendly = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        const configValues = { ...pageConfigGlobal.configValues, ...pageConfig.configValues };
+        const page = {
+            ...(0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendlyNew)({ configValues }),
+            route: pageConfig.routeFilesystem?.routeString ?? null
+        };
+        return [pageConfig.pageId, page];
+    }));
+    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly };
 }
 function getAllPageIds(pageFilesAll, pageConfigs) {
     const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);

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

@@ -10,7 +10,7 @@ const getConfigDefinedAt_js_1 = require("../page-configs/getConfigDefinedAt.js")
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const getHook_js_1 = require("../hooks/getHook.js");
 async function loadPageRoutes(
-// Remove all arguments and use GlobalContext instead?
+// Remove all arguments and use GlobalContextInternal instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
     // TODO/next-major: remove & make this function sync
     await Promise.all(pageFilesAll.filter((p) => p.fileType === '.page.route').map((p) => p.loadFile?.()));

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.221-commit-937dbfb';
+exports.PROJECT_VERSION = '0.4.222-commit-207e079';

package/dist/cjs/utils/assertSingleInstance.js

@@ -27,7 +27,7 @@ function assertSingleInstance() {
         const versions = (0, unique_js_1.unique)(globalObject.instances);
         assertUsage(versions.length <= 1, 
         // DO *NOT* patch vike to remove this error: because of multiple conflicting versions, you *will* eventually encounter insidious issues that hard to debug and potentially a security hazard, see for example https://github.com/vikejs/vike/issues/1108
-        `vike@${picocolors_1.default.bold(versions[0])} and vike@${picocolors_1.default.bold(versions[1])} loaded but only one version should be loaded`);
+        `vike@${picocolors_1.default.bold(versions[0])} and vike@${picocolors_1.default.bold(versions[1])} loaded but it's forbidden to load different versions`);
     }
     if (globalObject.checkSingleInstance && globalObject.instances.length > 1) {
         /*/ Not sure whether circular dependency can cause problems? In principle not since client-side code is ESM.

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

@@ -17,5 +17,10 @@ type RenderArgs = {
     pageContextInitClient?: Record<string, unknown>;
 };
 declare function renderPageClientSide(renderArgs: RenderArgs): Promise<void>;
+declare global {
+    var _vike: {
+        fullyRenderedUrl?: string;
+    };
+}
 declare function disableClientRouting(err: unknown, log: boolean): void;
 declare function getRenderCount(): number;

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

@@ -484,8 +484,15 @@ async function renderPageClientSide(renderArgs) {
         // Add link prefetch handlers
         addLinkPrefetchHandlers_watch();
         addLinkPrefetchHandlers();
+        stampFinished(urlOriginal);
     }
 }
+// For Vike tests (but also potentially for Vike users)
+// https://github.com/vikejs/vike/blob/ffbc5cf16407bcc075f414447e50d997c87c0c94/test/playground/pages/nested-layout/e2e-test.ts#L59
+function stampFinished(urlOriginal) {
+    window._vike ?? (window._vike = {});
+    window._vike.fullyRenderedUrl = urlOriginal;
+}
 function changeUrl(url, overwriteLastHistoryEntry) {
     if (getCurrentUrl() === url)
         return;

package/dist/esm/node/plugin/index.d.ts

@@ -4,7 +4,10 @@ export { plugin as ssr };
 export type { VikeVitePluginOptions as UserConfig };
 export type { VikeVitePluginOptions };
 export { PROJECT_VERSION as version } from './utils.js';
-declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): any;
+type PluginInterop = Record<string, unknown> & {
+    name: string;
+};
+declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): PluginInterop[];
 /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
 type VikeVitePluginOptions = {
     /** @deprecated Define Vike settings in +config.js instead of vite.config.js */

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

@@ -29,7 +29,7 @@ import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegres
 import { buildApp } from './plugins/buildApp.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
-// Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
+// Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
 function plugin(vikeVitePluginOptions = {}) {
     const plugins = [
         ...commonConfig(vikeVitePluginOptions),

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

@@ -1,5 +1,5 @@
 export { baseUrls };
-import { resolveBase, resolveBaseFromResolvedConfig } from '../../shared/resolveBase.js';
+import { resolveBase } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 function baseUrls() {
@@ -38,3 +38,8 @@ function baseUrls() {
         }
     };
 }
+function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
+    let baseViteOriginal = config._baseViteOriginal;
+    assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
+    return resolveBase(baseViteOriginal, baseServer, baseAssets);
+}

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

@@ -11,6 +11,7 @@ declare module 'vite' {
         _viteConfigEnhanced?: InlineConfig;
         vike?: {
             config: VikeConfigObject['global']['config'];
+            pages: VikeConfigObject['pages'];
             prerenderContext?: PrerenderContextPublic;
         };
     }

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

@@ -30,7 +30,10 @@ function commonConfig(vikeVitePluginOptions) {
                         _isDev: isDev,
                         _root: root,
                         _vikeVitePluginOptions: vikeVitePluginOptions,
-                        vike: { config: vikeConfig.global.config },
+                        vike: {
+                            pages: vikeConfig.pages,
+                            config: vikeConfig.global.config
+                        },
                         // TODO/v1-release: remove https://github.com/vikejs/vike/issues/2122
                         configVikePromise: Promise.resolve({
                             prerender: isPrerenderEnabled(vikeConfig)

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

@@ -10,8 +10,8 @@ import { vikeConfigDependencies, reloadVikeConfig, isV1Design, getVikeConfig } f
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
-import { getPlusFileValueConfigName } from './v1-design/getVikeConfig/getPlusFilesAll.js';
 import { updateUserFiles } from '../../../runtime/globalContext.js';
+import { isPlusFile } from './v1-design/getVikeConfig/crawlPlusFiles.js';
 function importUserCode() {
     let config;
     let vikeConfig;
@@ -68,50 +68,55 @@ function handleFileAddRemove(server, config) {
     return;
     function listener(file, isRemove) {
         file = normalizePath(file);
-        const isVikeConfig = isVikeConfigModule(file) || isVikeConfigFile(file);
-        if (isVikeConfig) {
-            const virtualModules = getVirtualModules(server);
-            virtualModules.forEach((mod) => {
-                server.moduleGraph.invalidateModule(mod);
-            });
+        if (isPlusFile(file) || isVikeConfigDependency(file, server.moduleGraph)?.modifiesVikeVirtualFiles) {
+            invalidateVikeVirtualFiles(server);
             reloadConfig(file, config, isRemove ? 'removed' : 'created');
         }
     }
 }
+function invalidateVikeVirtualFiles(server) {
+    const vikeVirtualFiles = getVikeVirtualFiles(server);
+    vikeVirtualFiles.forEach((mod) => {
+        server.moduleGraph.invalidateModule(mod);
+    });
+}
 function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
-    const isVikeConfig = isVikeConfigModule(file);
-    const isViteModule = ctx.modules.length > 0;
-    /* Should we show this?
-    // - Can be useful for server files that aren't processed by Vite.
-    // - Can be annoying for files that obviously aren't processed by Vite.
-    if (!isVikeConfig && !isViteModule) {
-      logViteAny(
-        `${msg} — ${pc.cyan('no HMR')}, see https://vike.dev/on-demand-compiler`,
-        'info',
-        null,
-        true
-      )
-      return
-    }
-    //*/
-    // It can hide an error it shouldn't hide (because the error isn't shown again), but it's ok since users can reload the page and the error will be shown again (Vite transpilation errors are shown again upon a page reload).
-    if (!isVikeConfig && isViteModule) {
-        return;
-    }
+    const isVikeConfig = isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
     if (isVikeConfig) {
-        /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
-        assert(!isViteModule)
-        */
-        reloadConfig(file, config, 'modified');
-        const virtualModules = getVirtualModules(server);
-        return virtualModules;
+        if (isVikeConfig.modifiesVikeVirtualFiles) {
+            /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
+            const isViteModule = ctx.modules.length > 0
+            assert(!isViteModule)
+            */
+            // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
+            invalidateVikeVirtualFiles(server);
+            reloadConfig(file, config, 'modified');
+            // Triggers a full page reload
+            const vikeVirtualFiles = getVikeVirtualFiles(server);
+            return vikeVirtualFiles;
+        }
+        else {
+            // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
+            // Vite already invalidates it, but possibly *after* handleHotUpdate() and thus after server.ssrLoadModule()
+            ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
+            updateUserFiles();
+        }
     }
 }
-function isVikeConfigModule(filePathAbsoluteFilesystem) {
+function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
+    // Check config-only files, for example all pages/+config.js dependencies. (There aren't part of Vite's module graph.)
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.forEach((f) => assertPosixPath(f));
-    return vikeConfigDependencies.has(filePathAbsoluteFilesystem);
+    if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
+        return { modifiesVikeVirtualFiles: true };
+    // Check using Vite's module graph, for example all +htmlAttributes dependencies.
+    // Alternatively, simply call updateUserFiles() on every handleHotUpdate() call.
+    const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);
+    const isPlusValueFileDependency = Array.from(importers).some((importer) => importer.file && isPlusFile(importer.file));
+    if (isPlusValueFileDependency)
+        return { modifiesVikeVirtualFiles: false };
+    return null;
 }
 function reloadConfig(filePath, config, op) {
     {
@@ -122,16 +127,45 @@ function reloadConfig(filePath, config, op) {
     reloadVikeConfig(config);
     updateUserFiles();
 }
-function getVirtualModules(server) {
-    const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())
+function getVikeVirtualFiles(server) {
+    const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
         .filter((url) => isVirtualFileIdPageConfigValuesAll(url) || isVirtualFileIdImportUserCode(url))
         .map((url) => {
         const mod = server.moduleGraph.urlToModuleMap.get(url);
         assert(mod);
         return mod;
     });
-    return virtualModules;
+    return vikeVirtualFiles;
+}
+// Get all transitive importers (including the module itself)
+function getImporters(file, moduleGraph) {
+    const importers = new Set();
+    const mods = moduleGraph.getModulesByFile(file);
+    if (!mods)
+        return importers;
+    for (const mod of mods) {
+        getModuleImporters(mod).forEach((importer) => {
+            if (importer)
+                importers.add(importer);
+        });
+    }
+    return importers;
 }
-function isVikeConfigFile(filePath) {
-    return !!getPlusFileValueConfigName(filePath);
+function getModuleImporters(mod, seen = new Set()) {
+    if (seen.has(mod))
+        return new Set();
+    seen.add(mod);
+    const importers = new Set();
+    if (mod.id)
+        importers.add(mod);
+    // Traverse through the importers (modules that import this module)
+    for (const importer of mod.importers) {
+        if (importer.id)
+            importers.add(importer);
+        getModuleImporters(importer, seen).forEach((importerTransitive) => {
+            if (importerTransitive)
+                importers.add(importerTransitive);
+        });
+    }
+    return importers;
 }

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

@@ -1,4 +1,8 @@
 export { crawlPlusFiles };
+export { isPlusFile };
+export { getPlusFileValueConfigName };
 declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: null | string): Promise<{
     filePathAbsoluteUserRootDir: string;
 }[]>;
+declare function isPlusFile(filePath: string): boolean;
+declare function getPlusFileValueConfigName(filePath: string): string | null;

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

@@ -1,5 +1,7 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual } from '../../../../utils.js';
+export { isPlusFile };
+export { getPlusFileValueConfigName };
+import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage } from '../../../../utils.js';
 import path from 'path';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
@@ -49,6 +51,7 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem) {
         assertPosixPath(filePath);
         assert(!filePath.startsWith(userRootDir));
         const filePathAbsoluteUserRootDir = path.posix.join('/', filePath);
+        assert(isPlusFile(filePathAbsoluteUserRootDir));
         return { filePathAbsoluteUserRootDir };
     });
     return plusFiles;
@@ -223,3 +226,37 @@ function isGitCrawlDisabled() {
     const crawSettings = getEnvVarObject('VIKE_CRAWL');
     return crawSettings?.git === false;
 }
+function isPlusFile(filePath) {
+    assertPosixPath(filePath);
+    if (isTemporaryBuildFile(filePath))
+        return false;
+    const fileName = filePath.split('/').pop();
+    return fileName.startsWith('+');
+}
+function getPlusFileValueConfigName(filePath) {
+    if (!isPlusFile(filePath))
+        return null;
+    const fileName = path.posix.basename(filePath);
+    // assertNoUnexpectedPlusSign(filePath, fileName)
+    const basename = fileName.split('.')[0];
+    assert(basename.startsWith('+'));
+    const configName = basename.slice(1);
+    assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
+    return configName;
+}
+/* https://github.com/vikejs/vike/issues/1407
+function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
+  const dirs = path.posix.dirname(filePath).split('/')
+  dirs.forEach((dir, i) => {
+    const dirPath = dirs.slice(0, i + 1).join('/')
+    assertUsage(
+      !dir.includes('+'),
+      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
+    )
+  })
+  assertUsage(
+    !fileName.slice(1).includes('+'),
+    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
+  )
+}
+*/

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

@@ -1,5 +1,4 @@
 export { getPlusFilesAll };
-export { getPlusFileValueConfigName };
 export type { PlusFileValue };
 export type { PlusFile };
 export type { PlusFilesByLocationId };
@@ -36,4 +35,3 @@ type PlusFileValue = PlusFileCommons & {
 };
 type PlusFilesByLocationId = Record<LocationId, PlusFile[]>;
 declare function getPlusFilesAll(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
-declare function getPlusFileValueConfigName(filePath: string): string | null;

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

@@ -1,16 +1,13 @@
 export { getPlusFilesAll };
-export { getPlusFileValueConfigName };
-import { assert, assertPosixPath, assertUsage } from '../../../../utils.js';
+import { assert } from '../../../../utils.js';
 import { configDefinitionsBuiltIn } from './configDefinitionsBuiltIn.js';
 import { getLocationId } from './filesystemRouting.js';
-import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
-import { crawlPlusFiles } from './crawlPlusFiles.js';
+import { crawlPlusFiles, getPlusFileValueConfigName } from './crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadValueFile } from './loadFileAtConfigTime.js';
 import { resolvePointerImport } from './resolvePointerImport.js';
 import { getFilePathResolved } from '../../../../shared/getFilePath.js';
 import { assertExtensionsConventions } from './assertExtensions.js';
-import path from 'node:path';
 async function getPlusFilesAll(userRootDir, esbuildCache) {
     const plusFiles = await findPlusFiles(userRootDir, null);
     const configFiles = [];
@@ -120,35 +117,3 @@ async function findPlusFiles(userRootDir, outDirRoot) {
     const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
-function getPlusFileValueConfigName(filePath) {
-    assertPosixPath(filePath);
-    if (isTemporaryBuildFile(filePath))
-        return null;
-    const fileName = path.posix.basename(filePath);
-    // assertNoUnexpectedPlusSign(filePath, fileName)
-    const basename = fileName.split('.')[0];
-    if (!basename.startsWith('+')) {
-        return null;
-    }
-    else {
-        const configName = basename.slice(1);
-        assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
-        return configName;
-    }
-}
-/* https://github.com/vikejs/vike/issues/1407
-function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
-  const dirs = path.posix.dirname(filePath).split('/')
-  dirs.forEach((dir, i) => {
-    const dirPath = dirs.slice(0, i + 1).join('/')
-    assertUsage(
-      !dir.includes('+'),
-      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
-    )
-  })
-  assertUsage(
-    !fileName.slice(1).includes('+'),
-    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
-  )
-}
-*/

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

@@ -23,6 +23,7 @@ if (debugEsbuildResolve.isActivated)
     debugEsbuildResolve('esbuild version', version);
 async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig, esbuildCache) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
+    assert(filePathAbsoluteFilesystem);
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
     if (esbuildCache[filePathAbsoluteFilesystem]) {
         return await esbuildCache[filePathAbsoluteFilesystem];
@@ -49,6 +50,7 @@ async function transpileAndExecuteFile(filePath, userRootDir, isExtensionConfig,
 }
 async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
+    assert(filePathAbsoluteFilesystem);
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     if (debug.isActivated)

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

@@ -9,12 +9,13 @@ export type { VikeConfigObject };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type ConfigDefinitions, type ConfigDefinitionInternal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import type { ResolvedConfig } from 'vite';
-import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { type ConfigUserFriendly, type PageConfigsUserFriendly } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { type PlusFile } from './getVikeConfig/getPlusFilesAll.js';
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
-    global: ReturnType<typeof getPageConfigUserFriendlyNew>;
+    global: ConfigUserFriendly;
+    pages: PageConfigsUserFriendly;
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(config: ResolvedConfig): void;

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

@@ -31,6 +31,7 @@ function reloadVikeConfig(config) {
     const userRootDir = config.root;
     const vikeVitePluginOptions = config._vikeVitePluginOptions;
     assert(vikeVitePluginOptions);
+    // TODO/now: unify with esbuildCache
     vikeConfigDependencies.clear();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
     handleReloadSideEffects();
@@ -126,7 +127,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                global: getPageConfigUserFriendlyNew({ configValues: {} })
+                global: getPageConfigUserFriendlyNew({ configValues: {} }),
+                pages: {}
             };
             return dummyData;
         }
@@ -135,15 +137,26 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const esbuildCache = {};
     const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
-    // assertKnownConfigs(plusFilesAll)
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
+    assertKnownConfigs(configDefinitionsResolved, plusFilesAll);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
     // interop vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     // global
-    const configValues = getConfigValues(pageConfigGlobal);
-    const global = getPageConfigUserFriendlyNew({ configValues });
-    return { pageConfigs, pageConfigGlobal, global };
+    const configValuesGlobal = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues: configValuesGlobal });
+    // TODO/now DEDUPE
+    // pages
+    const pages = objectFromEntries(pageConfigs.map((pageConfig) => {
+        const configValuesLocal = getConfigValues(pageConfig, true);
+        const configValues = { ...configValuesGlobal, ...configValuesLocal };
+        const page = {
+            ...getPageConfigUserFriendlyNew({ configValues }),
+            route: pageConfig.routeFilesystem?.routeString ?? null
+        };
+        return [pageConfig.pageId, page];
+    }));
+    return { pageConfigs, pageConfigGlobal, global, pages };
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const configDefinitionsGlobal = getConfigDefinitions(
@@ -283,7 +296,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
     // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
     assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
 }
-function getConfigValues(pageConfig) {
+function getConfigValues(pageConfig, tolerateMissingValue) {
     const configValues = {};
     getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
@@ -294,7 +307,11 @@ function getConfigValues(pageConfig) {
         if (entry.configValueBase.type === 'standard') {
             assert('sourceRelevant' in entry); // Help TS
             const { configValueBase, sourceRelevant, configName } = entry;
-            assert('value' in sourceRelevant);
+            if (!sourceRelevant.valueIsLoaded) {
+                if (tolerateMissingValue)
+                    return;
+                assert(false);
+            }
             const { value } = sourceRelevant;
             configValues[configName] = { ...configValueBase, value };
         }
@@ -303,9 +320,18 @@ function getConfigValues(pageConfig) {
             const { configValueBase, sourcesRelevant, configName } = entry;
             const values = [];
             sourcesRelevant.forEach((source) => {
-                assert('value' in source);
+                if (!source.valueIsLoaded) {
+                    if (tolerateMissingValue)
+                        return;
+                    assert(false);
+                }
                 values.push(source.value);
             });
+            if (values.length === 0) {
+                if (tolerateMissingValue)
+                    return;
+                assert(false);
+            }
             configValues[configName] = { ...configValueBase, value: values };
         }
     });
@@ -350,7 +376,6 @@ function getPlusFilesRelevant(plusFilesAll, locationIdPage) {
     return plusFilesRelevant;
 }
 function sortForGlobal(plusFilesAll) {
-    const locationIdsAll = objectKeys(plusFilesAll);
     const plusFilesAllSorted = Object.fromEntries(objectEntries(plusFilesAll)
         .sort(lowerFirst(([locationId]) => locationId.split('/').length))
         .sort(makeFirst(([locationId]) => isGlobalLocation(locationId, plusFilesAll))));
@@ -747,13 +772,13 @@ function getComputed(configValueSources, configDefinitions) {
     return configValuesComputed;
 }
 // Show error message upon unknown config
-function assertKnownConfigs(plusFilesAll) {
+function assertKnownConfigs(configDefinitionsResolved, plusFilesAll) {
     const configDefinitionsAll = getConfigDefinitions(plusFilesAll);
     const configNamesKnownAll = Object.keys(configDefinitionsAll);
-    objectEntries(plusFilesAll).forEach(([locationId, plusFiles]) => {
-        const plusFilesRelevant = getPlusFilesRelevant(plusFilesAll, locationId);
-        const configDefinitionsLocal = getConfigDefinitions(plusFilesRelevant);
-        const configNamesKnownLocal = Object.keys(configDefinitionsLocal);
+    const configNamesGlobal = Object.keys(configDefinitionsResolved.configDefinitionsGlobal);
+    objectEntries(configDefinitionsResolved.configDefinitionsLocal).forEach(([_locationId, { configDefinitions, plusFiles }]) => {
+        const configDefinitionsLocal = configDefinitions;
+        const configNamesKnownLocal = [...Object.keys(configDefinitionsLocal), ...configNamesGlobal];
         plusFiles.forEach((plusFile) => {
             const configNames = getDefiningConfigNames(plusFile);
             configNames.forEach((configName) => {

package/dist/esm/node/runtime/globalContext.d.ts

@@ -16,23 +16,25 @@ export { assertBuildInfo };
 export { getViteConfigRuntime };
 export { updateUserFiles };
 export type { BuildInfo };
-export type { GlobalContext };
+export type { GlobalContextInternal };
 export type { GlobalContextPublic };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
-import type { ConfigUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
+import type { ConfigUserFriendly, PageConfigsUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 import type { ConfigVitePluginServerEntry } from '@brillout/vite-plugin-server-entry/plugin';
-type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig'>;
+import { type BaseUrlsResolved } from '../shared/resolveBase.js';
+type GlobalContextPublic = Pick<GlobalContext, 'assetsManifest' | 'config' | 'viteConfig' | 'pages' | 'baseAssets' | 'baseServer'>;
 type PageRuntimeInfo = Awaited<ReturnType<typeof getUserFiles>>;
-type GlobalContext = GlobalContextWithoutPublicCopy & {
+type GlobalContextInternal = GlobalContext & {
     globalContext_public: GlobalContextPublic;
 };
-type GlobalContextWithoutPublicCopy = {
+type GlobalContext = {
     viteConfigRuntime: {
         _baseViteOriginal: null | string;
     };
     config: ConfigUserFriendly['config'];
-} & PageRuntimeInfo & ({
+    pages: PageConfigsUserFriendly;
+} & BaseUrlsResolved & PageRuntimeInfo & ({
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
@@ -50,7 +52,7 @@ type GlobalContextWithoutPublicCopy = {
     usesClientRouter: boolean;
     viteConfig: ResolvedConfig;
 })));
-declare function getGlobalContextInternal(): Promise<GlobalContext>;
+declare function getGlobalContextInternal(): Promise<GlobalContextInternal>;
 /** @experimental https://vike.dev/getGlobalContext */
 declare function getGlobalContextSync(): GlobalContextPublic;
 /** @experimental https://vike.dev/getGlobalContext */
@@ -71,6 +73,7 @@ declare function getUserFiles(): Promise<{
     allPageIds: string[];
     pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    pages: PageConfigsUserFriendly;
     config: import("../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
 }>;
 declare function setGlobalContext_buildEntry(buildEntry: unknown): Promise<void>;