vike 0.4.224 → 0.4.225-commit-2b7971f

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

@@ -2,6 +2,7 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 export { prerender404Page };
 export { getPageContextInitEnhanced };
+export { createPageContext };
 export type { PageContextAfterRender };
 export type { PageContextInitEnhanced };
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
@@ -32,6 +33,10 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     documentHtml: string;
     pageContextSerialized: null;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -62,7 +67,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
             pageRoutes: import("../../../__internal/index.js").PageRoutes;
             onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
             pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-            config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+            config: import("../../../types/index.js").ConfigResolved;
         } & ({
             isProduction: false;
             isPrerendering: false;
@@ -118,6 +123,10 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     documentHtml: string;
     pageContextSerialized: string;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -148,7 +157,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
             pageRoutes: import("../../../__internal/index.js").PageRoutes;
             onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
             pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-            config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+            config: import("../../../types/index.js").ConfigResolved;
         } & ({
             isProduction: false;
             isPrerendering: false;
@@ -205,6 +214,10 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     documentHtml: string;
     pageContextSerialized: null;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -235,7 +248,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
             pageRoutes: import("../../../__internal/index.js").PageRoutes;
             onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
             pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-            config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+            config: import("../../../types/index.js").ConfigResolved;
         } & ({
             isProduction: false;
             isPrerendering: false;
@@ -291,6 +304,10 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     documentHtml: string;
     pageContextSerialized: string;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -321,7 +338,7 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
             pageRoutes: import("../../../__internal/index.js").PageRoutes;
             onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
             pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-            config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+            config: import("../../../types/index.js").ConfigResolved;
         } & ({
             isProduction: false;
             isPrerendering: false;
@@ -379,13 +396,17 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     urlOriginal: string;
     headersOriginal?: unknown;
     headers?: unknown;
-}, globalContext: GlobalContextInternal, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
+}, globalContext: GlobalContextInternal, isPrerendering: boolean, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
     ssr?: {
         urlRewrite: null | string;
         urlHandler: null | ((url: string) => string);
         isClientSideNavigation: boolean;
     };
 }): Promise<{
+    _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Record<string, unknown> & {
     urlOriginal: string;
     headersOriginal?: unknown;
     headers?: unknown;
@@ -416,7 +437,7 @@ declare function getPageContextInitEnhanced(pageContextInit: {
         pageRoutes: import("../../../__internal/index.js").PageRoutes;
         onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
         pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
-        config: import("../../../shared/page-configs/Config/PageContextConfig.js").ConfigResolved;
+        config: import("../../../types/index.js").ConfigResolved;
     } & ({
         isProduction: false;
         isPrerendering: false;
@@ -450,3 +471,8 @@ declare function getPageContextInitEnhanced(pageContextInit: {
 } & {
     headers: Record<string, string> | null;
 }>;
+declare function createPageContext(pageContextInit: Record<string, unknown>, isPrerendering: boolean): {
+    _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Record<string, unknown>;

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -2,6 +2,7 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 export { prerender404Page };
 export { getPageContextInitEnhanced };
+export { createPageContext };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import { assert, assertUsage, assertWarning, hasProp, normalizeHeaders, objectAssign } from '../utils.js';
@@ -84,7 +85,11 @@ async function prerender404Page(pageContextInit_, globalContext) {
     if (!errorPageId) {
         return null;
     }
-    const pageContext = {
+    // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
+    const pageContextInit = { urlOriginal: '/fake-404-url' };
+    objectAssign(pageContextInit, pageContextInit_);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
+    objectAssign(pageContext, {
         pageId: errorPageId,
         _httpRequestId: null,
         _urlRewrite: null,
@@ -93,25 +98,17 @@ async function prerender404Page(pageContextInit_, globalContext) {
         // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
         _usesClientRouter: false,
         _debugRouteMatches: []
-    };
-    const pageContextInit = {
-        urlOriginal: '/fake-404-url' // A URL is needed for `applyViteHtmlTransform`
-    };
-    objectAssign(pageContextInit, pageContextInit_);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        objectAssign(pageContext, pageContextInitEnhanced);
-    }
+    });
     objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     return prerenderPage(pageContext);
 }
-async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+async function getPageContextInitEnhanced(pageContextInit, globalContext, isPrerendering, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,
     isClientSideNavigation: false
 } } = {}) {
     assert(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = {};
+    const pageContextInitEnhanced = createPageContext(pageContextInit, isPrerendering);
     objectAssign(pageContextInitEnhanced, pageContextInit);
     objectAssign(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
@@ -158,3 +155,12 @@ async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr:
     }
     return pageContextInitEnhanced;
 }
+function createPageContext(pageContextInit, isPrerendering) {
+    const pageContext = {
+        _isPageContextObject: true,
+        isClientSide: false,
+        isPrerendering
+    };
+    objectAssign(pageContext, pageContextInit);
+    return pageContext;
+}

package/dist/esm/node/runtime/renderPage.js

@@ -1,8 +1,8 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
-import { getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
+import { getPageContextInitEnhanced, renderPageAlreadyRouted, createPageContext } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContextInternal, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -103,15 +103,9 @@ async function renderPageAlreadyPrepared(pageContextInit, globalContext, httpReq
     // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
     0);
     let pageContextNominalPageSuccess;
-    let pageContextNominalPageInit = {};
-    {
-        const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
-        objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
-    }
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
-        objectAssign(pageContextNominalPageInit, pageContextInitEnhanced);
-    }
+    const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
+    const pageContextNominalPageInit = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, pageContextFromAllRewrites._urlRewrite, httpRequestId);
+    objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
     let errNominalPage;
     {
         try {
@@ -242,7 +236,7 @@ function prettyUrl(url) {
     return pc.bold(decodeURI(url));
 }
 function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
-    const pageContextWithError = createPageContext(pageContextInit);
+    const pageContextWithError = createPageContext(pageContextInit, false);
     const httpResponse = createHttpResponseError(pageContext);
     objectAssign(pageContextWithError, {
         httpResponse,
@@ -250,13 +244,6 @@ function getPageContextHttpResponseError(err, pageContextInit, pageContext) {
     });
     return pageContextWithError;
 }
-function createPageContext(pageContextInit) {
-    const pageContext = {
-        _isPageContextObject: true
-    };
-    Object.assign(pageContext, pageContextInit);
-    return pageContext;
-}
 async function renderPageNominal(pageContext) {
     objectAssign(pageContext, { errorWhileRendering: null });
     // Route
@@ -281,10 +268,8 @@ async function renderPageNominal(pageContext) {
     return pageContextAfterRender;
 }
 async function getPageContextErrorPageInit(pageContextInit, globalContext, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
-    const pageContextInitEnhanced = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
+    const pageContext = await getPageContextInitEnhancedSSR(pageContextInit, globalContext, null, httpRequestId);
     assert(errNominalPage);
-    const pageContext = {};
-    objectAssign(pageContext, pageContextInitEnhanced);
     objectAssign(pageContext, {
         is404: false,
         errorWhileRendering: errNominalPage,
@@ -298,7 +283,7 @@ async function getPageContextErrorPageInit(pageContextInit, globalContext, errNo
 }
 async function getPageContextInitEnhancedSSR(pageContextInit, globalContext, urlRewrite, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext, {
+    const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext, false, {
         ssr: {
             urlRewrite,
             urlHandler: _urlHandler,
@@ -341,8 +326,8 @@ async function normalizeUrl(pageContextInit, globalContext, httpRequestId) {
     if (!urlNormalized)
         return null;
     logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
-    const pageContextHttpResponse = createPageContext(pageContextInit);
+    const httpResponse = createHttpResponseRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit);
+    const pageContextHttpResponse = createPageContext(pageContextInit, false);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
@@ -383,15 +368,17 @@ async function getPermanentRedirect(pageContextInit, globalContext, httpRequestI
         assert(urlTarget !== pageContextInit.urlOriginal);
     }
     logRuntimeInfo?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
-    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
-    const pageContextHttpResponse = createPageContext(pageContextInit);
+    const httpResponse = createHttpResponseRedirect({ url: urlTarget, statusCode: 301 }, pageContextInit);
+    const pageContextHttpResponse = createPageContext(pageContextInit, false);
     objectAssign(pageContextHttpResponse, { httpResponse });
     return pageContextHttpResponse;
 }
 function normalize(url) {
     return url || '/';
 }
-async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
+async function handleAbortError(errAbort, pageContextsFromRewrite, 
+// The original `pageContextInit` object passed to `renderPage(pageContextInit)`
+pageContextInit, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
 pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalContext) {
     logAbortErrorHandled(errAbort, globalContext.isProduction, pageContextNominalPageInit);
@@ -403,10 +390,10 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
             const abortCall = pageContextAbort._abortCall;
             assert(abortCall);
             assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
-            const pageContext = createPageContext({});
+            const pageContext = createPageContext({}, false);
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
-            objectAssign(pageContext, pageContextErrorPageInit);
+            objectAssign(pageContext, pageContextErrorPageInit, true);
             objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = serializePageContextClientSide(pageContext);
@@ -427,15 +414,9 @@ pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit, globalConte
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRedirect) {
-        const pageContextReturn = createPageContext(pageContextInit);
+        const pageContextReturn = createPageContext(pageContextInit, false);
         objectAssign(pageContextReturn, pageContextAbort);
-        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, (() => {
-            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
-            const urlLogical = createUrlFromComponents(null, pathname, searchOriginal, 
-            // The server-side doesn't have access to the hash
-            null);
-            return urlLogical;
-        })());
+        const httpResponse = createHttpResponseRedirect(pageContextAbort._urlRedirect, pageContextInit);
         objectAssign(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }
@@ -448,7 +429,7 @@ async function checkBaseUrl(pageContextInit, globalContext) {
     const { isBaseMissing } = parseUrl(urlOriginal, baseServer);
     if (!isBaseMissing)
         return;
-    const pageContext = createPageContext(pageContextInit);
+    const pageContext = createPageContext(pageContextInit, false);
     const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
     objectAssign(pageContext, {
         httpResponse,
@@ -461,7 +442,7 @@ function renderInvalidRequest(pageContextInit) {
     const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
     if (urlPathnameWithBase.endsWith('/favicon.ico')) {
-        const pageContext = createPageContext(pageContextInit);
+        const pageContext = createPageContext(pageContextInit, false);
         const httpResponse = createHttpResponseFavicon404();
         objectAssign(pageContext, { httpResponse });
         checkType(pageContext);

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

@@ -11,7 +11,6 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/parseUrl-extras.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/sorter.js';
-export * from '../../utils/projectInfo.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/objectAssign.js';

package/dist/esm/node/runtime/utils.js

@@ -15,7 +15,6 @@ export * from '../../utils/parseUrl.js';
 export * from '../../utils/parseUrl-extras.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/sorter.js';
-export * from '../../utils/projectInfo.js';
 export * from '../../utils/isArray.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/objectAssign.js';

package/dist/esm/node/runtime-dev/createDevMiddleware.js

@@ -9,16 +9,18 @@ import { setGlobalContext_isProduction } from '../runtime/globalContext.js';
  */
 async function createDevMiddleware(options = {}) {
     setGlobalContext_isProduction(false);
-    const viteConfigFromOptions = {
-        ...options.viteConfig,
-        server: {
-            ...options.viteConfig?.server,
-            middlewareMode: options.viteConfig?.server?.middlewareMode ?? true
+    const optionsMod = {
+        ...options,
+        viteConfig: {
+            ...options.viteConfig,
+            root: options.root ?? options.viteConfig?.root,
+            server: {
+                ...options.viteConfig?.server,
+                middlewareMode: options.viteConfig?.server?.middlewareMode ?? true
+            }
         }
     };
-    if (options.root)
-        viteConfigFromOptions.root = options.root;
-    const { viteConfigEnhanced } = await prepareViteApiCall(viteConfigFromOptions, 'dev');
+    const { viteConfigEnhanced } = await prepareViteApiCall(optionsMod, 'dev');
     const server = await createServer(viteConfigEnhanced);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };

package/dist/esm/node/shared/assertV1Design.js

@@ -10,7 +10,8 @@ function assertV1Design(pageConfigs, pageFilesAll) {
             assert(pageConfigs.length > 0);
             const filesV1 = unique(pageConfigs
                 .map((p) => Object.values(p.configValueSources).map((sources) => sources
-                .map((c) => c.definedAtFilePath.filePathAbsoluteUserRootDir)
+                .map((c) => c.definedAt)
+                .map((definedAt) => (definedAt.definedBy ? null : definedAt.filePathAbsoluteUserRootDir))
                 .filter(isNotNullish)
                 .map((filePathToShowToUser) => indent + filePathToShowToUser)))
                 .flat(2));

package/dist/esm/node/shared/utils.d.ts

@@ -1,7 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/projectInfo.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/objectAssign.js';

package/dist/esm/node/shared/utils.js

@@ -3,7 +3,6 @@ assertIsNotBrowser();
 export * from '../../utils/assert.js';
 export * from '../../utils/getFileExtension.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/projectInfo.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/objectAssign.js';

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

@@ -0,0 +1 @@
+export declare const NOT_SERIALIZABLE = "__VIKE__NOT_SERIALIZABLE__";

package/dist/esm/shared/NOT_SERIALIZABLE.js

@@ -0,0 +1,2 @@
+// TODO: move to ../node/runtime/html/NOT_SERIALIZABLE.ts once code is distributed as ESM
+export const NOT_SERIALIZABLE = '__VIKE__NOT_SERIALIZABLE__';

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

@@ -297,13 +297,17 @@ type ConfigBuiltIn = {
          */
         disableAutoRun?: boolean;
         /**
-         * Set prerender settings without enabling pre-rendering.
+         * Whether to enable pre-rendering.
          *
-         * https://vike.dev/prerender#value
+         * Setting `enable: null` enables you to set prerender settings without enabling pre-rendering by default.
+         *
+         * This is useful, for example, if you want pre-rendering to stay opt-in instead of opt-out while setting pre-render settings globally.
+         *
+         * https://vike.dev/prerender#enable
          *
          * @default true
          */
-        value?: boolean | null;
+        enable?: boolean | null;
     };
     /**
      * Install Vike extensions.
@@ -471,6 +475,22 @@ type ConfigBuiltIn = {
      * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
      */
     cacheControl?: string;
+    /**
+     * Make development/preview server available over LAN and public addresses.
+     *
+     * Default: `false` (or `true` if running inside Docker/Podman).
+     *
+     * https://vike.dev/host
+     */
+    host?: boolean | string;
+    /**
+     * Change port of development/preview server.
+     *
+     * @default 3000
+     *
+     * https://vike.dev/port
+     */
+    port?: number;
     /** Where scripts are injected in the HTML.
      *
      * https://vike.dev/injectScriptsAt

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

@@ -17,12 +17,15 @@ export type { ConfigValueSources };
 export type { ConfigValuesComputed };
 export type { DefinedAtData };
 export type { DefinedAtFile };
+export type { DefinedAt };
+export type { DefinedBy };
 export type { DefinedAtFilePath };
 import type { ConfigValueSerialized } from './serialize/PageConfigSerialized.js';
 import type { LocationId } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
 import type { ConfigDefinitions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { PlusFile } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/getPlusFilesAll.js';
+import type { Operation } from '../../node/api/types.js';
 type PageConfigCommon = {
     pageId: string;
 } & PageConfigRoute;
@@ -33,7 +36,7 @@ type PageConfigRoute = {
     isErrorPage?: undefined;
     routeFilesystem: {
         routeString: string;
-        definedBy: string;
+        definedAtLocation: string;
     };
 };
 /** Page config, runtime data structure */
@@ -89,12 +92,12 @@ type ConfigValueSources = Record<string, // configName
 ConfigValueSource[]>;
 type ConfigValueSource = {
     configEnv: ConfigEnvInternal;
-    definedAtFilePath: DefinedAtFilePath;
+    definedAt: DefinedAtFilePath | DefinedBy;
     plusFile: PlusFile | null;
     locationId: LocationId;
     /** Wether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
     valueIsLoadedWithImport: boolean;
-    /** Whether the config value is a file path, for example config.client */
+    /** Whether the config value is a file path, this is currently only true for +client */
     valueIsFilePath?: true;
     /** Whether the config value is defined by a +{configName}.js file */
     valueIsDefinedByPlusValueFile: boolean;
@@ -119,13 +122,13 @@ type ConfigValue = ConfigValueStandard | ConfigValueCumulative | ConfigValueComp
 type ConfigValueStandard = {
     type: 'standard';
     value: unknown;
-    definedAtData: DefinedAtFile;
+    definedAtData: DefinedAt;
 };
 /** Defined by multiple sources (thus multiple file paths). */
 type ConfigValueCumulative = {
     type: 'cumulative';
     value: unknown[];
-    definedAtData: DefinedAtFile[];
+    definedAtData: DefinedAt[];
 };
 /** Defined internally by Vike (currently, Vike doesn't support computed configs created by users). */
 type ConfigValueComputed = {
@@ -133,8 +136,16 @@ type ConfigValueComputed = {
     value: unknown;
     definedAtData: null;
 };
-type DefinedAtData = DefinedAtFile | DefinedAtFile[] | null;
+type DefinedAtData = DefinedAt | DefinedAt[] | null;
+type DefinedAt = DefinedAtFile | DefinedBy;
+type DefinedBy = {
+    definedBy: 'cli' | 'env';
+} | {
+    definedBy: 'api';
+    operation: Operation;
+};
 type DefinedAtFile = {
     filePathToShowToUser: string;
     fileExportPathToShowToUser: null | string[];
+    definedBy?: undefined;
 };

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

@@ -1,11 +1,13 @@
 export { getConfigDefinedAt };
 export { getConfigDefinedAtOptional };
 export { getDefinedAtString };
+export { getDefinedByString };
 export type { ConfigDefinedAt };
 export type { ConfigDefinedAtOptional };
-import type { DefinedAtData, DefinedAtFile } from './PageConfig.js';
+import type { DefinedAtData, DefinedBy } from './PageConfig.js';
 type ConfigDefinedAtOptional = ConfigDefinedAt | `Config ${string} defined internally`;
 type ConfigDefinedAt = `Config ${string} defined at ${string}`;
-declare function getConfigDefinedAt<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: DefinedAtFile | DefinedAtFile[]): `${SentenceBegin} ${ConfigName} defined at ${string}`;
+declare function getConfigDefinedAt<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: NonNullable<DefinedAtData>): `${SentenceBegin} ${ConfigName} defined at ${string}`;
 declare function getConfigDefinedAtOptional<SentenceBegin extends 'Config' | 'config', ConfigName extends string>(sentenceBegin: SentenceBegin, configName: ConfigName, definedAtData: DefinedAtData): `${SentenceBegin} ${ConfigName} defined ${'internally' | `at ${string}`}`;
-declare function getDefinedAtString(definedAtData: DefinedAtFile | DefinedAtFile[], configName: string): string;
+declare function getDefinedAtString(definedAtData: NonNullable<DefinedAtData>, configName: string): string;
+declare function getDefinedByString(definedAt: DefinedBy, configName: string): `API call dev({ vikeConfig: { ${string} } })` | `API call build({ vikeConfig: { ${string} } })` | `API call preview({ vikeConfig: { ${string} } })` | `API call prerender({ vikeConfig: { ${string} } })` | `CLI option --${string}` | `environment variable VIKE_CONFIG="{${string}}"`;

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

@@ -1,7 +1,8 @@
 export { getConfigDefinedAt };
 export { getConfigDefinedAtOptional };
 export { getDefinedAtString };
-import { assert, isArray } from '../utils.js';
+export { getDefinedByString };
+import { assert, checkType, isArray } from '../utils.js';
 import pc from '@brillout/picocolors';
 import { getExportPath } from './getExportPath.js';
 function getConfigDefinedAt(sentenceBegin, configName, definedAtData) {
@@ -28,8 +29,10 @@ function getDefinedAtString(definedAtData, configName) {
     }
     assert(files.length >= 1);
     const definedAtString = files
-        .map((source) => {
-        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
+        .map((definedAt) => {
+        if (definedAt.definedBy)
+            return getDefinedByString(definedAt, configName);
+        const { filePathToShowToUser, fileExportPathToShowToUser } = definedAt;
         let s = filePathToShowToUser;
         const exportPath = getExportPath(fileExportPathToShowToUser, configName);
         if (exportPath) {
@@ -40,3 +43,17 @@ function getDefinedAtString(definedAtData, configName) {
         .join(' / ');
     return definedAtString;
 }
+function getDefinedByString(definedAt, configName) {
+    if (definedAt.definedBy === 'api') {
+        return `API call ${pc.cyan(`${definedAt.operation}({ vikeConfig: { ${configName} } })`)}`;
+    }
+    const { definedBy } = definedAt;
+    if (definedBy === 'cli') {
+        return `CLI option ${pc.cyan(`--${configName}`)}`;
+    }
+    if (definedBy === 'env') {
+        return `environment variable ${pc.cyan(`VIKE_CONFIG="{${configName}}"`)}`;
+    }
+    checkType(definedBy);
+    assert(false);
+}

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

@@ -31,7 +31,7 @@ function getConfigValue(pageConfig, configName) {
         return {
             type: 'standard',
             value: configValueSource.value,
-            definedAtData: getDefinedAtFile(configValueSource)
+            definedAtData: getDefinedAt(configValueSource)
         };
     }
     else {
@@ -51,13 +51,16 @@ function mergeCumulative(configValueSources) {
         assert(configValueSource.configEnv.config === true);
         assert(configValueSource.valueIsLoaded);
         value.push(configValueSource.value);
-        definedAtData.push(getDefinedAtFile(configValueSource));
+        definedAtData.push(getDefinedAt(configValueSource));
     });
     return { value, definedAtData };
 }
-function getDefinedAtFile(configValueSource) {
+function getDefinedAt(configValueSource) {
+    const { definedAt } = configValueSource;
+    if (definedAt.definedBy)
+        return definedAt;
     return {
-        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
+        filePathToShowToUser: definedAt.filePathToShowToUser,
+        fileExportPathToShowToUser: definedAt.fileExportPathToShowToUser
     };
 }

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

@@ -12,7 +12,7 @@ function getConfigValueFilePathToShowToUser(definedAtData) {
     // A unique file path only exists if the config value isn't cumulative nor computed:
     //  - cumulative config values have multiple file paths
     //  - computed values don't have any file path
-    if (!definedAtData || isArray(definedAtData))
+    if (!definedAtData || isArray(definedAtData) || definedAtData.definedBy)
         return null;
     const { filePathToShowToUser } = definedAtData;
     assert(filePathToShowToUser);

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.d.ts

@@ -3,8 +3,8 @@ export { parseConfigValuesSerialized };
 import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../PageConfig.js';
 import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
 import type { ConfigValueSerialized } from './PageConfigSerialized.js';
-declare function parseConfigValuesSerialized(configValuesSerialized: Record<string, ConfigValueSerialized>): ConfigValues;
 declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;
 };
+declare function parseConfigValuesSerialized(configValuesSerialized: Record<string, ConfigValueSerialized>): ConfigValues;