vike 0.4.230-commit-f07cc20 → 0.4.231-commit-a0ca5e4

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

@@ -0,0 +1,68 @@
+export { getVikeConfigInternal };
+export { getVikeConfigInternalOptional };
+export { getVikeConfigInternalSync };
+export { setVikeConfigContext };
+export { reloadVikeConfig };
+export { isV1Design };
+export { getConfVal };
+export { getConfigDefinitionOptional };
+export { getVikeConfigFromCliOrEnv };
+export { isOverriden };
+export type { VikeConfigInternal };
+export { getVikeConfig };
+export type { VikeConfig };
+import type { PageConfigGlobalBuildTime, ConfigValueSource, PageConfigBuildTime } from '../../../types/PageConfig.js';
+import { type ConfigDefinitionsInternal, type ConfigDefinitionInternal } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+import { type VikeConfigPublicGlobal, type VikeConfigPublicPageEager } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesAll.js';
+import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
+import type { ResolvedConfig, UserConfig } from 'vite';
+type VikeConfigContext = {
+    userRootDir: string;
+    isDev: boolean;
+    vikeVitePluginOptions: unknown;
+};
+type PrerenderContext = {
+    isPrerenderingEnabled: boolean;
+    isPrerenderingEnabledForAllPages: boolean;
+} & ({
+    [K in keyof PrerenderContextPublic]: null;
+} | PrerenderContextPublic);
+type VikeConfigInternal = {
+    _pageConfigs: PageConfigBuildTime[];
+    _pageConfigGlobal: PageConfigGlobalBuildTime;
+    config: VikeConfigPublicGlobal['config'];
+    _from: VikeConfigPublicGlobal['_from'];
+    pages: Record<string, // pageId
+    VikeConfigPublicPageEager>;
+    _vikeConfigDependencies: Set<string>;
+    prerenderContext: PrerenderContext;
+};
+declare function reloadVikeConfig(): void;
+declare function getVikeConfigInternal(doNotRestartViteOnError?: boolean): Promise<VikeConfigInternal>;
+declare function getVikeConfigInternalSync(): VikeConfigInternal;
+/**
+ * Get all the information Vike knows about the app in your Vite plugin.
+ *
+ * https://vike.dev/getVikeConfig
+ */
+declare function getVikeConfig(config: ResolvedConfig | UserConfig): VikeConfig;
+type VikeConfig = Pick<VikeConfigInternal, 'config' | 'pages' | 'prerenderContext'>;
+declare function setVikeConfigContext(vikeConfigCtx_: VikeConfigContext): void;
+declare function getVikeConfigInternalOptional(): Promise<null | VikeConfigInternal>;
+declare function isV1Design(): boolean;
+declare function getVikeConfigFromCliOrEnv(): {
+    vikeConfigFromCliOrEnv: {
+        [x: string]: unknown;
+    };
+    configFromCliOptions: import("../../cli/parseCli.js").CliOptions | null;
+    configFromEnvVar: Record<string, unknown> | null;
+};
+declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitionsInternal, configName: string): ConfigDefinitionInternal | null;
+declare function getConfVal(plusFile: PlusFile, configName: string): null | {
+    value: unknown;
+    valueIsLoaded: true;
+} | {
+    valueIsLoaded: false;
+};
+declare function isOverriden(source: ConfigValueSource, configName: string, pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime): boolean;

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig.js → vite/shared/resolveVikeConfigInternal.js}

@@ -1,175 +1,202 @@
-export { getVikeConfig };
-export { getVikeConfigOptional };
-export { getVikeConfig2 };
+// Internal usage
+export { getVikeConfigInternal };
+export { getVikeConfigInternalOptional };
+export { getVikeConfigInternalSync };
+export { setVikeConfigContext };
 export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 export { isOverriden };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance } from '../../../utils.js';
-import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
-import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isVikeConfigInvalid, isVikeConfigInvalid_set } from '../../../../runtime/renderPage/isVikeConfigInvalid.js';
-import { getViteDevServer } from '../../../../runtime/globalContext.js';
-import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
-import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
+// Public usage
+export { getVikeConfig };
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance, genPromise } from '../utils.js';
+import { configDefinitionsBuiltIn } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect } from './resolveVikeConfigInternal/filesystemRouting.js';
+import { getViteDevServer } from '../../runtime/globalContext.js';
+import { logConfigError, logConfigErrorRecover } from './loggerNotProd.js';
+import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from './loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
-import { getConfigDefinedAt, getDefinedByString } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
-import { loadPointerImport, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
-import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
-import { getFilePathResolved } from '../../../shared/getFilePath.js';
-import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.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';
-import { getApiOperation } from '../../../../api/context.js';
-import { getCliOptions } from '../../../../cli/context.js';
+import { getConfigDefinedAt, getDefinedByString } from '../../../shared/page-configs/getConfigDefinedAt.js';
+import { loadPointerImport, loadValueFile } from './resolveVikeConfigInternal/loadFileAtConfigTime.js';
+import { resolvePointerImport } from './resolveVikeConfigInternal/resolvePointerImport.js';
+import { getFilePathResolved } from './getFilePath.js';
+import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
+import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEager } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { getConfigValuesBase, isJsonValue } from '../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { getPlusFilesAll } from './resolveVikeConfigInternal/getPlusFilesAll.js';
+import { getEnvVarObject } from './getEnvVarObject.js';
+import { getApiOperation } from '../../api/context.js';
+import { getCliOptions } from '../../cli/context.js';
+import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
+import { getProxyForPublicUsage } from '../../../shared/getProxyForPublicUsage.js';
+import { renderPage_vikeConfigHasError } from '../../runtime/renderPage.js';
 assertIsNotProductionRuntime();
+// We can simply use global variables since Vike's config is:
+//  - gobal
+//  - independent of Vite (therefore we don't need to tie Vike's config with Vite's `config` object)
 assertIsSingleModuleInstance('v1-design/getVikeConfig.ts');
 let restartVite = false;
-let wasConfigInvalid = null;
+let vikeConfigHasBuildError = null;
+let isV1Design_ = null;
 let vikeConfigPromise = null;
-function reloadVikeConfig(config) {
-    const userRootDir = config.root;
-    const vikeVitePluginOptions = config._vikeVitePluginOptions;
+// TODO/v1-release: remove
+let vikeConfigSync = null;
+let vikeConfigCtx = null; // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
+let prerenderContext;
+function reloadVikeConfig() {
+    assert(vikeConfigCtx);
+    const { userRootDir, vikeVitePluginOptions } = vikeConfigCtx;
     assert(vikeVitePluginOptions);
-    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
-    handleReloadSideEffects();
+    resolveVikeConfigInternal_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
 }
-async function handleReloadSideEffects() {
-    wasConfigInvalid = !!isVikeConfigInvalid;
-    const vikeConfigPromisePrevious = vikeConfigPromise;
-    try {
-        await vikeConfigPromise;
-    }
-    catch (err) {
-        // handleReloadSideEffects() is only called in dev.
-        // In dev, if loadVikeConfig_withErrorHandling() throws an error, then it's a vike bug.
-        console.error(err);
-        assert(false);
-    }
-    if (vikeConfigPromise !== vikeConfigPromisePrevious) {
-        // Let the next handleReloadSideEffects() call handle side effects
-        return;
-    }
-    if (!isVikeConfigInvalid) {
-        if (wasConfigInvalid) {
-            wasConfigInvalid = false;
-            logConfigErrorRecover();
-        }
-        if (restartVite) {
-            restartVite = false;
-            const viteDevServer = getViteDevServer();
-            assert(viteDevServer);
-            removeSuperfluousViteLog_enable();
-            await viteDevServer.restart(true);
-            removeSuperfluousViteLog_disable();
-        }
-    }
+async function getVikeConfigInternal(
+// I don't remember the logic behind it — neither why we restart Vite's dev server, nor why we sometimes don't.
+// TO-DO: eventually rethink all that. Some + settings are expected to influence Vite's config (restarting Vite's dev server is needed) while some don't.
+doNotRestartViteOnError = false) {
+    assert(vikeConfigCtx);
+    const { userRootDir, isDev, vikeVitePluginOptions } = vikeConfigCtx;
+    const vikeConfig = await getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
+    return vikeConfig;
 }
-// TODO/soon: predominantly use getVikeConfigInternal() instead of getVikeConfig() then maybe refector?
-async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
-    const userRootDir = config.root;
-    const vikeVitePluginOptions = config._vikeVitePluginOptions;
-    assert(vikeVitePluginOptions);
-    const isDev = config._isDev;
-    assert(typeof isDev === 'boolean');
-    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError ?? false);
+// TODO/v1-release: remove
+function getVikeConfigInternalSync() {
+    assert(vikeConfigSync);
+    return vikeConfigSync;
 }
-async function getVikeConfig2(userRootDir, isDev, vikeVitePluginOptions) {
-    assert(vikeVitePluginOptions);
-    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, false);
+// TO-DO/eventually: this maybe(/probably?) isn't safe against race conditions upon file changes in development, thus:
+// - Like getGlobalContext() and getGlobalContextSync() — make getVikeConfig() async and provide a getVikeConfigSync() while discourage using it
+// Public usage
+/**
+ * Get all the information Vike knows about the app in your Vite plugin.
+ *
+ * https://vike.dev/getVikeConfig
+ */
+function getVikeConfig(
+// TO-DO/eventually: remove unused arguments (older versions used it and we didn't remove it yet to avoid a TypeScript breaking change)
+// - No rush: we can do it later since it's getVikeConfig() is a beta feature as documented at https://vike.dev/getVikeConfig
+config) {
+    const vikeConfig = getVikeConfigInternalSync();
+    assertUsage(vikeConfig, 'getVikeConfig() can only be used when Vite is loaded (i.e. during development or build) — Vite is never loaded in production.');
+    const vikeConfigPublic = getProxyForPublicUsage(vikeConfig, 'vikeConfig');
+    return vikeConfigPublic;
 }
-async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+function setVikeConfigContext(vikeConfigCtx_) {
+    // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
+    vikeConfigCtx = vikeConfigCtx_;
+}
+async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     if (!vikeConfigPromise) {
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
+        resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     }
-    return await vikeConfigPromise;
+    assert(vikeConfigPromise);
+    const vikeConfig = await vikeConfigPromise;
+    return vikeConfig;
 }
-async function getVikeConfigOptional() {
+async function getVikeConfigInternalOptional() {
     if (!vikeConfigPromise)
         return null;
-    return await vikeConfigPromise;
+    const vikeConfig = await vikeConfigPromise;
+    return vikeConfig;
 }
-function isV1Design(config) {
-    const vikeConfig = config._vikeConfigObject;
-    assert(vikeConfig);
-    const { pageConfigs } = vikeConfig;
-    const isV1Design = pageConfigs.length > 0;
-    return isV1Design;
+function isV1Design() {
+    assert(typeof isV1Design_ === 'boolean');
+    return isV1Design_;
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+    const { promise, resolve, reject } = genPromise();
+    vikeConfigPromise = promise;
+    const esbuildCache = {
+        transpileCache: {},
+        vikeConfigDependencies: new Set()
+    };
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, vikeVitePluginOptions);
+        ret = await resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache);
     }
     catch (err_) {
         hasError = true;
         err = err_;
     }
+    // There is a newer call — let the new call supersede the old one.
+    // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
+    if (vikeConfigPromise !== promise) {
+        // vikeConfigPromise.then(resolve).catch(reject)
+        try {
+            resolve(await vikeConfigPromise);
+        }
+        catch (err) {
+            reject(err);
+        }
+        return;
+    }
     if (!hasError) {
         assert(ret);
         assert(err === undefined);
-        isVikeConfigInvalid_set(false);
-        return ret;
+        const hadError = vikeConfigHasBuildError;
+        vikeConfigHasBuildError = false;
+        renderPage_vikeConfigHasError({ hasBuildError: false });
+        if (hadError) {
+            logConfigErrorRecover();
+            if (restartVite) {
+                restartVite = false;
+                restartViteDevServer();
+            }
+        }
+        resolve(ret);
     }
     else {
         assert(ret === undefined);
         assert(err);
-        isVikeConfigInvalid_set({ err });
+        vikeConfigHasBuildError = true;
+        renderPage_vikeConfigHasError({ hasBuildError: { err } });
+        if (!doNotRestartViteOnError)
+            restartVite = true;
         if (!isDev) {
-            assert(getViteDevServer() === null);
-            throw err;
+            reject(err);
         }
         else {
             logConfigError(err);
-            if (!doNotRestartViteOnError) {
-                restartVite = true;
-            }
-            const dummyData = {
-                pageConfigs: [],
-                pageConfigGlobal: {
-                    configDefinitions: {},
-                    configValueSources: {}
-                },
-                global: getUserFriendlyConfigsGlobal({ pageConfigGlobalValues: {} }),
-                pages: {},
-                vikeConfigDependencies: new Set()
-            };
-            return dummyData;
+            resolve(getVikeConfigDummy(esbuildCache));
         }
     }
 }
-async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const esbuildCache = {
-        transpileCache: {},
-        vikeConfigDependencies: new Set()
-    };
+async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache) {
     const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
+    if (!isV1Design_)
+        isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
     // global
     const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
-    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({ pageConfigGlobalValues });
+    const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({ pageConfigGlobalValues });
     // pages
-    const userFriendlyConfigsPageEager = objectFromEntries(pageConfigs.map((pageConfig) => {
+    const vikeConfigPublicPagesEager = objectFromEntries(pageConfigs.map((pageConfig) => {
         const pageConfigValues = getConfigValues(pageConfig, true);
-        return getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues);
+        return resolveVikeConfigPublicPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
-    return {
-        pageConfigs,
-        pageConfigGlobal,
-        global: userFriendlyConfigsGlobal,
-        pages: userFriendlyConfigsPageEager,
-        vikeConfigDependencies: esbuildCache.vikeConfigDependencies
+    const prerenderContext = resolvePrerenderContext({
+        config: vikeConfigPublicGlobal.config,
+        _from: vikeConfigPublicGlobal._from,
+        _pageConfigs: pageConfigs
+    });
+    const vikeConfig = {
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        config: vikeConfigPublicGlobal.config,
+        _from: vikeConfigPublicGlobal._from,
+        pages: vikeConfigPublicPagesEager,
+        prerenderContext,
+        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies
     };
+    vikeConfigSync = vikeConfig;
+    return vikeConfig;
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const plusFilesAllOrdered = Object.values(plusFilesAll)
@@ -1081,3 +1108,56 @@ function isOverriden(source, configName, pageConfig) {
     assert(idx >= 0);
     return idx > 0;
 }
+function resolvePrerenderContext(vikeConfig) {
+    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
+    prerenderContext ?? (prerenderContext = {
+        isPrerenderingEnabled: false,
+        isPrerenderingEnabledForAllPages: false,
+        // Set at runPrerender()
+        output: null,
+        // Set at runPrerender()
+        pageContexts: null
+    });
+    prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
+    prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
+    return prerenderContext;
+}
+function restartViteDevServer() {
+    const viteDevServer = getViteDevServer();
+    assert(viteDevServer);
+    removeSuperfluousViteLog_enable();
+    (async () => {
+        try {
+            await viteDevServer.restart(true);
+        }
+        catch (err) {
+            console.error('Vite restart error:');
+            console.error(err);
+        }
+    })();
+    removeSuperfluousViteLog_disable();
+}
+function getVikeConfigDummy(esbuildCache) {
+    const globalDummy = resolveVikeConfigPublicGlobal({ pageConfigGlobalValues: {} });
+    const pageConfigsDummy = [];
+    const prerenderContextDummy = resolvePrerenderContext({
+        config: globalDummy.config,
+        _from: globalDummy._from,
+        _pageConfigs: pageConfigsDummy
+    });
+    const vikeConfigDummy = {
+        _pageConfigs: pageConfigsDummy,
+        _pageConfigGlobal: {
+            configDefinitions: {},
+            configValueSources: {}
+        },
+        config: globalDummy.config,
+        _from: globalDummy._from,
+        pages: {},
+        prerenderContext: prerenderContextDummy,
+        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies
+    };
+    vikeConfigSync = vikeConfigDummy;
+    isV1Design_ = true;
+    return vikeConfigDummy;
+}

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

@@ -1,13 +1,16 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-export type { GlobalContextShared };
-export type { GlobalContextSharedPublic };
+export type { GlobalContextBase };
+export type { GlobalContextBasePublic };
+export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextClientInternal;
 import type { PageFile } from './getPageFiles.js';
-import type { PageConfigRuntime } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../types/PageConfig.js';
+import type { GlobalContextServerInternal } from '../node/runtime/globalContext.js';
+import type { GlobalContextClientInternal } from '../client/runtime-client-routing/globalContext.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 declare function createGlobalContextShared<GlobalContextAddendum extends object>(virtualFileExports: unknown, globalObject: {
     globalContext?: Record<string, unknown>;
-}, addGlobalContext?: (globalContext: GlobalContextShared) => Promise<GlobalContextAddendum>): Promise<{
+}, addGlobalContext?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>): Promise<{
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -18,22 +21,21 @@ declare function createGlobalContextShared<GlobalContextAddendum extends object>
     _virtualFileExports: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _userFriendlyConfigsGlobal: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    _vikeConfigPublicGlobal: {
+        config: import("../types/index.js").ConfigResolved;
+        _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-            route: import("./page-configs/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
 } & Awaited<GlobalContextAddendum>>;
-type GlobalContextSharedPublic = Pick<GlobalContextShared, 'config' | 'pages' | 'isGlobalContext'>;
-type GlobalContextShared = ReturnType<typeof createGlobalContextBase>;
+type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
+type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
 declare function createGlobalContextBase(virtualFileExports: unknown): {
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -45,17 +47,16 @@ declare function createGlobalContextBase(virtualFileExports: unknown): {
     _virtualFileExports: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
-    _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _userFriendlyConfigsGlobal: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
-    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
+    _vikeConfigPublicGlobal: {
+        config: import("../types/index.js").ConfigResolved;
+        _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
-            route: import("./page-configs/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
 };

package/dist/esm/shared/createGlobalContextShared.js

@@ -1,8 +1,8 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
 import { changeEnumerable, objectAssign, unique } from './utils.js';
-import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
-import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from './page-configs/getUserFriendlyConfigs.js';
+import { parseVirtualFileExports } from './getPageFiles/parseVirtualFileExports.js';
+import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEager } from './page-configs/resolveVikeConfigPublic.js';
 import { execHookGlobal } from './hooks/execHook.js';
 import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
@@ -33,7 +33,7 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExports) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, userFriendlyConfigsGlobal, userFriendlyConfigsPageEager } = getConfigsAll(virtualFileExports);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, vikeConfigPublicGlobal, vikeConfigPublicPagesEager } = getConfigsAll(virtualFileExports);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -47,29 +47,29 @@ function createGlobalContextBase(virtualFileExports) {
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        _userFriendlyConfigsGlobal: userFriendlyConfigsGlobal,
-        config: userFriendlyConfigsGlobal.config,
-        pages: userFriendlyConfigsPageEager
+        _vikeConfigPublicGlobal: vikeConfigPublicGlobal,
+        config: vikeConfigPublicGlobal.config,
+        pages: vikeConfigPublicPagesEager
     };
     changeEnumerable(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
 function getConfigsAll(virtualFileExports) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseGlobResults(virtualFileExports);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExports(virtualFileExports);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
-    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({
+    const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({
         pageConfigGlobalValues: pageConfigGlobal.configValues
     });
-    const userFriendlyConfigsPageEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        return getUserFriendlyConfigsPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
+    const vikeConfigPublicPagesEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        return resolveVikeConfigPublicPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
     }));
     return {
         pageFilesAll,
         allPageIds,
         pageConfigs,
         pageConfigGlobal,
-        userFriendlyConfigsGlobal,
-        userFriendlyConfigsPageEager
+        vikeConfigPublicGlobal,
+        vikeConfigPublicPagesEager
     };
 }
 function getAllPageIds(pageFilesAll, pageConfigs) {

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

@@ -1,9 +1,14 @@
 export { createPageContextShared };
 export { createPageContextObject };
-import type { PageConfigUserFriendly } from './page-configs/getUserFriendlyConfigs.js';
-import type { PageConfigGlobalRuntime } from './page-configs/PageConfig.js';
+import type { VikeConfigPublicGlobal } from './page-configs/resolveVikeConfigPublic.js';
+import type { PageConfigGlobalRuntime } from '../types/PageConfig.js';
 import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, userFriendlyConfigsGlobal: PageConfigUserFriendly): Promise<T & PageConfigUserFriendly>;
+declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, vikeConfigPublicGlobal: VikeConfigPublicGlobal): Promise<T & {
+    config: import("../types/index.js").ConfigResolved;
+    _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+}>;
 declare function createPageContextObject(): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/esm/shared/createPageContextShared.js

@@ -3,8 +3,8 @@ export { createPageContextObject };
 import { execHookGlobal } from './hooks/execHook.js';
 import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
 import { changeEnumerable, objectAssign } from './utils.js';
-async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
-    objectAssign(pageContextCreated, userFriendlyConfigsGlobal);
+async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
+    objectAssign(pageContextCreated, vikeConfigPublicGlobal);
     await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }

package/dist/esm/shared/error-page.d.ts

@@ -1,7 +1,7 @@
 export { getErrorPageId };
 export { isErrorPageId };
 export { isErrorPage };
-import type { PageConfigRuntime } from './page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../types/PageConfig.js';
 import type { PageFile } from './getPageFiles.js';
 declare function getErrorPageId(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string | null;
 declare function isErrorPageId(pageId: string, _isV1Design: false): boolean;

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

@@ -1,5 +1,5 @@
 export { analyzeClientSide };
-import type { PageConfigRuntime } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime } from '../../types/PageConfig.js';
 import type { PageFile } from './getPageFileObject.js';
 declare function analyzeClientSide(pageConfig: PageConfigRuntime | null, pageFilesAll: PageFile[], pageId: string): {
     isClientRuntimeLoaded: boolean;

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.d.ts

@@ -11,4 +11,4 @@ declare function determineClientEntry({ pageFilesClientSide, pageFilesServerSide
     clientEntries: string[];
     clientDependencies: ClientDependency[];
 };
-declare function getVikeClientEntry(isClientRouting: boolean): "@@vike/dist/esm/client/client-routing-runtime/entry.js" | "@@vike/dist/esm/client/server-routing-runtime/entry.js";
+declare function getVikeClientEntry(isClientRouting: boolean): "@@vike/dist/esm/client/runtime-client-routing/entry.js" | "@@vike/dist/esm/client/runtime-server-routing/entry.js";