vike 0.4.217 → 0.4.218-commit-01a099d

package/dist/cjs/shared/page-configs/serialize/serializeConfigValues.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serializeConfigValues = serializeConfigValues;
+exports.getConfigValuesBase = getConfigValuesBase;
 const assertSetup_js_1 = require("../../../utils/assertSetup.js");
 const utils_js_1 = require("../../../node/plugin/utils.js");
 const addImportStatement_js_1 = require("../../../node/plugin/plugins/importUserCode/addImportStatement.js");
@@ -20,74 +21,42 @@ const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
 function serializeConfigValues(pageConfig, importStatements, isEnvMatch, { isEager }, tabspace) {
     const lines = [];
     tabspace += '  ';
-    Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
-        if (!isEnvMatch(configValuesComputed.configEnv))
-            return;
-        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
-        if (pageConfig.configValueSources[configName])
-            return;
-        const valueData = serializeWithJson(configValuesComputed.value, configName, null, importStatements);
-        const configValueBase = {
-            type: 'computed',
-            definedAtData: null
-        };
-        serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
-    });
-    Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-        const configDef = pageConfig.configDefinitions[configName];
-        (0, utils_js_1.assert)(configDef);
-        if (isEager !== !!configDef.eager)
-            return;
-        if (!configDef.cumulative) {
-            const configValueSource = sources[0];
-            (0, utils_js_1.assert)(configValueSource);
-            (0, utils_js_1.assert)(sources.slice(1).every((s) => s.isOverriden === true));
-            if (!isEnvMatch(configValueSource.configEnv))
-                return;
-            const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
-            const configValueBase = {
-                type: 'standard',
-                definedAtData: definedAtFile
-            };
+    getConfigValuesBase(pageConfig, isEnvMatch, { isEager }).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            (0, utils_js_1.assert)('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            const valueData = getValueSerializedWithJson(value, configName, configValueBase.definedAtData, importStatements);
             serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
         }
-        else {
+        if (entry.configValueBase.type === 'standard') {
+            (0, utils_js_1.assert)('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            const valueData = getValueSerializedFromSource(sourceRelevant, configName, importStatements);
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            (0, utils_js_1.assert)('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
             const valueDataList = [];
-            const definedAtData = [];
-            sources
-                .filter((s) => !s.isOverriden)
-                .forEach((configValueSource) => {
-                if (!isEnvMatch(configValueSource.configEnv))
-                    return;
-                const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+            sourcesRelevant.forEach((source) => {
+                const valueData = getValueSerializedFromSource(source, configName, importStatements);
                 valueDataList.push(valueData);
-                definedAtData.push(definedAtFile);
             });
-            if (valueDataList.length === 0)
-                return;
-            const configValueBase = {
-                type: 'cumulative',
-                definedAtData
-            };
             serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
         }
     });
     return lines;
 }
-function serializeConfigValueSource(configValueSource, configName, importStatements) {
+function getValueSerializedFromSource(configValueSource, configName, importStatements) {
     (0, utils_js_1.assert)(configValueSource.isOverriden === false);
     let valueData;
     if ('value' in configValueSource) {
-        valueData = serializeWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
+        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
     }
     else {
-        valueData = serializeWithImport(configValueSource, importStatements);
+        valueData = getValueSerializedWithImport(configValueSource, importStatements);
     }
-    const definedAtFile = {
-        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
-    };
-    return { valueData, definedAtFile };
+    return valueData;
 }
 function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
     lineAdd(`[${JSON.stringify(configName)}]: {`);
@@ -131,7 +100,7 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
         tabspace = tabspace.slice(2);
     }
 }
-function serializeWithImport(configValueSource, importStatements) {
+function getValueSerializedWithImport(configValueSource, importStatements) {
     (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
     const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
     (0, utils_js_1.assert)(valueIsImportedAtRuntime);
@@ -144,7 +113,7 @@ function serializeWithImport(configValueSource, importStatements) {
         valueAsJsCode: importName
     };
 }
-function serializeWithJson(value, configName, definedAtData, importStatements) {
+function getValueSerializedWithJson(value, configName, definedAtData, importStatements) {
     const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements);
     return {
         type: 'js-serialized',
@@ -201,3 +170,59 @@ function logJsonSerializeError(err, configName, definedAtData) {
     (0, utils_js_1.assert)(configValueFilePathToShowToUser);
     (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
 }
+function getConfigValuesBase(pageConfig, isEnvMatch, { isEager } = {}) {
+    const fromComputed = Object.entries(pageConfig.configValuesComputed ?? {}).map(([configName, valueInfo]) => {
+        if (!isEnvMatch(valueInfo.configEnv))
+            return 'SKIP';
+        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return 'SKIP';
+        const configValueBase = {
+            type: 'computed',
+            definedAtData: null
+        };
+        return { configValueBase, value: valueInfo.value, configName };
+    });
+    const fromSources = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
+        const configDef = pageConfig.configDefinitions[configName];
+        (0, utils_js_1.assert)(configDef);
+        if (isEager !== undefined && isEager !== !!configDef.eager)
+            return 'SKIP';
+        if (!configDef.cumulative) {
+            const source = sources[0];
+            (0, utils_js_1.assert)(source);
+            (0, utils_js_1.assert)(sources.slice(1).every((s) => s.isOverriden === true));
+            if (!isEnvMatch(source.configEnv))
+                return 'SKIP';
+            const definedAtFile = getDefinedAtFileSource(source);
+            const configValueBase = {
+                type: 'standard',
+                definedAtData: definedAtFile
+            };
+            return { configValueBase, sourceRelevant: source, configName };
+        }
+        else {
+            const sourcesRelevant = sources.filter((source) => !source.isOverriden && isEnvMatch(source.configEnv));
+            if (sourcesRelevant.length === 0)
+                return 'SKIP';
+            const definedAtData = [];
+            sourcesRelevant.forEach((source) => {
+                const definedAtFile = getDefinedAtFileSource(source);
+                definedAtData.push(definedAtFile);
+            });
+            const configValueBase = {
+                type: 'cumulative',
+                definedAtData
+            };
+            return { configValueBase, sourcesRelevant, configName };
+        }
+    });
+    return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
+}
+function getDefinedAtFileSource(source) {
+    const definedAtFile = {
+        filePathToShowToUser: source.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: source.definedAtFilePath.fileExportPathToShowToUser
+    };
+    return definedAtFile;
+}

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

@@ -5,7 +5,7 @@ const error_page_js_1 = require("../error-page.js");
 const utils_js_1 = require("./utils.js");
 const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFromFilesystemPath.js");
 const utils_js_2 = require("../utils.js");
-const getConfigValue_js_1 = require("../page-configs/getConfigValue.js");
+const getConfigValueRuntime_js_1 = require("../page-configs/getConfigValueRuntime.js");
 const getConfigDefinedAt_js_1 = require("../page-configs/getConfigDefinedAt.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const getHook_js_1 = require("../hooks/getHook.js");
@@ -30,7 +30,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = (0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, configName);
+                const configValue = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
                     (0, utils_js_1.assert)(configValue.definedAtData);
@@ -46,7 +46,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         (0, utils_js_1.assert)((0, utils_js_2.isCallable)(route));
-                        if ((0, getConfigValue_js_1.getConfigValueRuntime)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if ((0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             (0, resolveRouteFunction_js_1.warnDeprecatedAllowKey)();
                         pageRoute = {
                             pageId,

package/dist/cjs/shared/utils.js

@@ -42,3 +42,4 @@ __exportStar(require("../utils/escapeRegex.js"), exports);
 __exportStar(require("../utils/isArray.js"), exports);
 __exportStar(require("../utils/changeEnumerable.js"), exports);
 __exportStar(require("../utils/objectDefineProperty.js"), exports);
+__exportStar(require("../utils/isScriptFile.js"), exports);

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.217';
+exports.PROJECT_VERSION = '0.4.218-commit-01a099d';

package/dist/cjs/utils/assert.js

@@ -35,6 +35,7 @@ const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/assert.ts'
 (0, assertSingleInstance_js_1.assertSingleInstance_onAssertModuleLoad)();
 const projectTag = `[vike]`;
 const projectTagWithVersion = `[vike@${projectInfo_js_1.projectInfo.projectVersion}]`;
+const bugTag = 'Bug';
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {
     if (condition)
@@ -54,7 +55,7 @@ function assert(condition, debugInfo) {
         .filter(Boolean)
         .join(' ');
     errMsg = addWhitespace(errMsg);
-    errMsg = addPrefixAssertType(errMsg, 'Bug');
+    errMsg = addPrefixAssertType(errMsg, bugTag);
     errMsg = addPrefixProjctName(errMsg, true);
     const internalError = (0, createErrorWithCleanStackTrace_js_1.createErrorWithCleanStackTrace)(errMsg, numberOfStackTraceLinesToRemove);
     globalObject.onBeforeLog?.();
@@ -165,7 +166,7 @@ function getAssertErrMsg(thing) {
         const showVikeVersion = tag === projectTagWithVersion;
         const errStackPrefix = `Error: ${tag}`;
         if (errStack?.startsWith(errStackPrefix)) {
-            if (globalObject.showStackTraceList.has(thing)) {
+            if (globalObject.showStackTraceList.has(thing) || isBug(thing)) {
                 const assertMsg = errStack.slice(errStackPrefix.length);
                 return { assertMsg, showVikeVersion };
             }
@@ -184,7 +185,7 @@ function overwriteAssertProductionLogger(logger) {
     globalObject.logger = logger;
 }
 function isBug(err) {
-    return !String(err).includes('[Bug]');
+    return String(err).includes(`[${bugTag}]`);
 }
 function setAlwaysShowStackTrace() {
     globalObject.alwaysShowStackTrace = true;

package/dist/esm/__internal/index.d.ts

@@ -1,14 +1,12 @@
+export { setBuildEntry } from '../node/runtime/globalContext.js';
 export { route, getPagesAndRoutes };
 export type { PageRoutes, PageFile, PageConfigRuntime as PageConfig };
 export { getMiddlewares };
 import { route as routeInternal, type PageRoutes } from '../shared/route/index.js';
-import { type PageFile } from '../shared/getPageFiles.js';
+import type { PageFile } from '../shared/getPageFiles/getPageFileObject.js';
 import { PageConfigRuntime } from '../shared/page-configs/PageConfig.js';
 /**
- * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
- * to compute some rewrite rules and extract { isr } configs.
- * Needs `import 'vike/__internal/setup'`
- * @param config
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
  */
 declare function getPagesAndRoutes(): Promise<{
     pageRoutes: PageRoutes;

package/dist/esm/__internal/index.js

@@ -1,17 +1,16 @@
+// Internals needed by Vike
+export { setBuildEntry } from '../node/runtime/globalContext.js';
 // Internals needed by vite-plugin-vercel
 export { route, getPagesAndRoutes };
 // Internals needed by experimental implementation of vike-telefunc
 export { getMiddlewares };
 import { route as routeInternal } from '../shared/route/index.js';
-import { getPageFilesAll } from '../shared/getPageFiles.js';
+import { getPageFilesAll } from '../shared/getPageFiles/getPageFiles.js';
 import { getGlobalContext, initGlobalContext_getGlobalContextAsync } from '../node/runtime/globalContext.js';
 import { setNodeEnvProduction } from '../utils/assertSetup.js';
 import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
 /**
- * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel}
- * to compute some rewrite rules and extract { isr } configs.
- * Needs `import 'vike/__internal/setup'`
- * @param config
+ * Used by {@link https://github.com/magne4000/vite-plugin-vercel|vite-plugin-vercel} to compute some rewrite rules and extract { isr } configs.
  */
 async function getPagesAndRoutes() {
     setNodeEnvProduction();

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

@@ -1,10 +1,13 @@
 export { createPageContext };
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
-import { getPageFilesAll } from '../../shared/getPageFiles.js';
+import { getPageFilesAll, setPageFiles } from '../../shared/getPageFiles/getPageFiles.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { getBaseServer } from './getBaseServer.js';
 import { assert, isBaseServer, getGlobalObject, objectAssign } from './utils.js';
+// @ts-ignore
+import * as pageFilesExports from 'virtual:vike:importUserCode:client:client-routing';
 const globalObject = getGlobalObject('createPageContext.ts', {});
+initDevEntry();
 async function createPageContext(urlOriginal) {
     if (!globalObject.pageFilesData) {
         globalObject.pageFilesData = await getPageFilesAll(true);
@@ -31,3 +34,6 @@ async function createPageContext(urlOriginal) {
     objectAssign(pageContext, pageContextUrlComputed);
     return pageContext;
 }
+function initDevEntry() {
+    setPageFiles(pageFilesExports);
+}

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

@@ -1 +1 @@
-import './pageFiles';
+export {};

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

@@ -1,6 +1,5 @@
 import { assertClientRouting } from '../../utils/assertRoutingType.js';
 assertClientRouting();
-import './pageFiles';
 import { initClientRouter } from './initClientRouter.js';
 import { assertSingleInstance_onClientEntryClientRouting } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';

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

@@ -1,7 +1,7 @@
 export { setPageContextCurrent };
 export { getPageContextCurrent };
-import type { PageContextExports } from '../../shared/getPageFiles.js';
-type PageContextCurrent = PageContextExports & {
+import type { PageConfigUserFriendly } from '../../shared/getPageFiles.js';
+type PageContextCurrent = PageConfigUserFriendly & {
     urlPathname: string;
 };
 declare function getPageContextCurrent(): null | PageContextCurrent;

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

@@ -5,7 +5,7 @@ export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
 export type { PageContextFromServerHooks };
 export type { PageContextFromClientHooks };
-import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly, PageFile } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContext = {
     urlOriginal: string;
@@ -21,9 +21,9 @@ declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
     routeParams: Record<string, string>;
     _hasPageContextFromServer: true;
 };
-declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageContextExports & {
+declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageConfigUserFriendly & {
     _hasPageContextFromServer: true;
-}): Promise<PageContextSerialized & PageContext & PageContextExports & {
+}): Promise<PageContextSerialized & PageContext & PageConfigUserFriendly & {
     _hasPageContextFromServer: true;
 } & {
     _hasPageContextFromClient: boolean;
@@ -45,5 +45,5 @@ type PageContextFromClientHooks = {
 declare function getPageContextFromClientHooks(pageContext: {
     pageId: string;
     _hasPageContextFromServer: boolean;
-} & PageContext & PageContextExports, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
+} & PageContext & PageConfigUserFriendly, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
 declare function setPageContextInitIsPassedToClient(pageContext: Record<string, unknown>): void;

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

@@ -12,7 +12,7 @@ import { preparePageContextForUserConsumptionClientSide } from '../shared/prepar
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getPageConfig } from '../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueRuntime.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';

package/dist/esm/client/client-routing-runtime/prefetch/getPrefetchSettings.d.ts

@@ -1,10 +1,10 @@
 export { getPrefetchSettings };
 export { PAGE_CONTEXT_MAX_AGE_DEFAULT };
 export type { PrefetchSettingResolved };
-import type { PageContextExports } from '../../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly } from '../../../shared/getPageFiles.js';
 declare const PAGE_CONTEXT_MAX_AGE_DEFAULT = 5000;
 type PrefetchSettingResolved = {
     staticAssets: false | 'hover' | 'viewport';
     pageContext: false | number;
 };
-declare function getPrefetchSettings(pageContext: PageContextExports, linkTag: null | HTMLElement): PrefetchSettingResolved;
+declare function getPrefetchSettings(pageContext: PageConfigUserFriendly, linkTag: null | HTMLElement): PrefetchSettingResolved;

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

@@ -6,7 +6,7 @@ export { addLinkPrefetchHandlers };
 export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { type PageContextFromServerHooks, getPageContextFromServerHooks } from './getPageContextFromHooks.js';
-import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly, PageFile } from '../../shared/getPageFiles.js';
 import { type PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type ResultPageContextFromServer = Awaited<ReturnType<typeof getPageContextFromServerHooks>>;
 type PageContextForPrefetch = {
@@ -19,7 +19,7 @@ type PageContextForPrefetch = {
 };
 declare function getPageContextPrefetched(pageContext: {
     urlPathname: string;
-} & PageContextExports): null | PageContextFromServerHooks;
+} & PageConfigUserFriendly): null | PageContextFromServerHooks;
 declare function populatePageContextPrefetchCache(pageContext: PageContextForPrefetch, result: ResultPageContextFromServer): void;
 /**
  * Programmatically prefetch client assets.

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

@@ -60,8 +60,8 @@ async function prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge)
     const result = await getPageContextFromServerHooks(pageContextLink, false);
     setPageContextPrefetchCache(pageContextLink, result, resultMaxAge);
 }
-function populatePageContextPrefetchCache(pageContext /*& PageContextExports*/, result) {
-    // TODO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use PageContextExports as it isn't available here.)
+function populatePageContextPrefetchCache(pageContext /*& PageConfigUserFriendly*/, result) {
+    // TODO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use PageConfigUserFriendly as it isn't available here.)
     if (!isBrilloutDocpress())
         return;
     setPageContextPrefetchCache(pageContext, result, null);

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

@@ -1 +1 @@
-import './pageFiles';
+export {};

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

@@ -1,6 +1,5 @@
 import { assertServerRouting } from '../../utils/assertRoutingType.js';
 assertServerRouting();
-import './pageFiles';
 import { getPageContext } from './getPageContext.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook } from '../../shared/hooks/getHook.js';

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

@@ -10,6 +10,6 @@ declare function getPageContext(): Promise<{
 } & {
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];
-} & import("../../shared/getPageFiles.js").PageContextExports & {
+} & import("../../shared/getPageFiles.js").PageConfigUserFriendly & {
     _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 }>;

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

@@ -1,10 +1,13 @@
+export { getPageContext };
 import { assertUsage, assertWarning, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
-import { getPageFilesAll } from '../../shared/getPageFiles.js';
+import { getPageFilesAll, setPageFiles } from '../../shared/getPageFiles/getPageFiles.js';
 import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-export { getPageContext };
+// @ts-ignore
+import * as pageFilesExports from 'virtual:vike:importUserCode:client:server-routing';
 const urlFirst = getCurrentUrl({ withoutHash: true });
+initDevEntry();
 async function getPageContext() {
     const pageContext = getPageContextSerializedInHtml();
     objectAssign(pageContext, {
@@ -36,3 +39,6 @@ async function loadPageUserFiles(pageId) {
     });
     return pageContextAddendum;
 }
+function initDevEntry() {
+    setPageFiles(pageFilesExports);
+}

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

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

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

@@ -1,9 +1,9 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
 export type { PageContextUserFiles };
-import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
+import { type PageFile, type PageConfigUserFriendly } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-type PageContextUserFilesLoaded = PageContextExports & {
+type PageContextUserFilesLoaded = PageConfigUserFriendly & {
     _pageFilesLoaded: PageFile[];
 };
 type PageContextUserFiles = {

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

@@ -1,6 +1,6 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
-import { getPageFilesClientSide, getPageContextExports } from '../../shared/getPageFiles.js';
+import { getPageFilesClientSide, getPageConfigUserFriendly } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../server-routing-runtime/utils.js';
@@ -29,7 +29,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         }
         throw err;
     }
-    const pageContextExports = getPageContextExports(pageFilesClientSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendly(pageFilesClientSide, pageConfigLoaded);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

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

@@ -1,9 +1,9 @@
 export { preparePageContextForUserConsumptionClientSide };
 export type { PageContextForUserConsumptionClientSide };
-import type { PageContextExports } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
-type PageContextForUserConsumptionClientSide = PageContextExports & PageContextForPassToClientWarning & {
+type PageContextForUserConsumptionClientSide = PageConfigUserFriendly & PageContextForPassToClientWarning & {
     pageId: string;
     _pageConfigs: PageConfigRuntime[];
 };

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

@@ -1,6 +1,7 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite } from 'vite';
+import { isPrerenderEnabled } from '../prerender/isPrerenderEnabled.js';
 /**
  * Programmatically trigger `$ vike build`
  *
@@ -13,9 +14,7 @@ async function build(options = {}) {
     // Build server-side
     const outputServer = await buildVite(setSSR(viteConfigEnhanced));
     // Pre-render
-    if (vikeConfigGlobal.prerender &&
-        !vikeConfigGlobal.prerender.disableAutoRun &&
-        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
+    if (isPrerenderEnabled(vikeConfigGlobal)) {
         const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
         await runPrerenderFromAutoRun(viteConfigEnhanced, true);
     }
@@ -31,7 +30,7 @@ function setSSR(viteConfig) {
     return {
         ...viteConfig,
         build: {
-            ...viteConfig.build,
+            ...viteConfig?.build,
             ssr: true
         }
     };

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

@@ -1,7 +1,13 @@
 export { prepareViteApiCall };
-import type { InlineConfig } from 'vite';
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { Operation } from './types.js';
 declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
-    viteConfigEnhanced: InlineConfig;
-    vikeConfigGlobal: import("../plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js").VikeConfigGlobal;
+    viteConfigEnhanced: InlineConfig | undefined;
+    vikeConfigGlobal: import("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js").VikeConfigGlobal;
 }>;
+declare function getViteRoot(operation: 'build' | 'dev' | 'preview' | 'prerender'): Promise<string>;
+declare function normalizeViteRoot(root: string): string;
+declare function assertViteRoot(root: string, config: ResolvedConfig): void;