vike 0.4.224-commit-00ed9fe → 0.4.225-commit-37a36a5

package/dist/esm/node/prerender/resolvePrerenderConfig.js

@@ -1,25 +1,33 @@
 export { resolvePrerenderConfigGlobal };
 export { resolvePrerenderConfigLocal };
-import { assert, isArray, objectAssign } from './utils.js';
+import { assert, isArray, isObject, objectAssign } from './utils.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
+// When setting +prerender to an object => it also enables pre-rendering
+const defaultValueForObject = true;
 function resolvePrerenderConfigGlobal(vikeConfig) {
-    const prerenderConfigs = vikeConfig.global.config.prerender;
-    let prerenderConfigList = prerenderConfigs || [];
-    // Needed because of backwards compatibility of `vike({prerender:true})` in `vite.config.js`; after we remove it we can remove this line.
-    prerenderConfigList = prerenderConfigList.filter(isObject2);
-    assert(prerenderConfigList.every(isObject2)); // Help TS
+    const prerenderConfigs = vikeConfig.global.config.prerender || [];
+    const prerenderSettings = prerenderConfigs.filter(isObject2);
     const prerenderConfigGlobal = {
-        partial: pickFirst(prerenderConfigList.map((c) => c.partial)) ?? false,
-        noExtraDir: pickFirst(prerenderConfigList.map((c) => c.noExtraDir)) ?? false,
-        parallel: pickFirst(prerenderConfigList.map((c) => c.parallel)) ?? true,
-        disableAutoRun: pickFirst(prerenderConfigList.map((c) => c.disableAutoRun)) ?? false
+        partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
     };
-    const prerenderConfigGlobalLocalValue = prerenderConfigList.map((c) => c.value).filter((v) => v !== null);
-    const defaultLocalValue = pickFirst(prerenderConfigGlobalLocalValue) ??
-        (prerenderConfigGlobalLocalValue.length > 0 ||
-            // Backwards compatibility for with vike({ prerender: true }) in vite.config.js
-            prerenderConfigs?.some((p) => p === true) ||
-            false);
+    let defaultLocalValue = false;
+    {
+        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.value !== null)[0];
+        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.value ?? defaultValueForObject))) {
+            defaultLocalValue = true;
+        }
+    }
+    // TODO/next-major: remove
+    // Backwards compatibility for `vike({prerender:true})` in vite.config.js
+    {
+        const valuesWithDefinedAt = vikeConfig.global._from.configsCumulative.prerender?.values ?? [];
+        if (valuesWithDefinedAt.some((v) => v.definedAt.includes('vite.config.js') && v.value)) {
+            defaultLocalValue = true;
+        }
+    }
     objectAssign(prerenderConfigGlobal, {
         defaultLocalValue,
         isPrerenderingEnabledForAllPages: vikeConfig.pageConfigs.length > 0 &&
@@ -45,8 +53,8 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const prerenderConfigLocal = { value };
     return prerenderConfigLocal;
 }
-function isObject2(p) {
-    return typeof p === 'object' && p !== null;
+function isObject2(value) {
+    return typeof value === 'object' && value !== null;
 }
 function pickFirst(arr) {
     return arr.filter((v) => v !== undefined)[0];

package/dist/esm/node/prerender/runPrerender.js

@@ -4,7 +4,7 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject, makePublicCopy, PROJECT_VERSION } from './utils.js';
 import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -38,7 +38,7 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await prepareViteApiCall(undefined, 'prerender');
+        const { viteConfigEnhanced } = await prepareViteApiCall({}, 'prerender');
         await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
     }
     catch (err) {
@@ -75,7 +75,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     getHook_setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
-        console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
+        console.log(`${pc.cyan(`vike v${PROJECT_VERSION}`)} ${pc.green('pre-rendering HTML...')}`);
     }
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');

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

@@ -1,6 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/hasProp.js';
-export * from '../../utils/projectInfo.js';
+export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';

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

@@ -2,7 +2,7 @@ import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 assertIsNotBrowser();
 export * from '../../utils/assert.js';
 export * from '../../utils/hasProp.js';
-export * from '../../utils/projectInfo.js';
+export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/isObjectWithKeys.js';
 export * from '../../utils/isCallable.js';

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

@@ -25,7 +25,7 @@ export { updateUserFiles };
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
 //   - globalObject.viteDevServer is used by updateUserFiles() which then sets globalConfig.userFiles
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, projectInfo, checkType } from './utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, checkType, PROJECT_VERSION } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
 import pc from '@brillout/picocolors';
@@ -89,9 +89,10 @@ function makePublic(globalContext) {
 async function setGlobalContext_viteDevServer(viteDevServer) {
     debug('setGlobalContext_viteDevServer()');
     setIsProduction(false);
-    if (globalObject.viteDevServer)
-        return;
-    assertIsNotInitilizedYet();
+    // We cannot cache globalObject.viteDevServer because it's fully replaced when the user modifies vite.config.js => Vite's dev server is fully reloaded and a new viteDevServer replaces the previous one.
+    if (!globalObject.viteDevServer) {
+        assertIsNotInitilizedYet();
+    }
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
     await updateUserFiles();
@@ -351,7 +352,7 @@ function assertBuildInfo(buildInfo) {
     checkType({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
 }
 function assertVersionAtBuildTime(versionAtBuildTime) {
-    const versionAtRuntime = projectInfo.projectVersion;
+    const versionAtRuntime = PROJECT_VERSION;
     const pretty = (version) => pc.bold(`vike@${version}`);
     assertUsage(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
@@ -369,7 +370,7 @@ async function updateUserFiles() {
     const { promise, resolve } = genPromise();
     assert(!globalObject.isProduction);
     globalObject.waitForUserFilesUpdate = promise;
-    const viteDevServer = getViteDevServer();
+    const { viteDevServer } = globalObject;
     assert(viteDevServer);
     let virtualFileExports;
     try {
@@ -381,6 +382,9 @@ async function updateUserFiles() {
     }
     virtualFileExports = virtualFileExports.default || virtualFileExports;
     debugGlob('Glob result: ', virtualFileExports);
+    // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
+    if (viteDevServer !== globalObject.viteDevServer)
+        return;
     await setUserFiles(virtualFileExports);
     resolve();
 }

package/dist/esm/node/runtime/html/injectAssets/getViteDevScript.js

@@ -1,6 +1,7 @@
 export { getViteDevScript };
 import { assert, assertUsage, assertWarning } from '../../utils.js';
 import pc from '@brillout/picocolors';
+const reachOutCTA = 'Create a new GitHub issue to discuss a solution.';
 async function getViteDevScript(pageContext) {
     const globalContext = pageContext._globalContext;
     if (globalContext.isProduction) {
@@ -12,11 +13,13 @@ async function getViteDevScript(pageContext) {
     let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;
     fakeHtml = await viteDevServer.transformIndexHtml('/', fakeHtml);
     assertUsage(!fakeHtml.includes('vite-plugin-pwa'), `The HTML transformer of ${pc.cyan('vite-plugin-pwa')} cannot be applied, see workaround at https://github.com/vikejs/vike/issues/388#issuecomment-1199280084`);
-    assertUsage(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), 'Vite plugins that minify the HTML are not supported by vike, see https://github.com/vikejs/vike/issues/224');
-    assertUsage(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), 'You are using a Vite Plugin that transforms the HTML in a way that conflicts with vike. Create a new GitHub ticket to discuss a solution.');
+    assertUsage(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), `Vite plugins that minify the HTML cannot be applied, see https://github.com/vikejs/vike/issues/224`);
+    assertUsage(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), `You are using a Vite Plugin that transforms the HTML in a way that conflicts with Vike. ${reachOutCTA}`);
     const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
     assert(viteInjection.includes('script'));
-    assertWarning(!viteInjection.includes('import('), 'Unexpected Vite HMR code. Reach out to a Vike maintainer on GitHub.', { onlyOnce: true });
+    assertWarning(!viteInjection.includes('import('), `Unexpected Vite injected HMR code. ${reachOutCTA}`, {
+        onlyOnce: true
+    });
     const viteDevScript = viteInjection;
     return viteDevScript;
 }

package/dist/esm/node/runtime/index-deprecated.d.ts

@@ -13,6 +13,4 @@ import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js
  *
  * See https://vike.dev/render
  */
-export declare const RenderErrorPage: (args_0?: {
-    pageContext?: Record<string, unknown>;
-} | undefined) => Error;
+export declare const RenderErrorPage: (...args: Parameters<typeof RenderErrorPage_>) => Error;

package/dist/esm/node/runtime/renderPage/createHttpResponse/assertNoInfiniteHttpRedirect.d.ts

@@ -1,4 +1,4 @@
 export { assertNoInfiniteHttpRedirect };
 declare function assertNoInfiniteHttpRedirect(urlRedirectTarget: string, pageContextInit: {
     urlOriginal: string;
-}): void;
+}): "DISABLED" | undefined;

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

@@ -4,14 +4,15 @@ import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-// It's too strict, see https://github.com/vikejs/vike/issues/1270#issuecomment-1820608999
-// - Let's create a new setting `+doNotCatchInfiniteRedirect` if someone complains.
 function assertNoInfiniteHttpRedirect(
 // The exact URL that the user will be redirected to.
 // - It includes the Base URL as well as the locale (i18n) base.
 urlRedirectTarget, 
 // Rationale for checking against `pageContextInit.urlOriginal`: https://github.com/vikejs/vike/pull/2264#issuecomment-2713890263
 pageContextInit) {
+    // TO-DO/eventually: use cookie as described at https://github.com/vikejs/vike/pull/2273
+    if (true)
+        return 'DISABLED'; // Disabled until we make it reliable.
     if (!urlRedirectTarget.startsWith('/')) {
         // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (at least not in itself).
         //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin; we hope/assume the user sets the URL without origin.

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/page-configs/Config.d.ts

@@ -297,7 +297,9 @@ type ConfigBuiltIn = {
          */
         disableAutoRun?: boolean;
         /**
-         * Set prerender settings without enabling pre-rendering.
+         * Whether to enable pre-rendering.
+         *
+         * Setting `value: null` enables you to set prerender settings without activating pre-rendering. (Useful for Vike extensions.)
          *
          * https://vike.dev/prerender#value
          *
@@ -471,6 +473,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,7 +92,7 @@ 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 */
@@ -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;

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.js

@@ -4,10 +4,6 @@ import { assert, assertUsage, isCallable } from '../../utils.js';
 import { getConfigDefinedAt } from '../getConfigDefinedAt.js';
 import { parseTransform } from '@brillout/json-serializer/parse';
 import { assertPlusFileExport } from '../assertPlusFileExport.js';
-function parseConfigValuesSerialized(configValuesSerialized) {
-    const configValues = parseConfigValuesSerialized_tmp(configValuesSerialized);
-    return configValues;
-}
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     // pageConfigs
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
@@ -43,7 +39,7 @@ function assertRouteConfigValue(configValues) {
    }
    */
 }
-function parseConfigValuesSerialized_tmp(configValuesSerialized) {
+function parseConfigValuesSerialized(configValuesSerialized) {
     const configValues = {};
     Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
         let configValue;
@@ -100,6 +96,7 @@ function parseValueSerialized(valueSerialized, configName, getDefinedAtFile) {
     if (valueSerialized.type === 'plus-file') {
         const definedAtFile = getDefinedAtFile();
         const { exportValues } = valueSerialized;
+        assert(!definedAtFile.definedBy);
         assertPlusFileExport(exportValues, definedAtFile.filePathToShowToUser, configName);
         let value;
         let valueWasFound = false;

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

@@ -2,7 +2,7 @@ export { serializeConfigValues };
 export { getConfigValuesBase };
 export { isJsonValue };
 export type { FilesEnv };
-import type { ConfigEnvInternal, ConfigValueSource, DefinedAtFile, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAt, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
 declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], filesEnv: FilesEnv, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
 declare function isJsonValue(value: unknown): boolean;
 declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;
@@ -17,14 +17,14 @@ type ConfigValuesBase = ({
 } | {
     configValueBase: {
         type: 'standard';
-        definedAtData: DefinedAtFile;
+        definedAtData: DefinedAt;
     };
     sourceRelevant: ConfigValueSource;
     configName: string;
 } | {
     configValueBase: {
         type: 'cumulative';
-        definedAtData: DefinedAtFile[];
+        definedAtData: DefinedAt[];
     };
     sourcesRelevant: ConfigValueSource[];
     configName: string;

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

@@ -47,7 +47,7 @@ function serializeConfigValues(pageConfig, importStatements, filesEnv, isEnvMatc
 function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
     let valueData;
     if (configValueSource.valueIsLoaded && !configValueSource.valueIsLoadedWithImport) {
-        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements, filesEnv, configValueSource.configEnv);
+        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAt, importStatements, filesEnv, configValueSource.configEnv);
     }
     else {
         valueData = getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName);
@@ -98,8 +98,9 @@ function serializeConfigValue(configValueBase, valueData, configName, lines, tab
 }
 function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
     assert(!configValueSource.valueIsFilePath);
-    const { valueIsDefinedByPlusValueFile, definedAtFilePath, configEnv } = configValueSource;
-    const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
+    const { valueIsDefinedByPlusValueFile, definedAt, configEnv } = configValueSource;
+    assert(!definedAt.definedBy);
+    const { filePathAbsoluteVite, fileExportName } = definedAt;
     if (valueIsDefinedByPlusValueFile)
         assert(fileExportName === undefined);
     const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*', filesEnv, configEnv, configName);
@@ -226,9 +227,12 @@ function getConfigValuesBase(pageConfig, isEnvMatch, isEager) {
     return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
 }
 function getDefinedAtFileSource(source) {
+    const { definedAt } = source;
+    if (definedAt.definedBy)
+        return definedAt;
     const definedAtFile = {
-        filePathToShowToUser: source.definedAtFilePath.filePathToShowToUser,
-        fileExportPathToShowToUser: source.definedAtFilePath.fileExportPathToShowToUser
+        filePathToShowToUser: definedAt.filePathToShowToUser,
+        fileExportPathToShowToUser: definedAt.fileExportPathToShowToUser
     };
     return definedAtFile;
 }

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

@@ -60,11 +60,11 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             if (!pageRoute) {
                 const { routeFilesystem } = pageConfig;
                 assert(routeFilesystem);
-                const { routeString, definedBy } = routeFilesystem;
+                const { routeString, definedAtLocation } = routeFilesystem;
                 assert(routeFilesystem.routeString.startsWith('/'));
                 pageRoute = {
                     pageId,
-                    routeFilesystemDefinedBy: definedBy,
+                    routeFilesystemDefinedBy: definedAtLocation,
                     comesFromV1PageConfig,
                     routeString,
                     routeDefinedAtString: null,

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

@@ -138,7 +138,11 @@ type PageContextBuiltInCommon<Data> = {
      */
     isBaseMissing?: true;
 };
-type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer;
+type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
+    isHydration?: undefined;
+    isBackwardNavigation?: undefined;
+    previousPageContext?: undefined;
+};
 type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & {
     /** Whether the current page is already rendered to HTML */
     isHydration: boolean;