vike 0.4.213 → 0.4.215

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

@@ -0,0 +1,7 @@
+export { onLoad };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { assertIsNotProductionRuntime } from '../runtime/utils.js';
+function onLoad() {
+    assertIsNotBrowser();
+    assertIsNotProductionRuntime();
+}

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

@@ -0,0 +1,7 @@
+export { prepareApiCall };
+import type { InlineConfig } from 'vite';
+import type { Operation } from './types.js';
+declare function prepareApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
+    viteConfigEnhanced: InlineConfig;
+    configVike: import("../../shared/ConfigVike.js").ConfigVikeResolved;
+}>;

package/dist/esm/node/api/{enhanceViteConfig.js → prepareApiCall.js}

@@ -1,9 +1,14 @@
-export { enhanceViteConfig };
+export { prepareApiCall };
 import { resolveConfig } from 'vite';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { pluginName } from '../plugin/plugins/commonConfig/pluginName.js';
-async function enhanceViteConfig(viteConfig = {}, command) {
-    let viteConfigResolved = await resolveViteConfig(viteConfig, command);
+import { setOperation } from './context.js';
+async function prepareApiCall(viteConfig = {}, operation) {
+    setOperation(operation);
+    return enhanceViteConfig(viteConfig, operation);
+}
+async function enhanceViteConfig(viteConfig = {}, operation) {
+    let viteConfigResolved = await resolveViteConfig(viteConfig, operation);
     let viteConfigEnhanced = viteConfig;
     // Add vike to plugins if not present
     if (!viteConfigResolved.plugins.some((p) => p.name === pluginName)) {
@@ -13,7 +18,7 @@ async function enhanceViteConfig(viteConfig = {}, command) {
             ...viteConfig,
             plugins: [...(viteConfig.plugins ?? []), vikePlugin()]
         };
-        viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, command);
+        viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, operation);
     }
     const configVike = await getConfigVike(viteConfigResolved);
     // TODO: enable Vike extensions to add Vite plugins
@@ -22,6 +27,6 @@ async function enhanceViteConfig(viteConfig = {}, command) {
         configVike
     };
 }
-async function resolveViteConfig(viteConfig, command) {
-    return await resolveConfig(viteConfig, command === 'build' || command === 'prerender' ? 'build' : 'serve', 'custom', command === 'dev' ? 'development' : 'production', command === 'preview');
+async function resolveViteConfig(viteConfig, operation) {
+    return await resolveConfig(viteConfig, operation === 'build' || operation === 'prerender' ? 'build' : 'serve', 'custom', operation === 'dev' ? 'development' : 'production', operation === 'preview');
 }

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

@@ -1,3 +1,6 @@
 export { prerender };
 import { type PrerenderOptions } from '../prerender/runPrerender.js';
-declare function prerender(options?: PrerenderOptions): Promise<void>;
+import type { ResolvedConfig } from 'vite';
+declare function prerender(options?: PrerenderOptions): Promise<{
+    viteConfig: ResolvedConfig;
+}>;

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

@@ -1,8 +1,11 @@
 export { prerender };
 import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
-import { enhanceViteConfig } from './enhanceViteConfig.js';
+import { prepareApiCall } from './prepareApiCall.js';
 async function prerender(options = {}) {
-    const { viteConfigEnhanced } = await enhanceViteConfig(options.viteConfig, 'prerender');
+    const { viteConfigEnhanced } = await prepareApiCall(options.viteConfig, 'prerender');
     options.viteConfig = viteConfigEnhanced;
-    await runPrerenderFromAPI(options);
+    const { viteConfig } = await runPrerenderFromAPI(options);
+    return {
+        viteConfig
+    };
 }

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

@@ -1,3 +1,7 @@
 export { preview };
-import type { APIOptions } from './APIOptions.js';
-declare function preview(options?: APIOptions): Promise<import("vite").PreviewServer>;
+import { type ResolvedConfig, type PreviewServer } from 'vite';
+import type { APIOptions } from './types.js';
+declare function preview(options?: APIOptions): Promise<{
+    viteServer: PreviewServer;
+    viteConfig: ResolvedConfig;
+}>;

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

@@ -1,8 +1,11 @@
 export { preview };
-import { enhanceViteConfig } from './enhanceViteConfig.js';
+import { prepareApiCall } from './prepareApiCall.js';
 import { preview as previewVite } from 'vite';
 async function preview(options = {}) {
-    const { viteConfigEnhanced } = await enhanceViteConfig(options.viteConfig, 'preview');
+    const { viteConfigEnhanced } = await prepareApiCall(options.viteConfig, 'preview');
     const server = await previewVite(viteConfigEnhanced);
-    return server;
+    return {
+        viteServer: server,
+        viteConfig: server.config
+    };
 }

package/dist/esm/node/api/{APIOptions.d.ts → types.d.ts}

@@ -1,4 +1,5 @@
-export { APIOptions };
+export type { APIOptions };
+export type { Operation };
 import type { InlineConfig } from 'vite';
 type APIOptions = {
     /**
@@ -8,3 +9,4 @@ type APIOptions = {
      */
     viteConfig?: InlineConfig;
 };
+type Operation = 'build' | 'dev' | 'preview' | 'prerender';

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

@@ -0,0 +1 @@
+export * from '../../utils/assert.js';

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

@@ -0,0 +1,5 @@
+// Utils needed by Vike's API
+// We call onLoad() here so that it's called even when only a subset of the API is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
+import { onLoad } from './onLoad.js';
+onLoad();
+export * from '../../utils/assert.js';

package/dist/esm/node/cli/entry.js

@@ -21,16 +21,16 @@ async function cli() {
 async function cmdDev() {
     const startTime = performance.now();
     try {
-        const server = await dev();
-        await server.listen();
-        const info = server.config.logger.info;
+        const { viteServer } = await dev();
+        await viteServer.listen();
+        const info = viteServer.config.logger.info;
         const startupDurationString = pc.dim(`ready in ${pc.reset(pc.bold(String(Math.ceil(performance.now() - startTime))))} ms`);
         const hasExistingLogs = process.stdout.bytesWritten > 0 || process.stderr.bytesWritten > 0;
         info(`  ${pc.yellow(`${pc.bold(projectInfo.projectName)} v${projectInfo.projectVersion}`)}  ${startupDurationString}\n`, {
             clear: !hasExistingLogs
         });
-        server.printUrls();
-        server.bindCLIShortcuts({ print: true });
+        viteServer.printUrls();
+        viteServer.bindCLIShortcuts({ print: true });
     }
     catch (err) {
         console.error(pc.red(`Error while starting dev server:`));
@@ -52,9 +52,9 @@ async function cmdBuild() {
 }
 async function cmdPreview() {
     try {
-        const server = await preview();
-        server.printUrls();
-        server.bindCLIShortcuts({ print: true });
+        const { viteServer } = await preview();
+        viteServer.printUrls();
+        viteServer.bindCLIShortcuts({ print: true });
     }
     catch (err) {
         console.error(pc.red(`Error while starting preview server:`));

package/dist/esm/node/cli/onLoad.js

@@ -1,5 +1,7 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { assertIsNotProductionRuntime } from '../runtime/utils.js';
 function onLoad() {
     assertIsNotBrowser();
+    assertIsNotProductionRuntime();
 }

package/dist/esm/node/cli/parseCli.js

@@ -4,8 +4,8 @@ import { projectInfo, includes } from './utils.js';
 const commands = [
     { name: 'dev', desc: 'Start development server' },
     { name: 'build', desc: 'Build for production' },
-    { name: 'preview', desc: 'Start preview server using production build' },
-    { name: 'prerender', desc: 'Pre-render pages' }
+    { name: 'preview', desc: 'Start preview server using production build (only works for SSG apps)' },
+    { name: 'prerender', desc: 'Pre-render pages (only needed when partial.disableAutoRun is true)' }
 ];
 function parseCli() {
     const command = (() => {

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

@@ -27,6 +27,7 @@ import { fileEnv } from './plugins/fileEnv.js';
 import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
 import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
+import { vite6HmrRegressionWorkaround } from './plugins/vite6HmrRegressionWorkaround.js';
 assertNodeEnv_onVikePluginLoad();
 markEnvAsVikePluginLoaded();
 assertViteVersion();
@@ -52,7 +53,8 @@ function plugin(vikeConfig) {
         baseUrls(vikeConfig),
         envVarsPlugin(),
         fileEnv(),
-        workaroundCssModuleHmr()
+        workaroundCssModuleHmr(),
+        vite6HmrRegressionWorkaround()
     ];
     return plugins;
 }

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

@@ -9,9 +9,6 @@ import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
 import { manifestTempFile } from './buildConfig.js';
 let forceExit = false;
-assertWarning(!isViteCliCall(), `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
-    onlyOnce: true
-});
 function autoFullBuild() {
     let config;
     let configVike;

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

@@ -1 +1 @@
-export declare const pluginName = "vike:commonConfig-1";
+export declare const pluginName = "vike:commonConfig";

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

@@ -1 +1 @@
-export const pluginName = 'vike:commonConfig-1';
+export const pluginName = 'vike:commonConfig';

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

@@ -8,6 +8,10 @@ import path from 'path';
 import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
 import { pluginName } from './commonConfig/pluginName.js';
 import { getEnvVarObject } from '../shared/getEnvVarObject.js';
+import { isViteCliCall } from '../shared/isViteCliCall.js';
+assertWarning(!isViteCliCall(), `Vite's CLI is deprecated ${pc.underline('https://vike.dev/migration/cli')}`, {
+    onlyOnce: true
+});
 function commonConfig() {
     return [
         {
@@ -18,7 +22,7 @@ function commonConfig() {
             }
         },
         {
-            name: 'vike:commonConfig-2',
+            name: `${pluginName}:post`,
             enforce: 'post',
             configResolved: {
                 order: 'post',

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

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

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

@@ -1,18 +1,17 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, assertWarning, scriptFileExtensions, humanizeTime, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile } from '../../../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensions, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile } from '../../../../utils.js';
 import path from 'path';
 import fs from 'fs/promises';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import pc from '@brillout/picocolors';
 import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
 const execA = promisify(exec);
 const TOO_MANY_UNTRACKED_FILES = 5;
 assertIsNotProductionRuntime();
 assertIsSingleModuleInstance('crawlPlusFiles.ts');
 let gitIsNotUsable = false;
-async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev, crawlWithGit) {
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, crawlWithGit) {
     assertPosixPath(userRootDir);
     assertPosixPath(outDirAbsoluteFilesystem);
     let outDirRelativeFromUserRootDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
@@ -27,7 +26,6 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev, craw
         (!outDirRelativeFromUserRootDir.startsWith('./') &&
             //
             !outDirRelativeFromUserRootDir.startsWith('../')));
-    const timeBefore = new Date().getTime();
     // Crawl
     let files = [];
     const res = crawlWithGit !== false && (await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir));
@@ -43,18 +41,6 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev, craw
     }
     // Filter build files
     files = files.filter((filePath) => !isTemporaryBuildFile(filePath));
-    // Check performance
-    {
-        const timeAfter = new Date().getTime();
-        const timeSpent = timeAfter - timeBefore;
-        if (isDev) {
-            // We only warn in dev, because while building it's expected to take a long time as crawling is competing for resources with other tasks.
-            // Although, in dev, it's also competing for resources e.g. with Vite's `optimizeDeps`.
-            assertWarning(timeSpent < 3 * 1000, `Crawling your ${pc.cyan('+')} files took an unexpected long time (${humanizeTime(timeSpent)}). If you consistently get this warning, then consider reaching out on GitHub.`, {
-                onlyOnce: 'slow-crawling'
-            });
-        }
-    }
     // Normalize
     const plusFiles = files.map((filePath) => {
         // Both `$ git-ls files` and fast-glob return posix paths

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

@@ -80,8 +80,8 @@ async function isV1Design(config, isDev) {
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, crawlWithGit) {
-    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
+async function loadInterfaceFiles(userRootDir, outDirRoot, crawlWithGit) {
+    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, crawlWithGit);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -195,7 +195,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit);
+        ret = await loadVikeConfig(userRootDir, outDirRoot, crawlWithGit);
     }
     catch (err_) {
         hasError = true;
@@ -232,8 +232,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
         }
     }
 }
-async function loadVikeConfig(userRootDir, outDirRoot, isDev, crawlWithGit) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
+async function loadVikeConfig(userRootDir, outDirRoot, crawlWithGit) {
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, crawlWithGit);
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
@@ -779,8 +779,8 @@ function getComputed(configValueSources, configDefinitions) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit) {
-    const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev, crawlWithGit);
+async function findPlusFiles(userRootDir, outDirRoot, crawlWithGit) {
+    const files = await crawlPlusFiles(userRootDir, outDirRoot, crawlWithGit);
     const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }

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

@@ -0,0 +1,3 @@
+export { vite6HmrRegressionWorkaround };
+import type { Plugin } from 'vite';
+declare function vite6HmrRegressionWorkaround(): Plugin;

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

@@ -0,0 +1,33 @@
+export { vite6HmrRegressionWorkaround };
+// https://vite.dev/guide/migration (will be 404 after vite@7 release) > search for `hmrReload()`
+// https://v6.vite.dev/guide/migration (will exist after vite@7 release) > search for `hmrReload()`
+// Workaround seems to work for docs page /banner (which is HTML-only)
+// But doesn't seem to work for /examples/render-modes/ (see https://github.com/vikejs/vike/pull/2069 commit `renable HMR test for HTML-only`)
+function vite6HmrRegressionWorkaround() {
+    return {
+        name: 'vike:vite6HmrRegressionWorkaround',
+        enforce: 'post',
+        hotUpdate: {
+            order: 'post',
+            handler({ modules, server, timestamp }) {
+                if (this.environment.name !== 'ssr')
+                    return;
+                let hasSsrOnlyModules = false;
+                const invalidatedModules = new Set();
+                for (const mod of modules) {
+                    if (mod.id == null)
+                        continue;
+                    const clientModule = server.environments.client.moduleGraph.getModuleById(mod.id);
+                    if (clientModule != null)
+                        continue;
+                    this.environment.moduleGraph.invalidateModule(mod, invalidatedModules, timestamp, true);
+                    hasSsrOnlyModules = true;
+                }
+                if (hasSsrOnlyModules) {
+                    server.ws.send({ type: 'full-reload' });
+                    return [];
+                }
+            }
+        }
+    };
+}

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

@@ -4,8 +4,8 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
 import '../runtime/page-files/setup.js';
-import type { InlineConfig } from 'vite';
-import type { APIOptions } from '../api/APIOptions.js';
+import type { InlineConfig, ResolvedConfig } from 'vite';
+import type { APIOptions } from '../api/types.js';
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -26,7 +26,9 @@ type PrerenderOptions = APIOptions & {
     /** @deprecated */
     base?: string;
 };
-declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<void>;
+declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
+    viteConfig: ResolvedConfig;
+}>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
 declare function runPrerenderFromAutoRun(viteConfig: InlineConfig, forceExit: boolean): Promise<void>;
 declare function runPrerender_forceExit(): void;

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

@@ -28,15 +28,15 @@ import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVik
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
-import { enhanceViteConfig } from '../api/enhanceViteConfig.js';
+import { prepareApiCall } from '../api/prepareApiCall.js';
 async function runPrerenderFromAPI(options = {}) {
-    await runPrerender(options, 'prerender()');
+    return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
     // - We don't use logErrorHint() because we don't have control over what happens with the error. For example, if the user land purposely swallows the error then the hint shouldn't be logged. Also, it's best if the hint is shown to the user *after* the error, but we cannot do/guarentee that.
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await enhanceViteConfig(undefined, 'prerender');
+        const { viteConfigEnhanced } = await prepareApiCall(undefined, 'prerender');
         await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
     }
     catch (err) {
@@ -115,6 +115,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
     warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
+    return { viteConfig };
 }
 async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design

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

@@ -56,7 +56,7 @@ type ConfigVikeUserProvided = {
          *
          * Use this if you want to programmatically initiate the pre-rendering process instead.
          *
-         * https://vike.dev/prerender-programmatic
+         * https://vike.dev/api#prerender
          *
          * @default false
          */

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

@@ -1,14 +1,8 @@
 export { getConfigValueRuntime };
-export { getConfigValueTyped };
-export type { TypeAsString };
 import { type ResolveTypeAsString } from '../utils.js';
 import type { PageConfigRuntime, ConfigValue } from './PageConfig.js';
 import type { ConfigNameBuiltIn } from './Config.js';
-type ConfigName = ConfigNameBuiltIn;
-type TypeAsString = 'string' | 'boolean' | undefined;
-declare function getConfigValueTyped<Type extends TypeAsString = undefined>(configValue: ConfigValue, configName: ConfigName, type?: Type): null | (ConfigValue & {
-    value: ResolveTypeAsString<Type>;
-});
-declare function getConfigValueRuntime<Type extends TypeAsString = undefined>(pageConfig: PageConfigRuntime, configName: ConfigName, type?: Type): null | (ConfigValue & {
+import { type TypeAsString } from './getConfigValueTyped.js';
+declare function getConfigValueRuntime<Type extends TypeAsString = undefined>(pageConfig: PageConfigRuntime, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
     value: ResolveTypeAsString<Type>;
 });

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

@@ -1,34 +1,8 @@
 export { getConfigValueRuntime };
-export { getConfigValueTyped };
-import { assert, assertUsage, getValuePrintable } from '../utils.js';
-import pc from '@brillout/picocolors';
-import { getConfigDefinedAtOptional } from './getConfigDefinedAt.js';
-function getConfigValueTyped(configValue, configName, type) {
-    /* [NULL_HANDLING] Do we really need this? This doesn't seem to make sense, let's eventually (re)move this.
-    // Enable users to suppress global config values by setting the local config value to null
-    if (configValue.value === null) return null
-    */
-    const { value, definedAtData } = configValue;
-    if (type)
-        assertConfigValueType(value, type, configName, definedAtData);
-    return configValue;
-}
+import { getConfigValueTyped } from './getConfigValueTyped.js';
 function getConfigValueRuntime(pageConfig, configName, type) {
     const configValue = pageConfig.configValues[configName];
     if (!configValue)
         return null;
     return getConfigValueTyped(configValue, configName, type);
 }
-function assertConfigValueType(value, type, configName, definedAtData) {
-    assert(value !== null);
-    const typeActual = typeof value;
-    if (typeActual === type)
-        return;
-    const valuePrintable = getValuePrintable(value);
-    const problem = valuePrintable !== null
-        ? `value ${pc.cyan(valuePrintable)}`
-        : `type ${pc.cyan(typeActual)}`;
-    const configDefinedAt = getConfigDefinedAtOptional('Config', configName, definedAtData);
-    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
-    assertUsage(false, errMsg);
-}

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

@@ -2,8 +2,7 @@ export { getConfigValueBuildTime };
 import { type ResolveTypeAsString } from '../utils.js';
 import type { PageConfigBuildTime, ConfigValue } from './PageConfig.js';
 import type { ConfigNameBuiltIn } from './Config.js';
-import { type TypeAsString } from './getConfigValue.js';
-type ConfigName = ConfigNameBuiltIn;
-declare function getConfigValueBuildTime<Type extends TypeAsString = undefined>(pageConfig: PageConfigBuildTime, configName: ConfigName, type?: Type): null | (ConfigValue & {
+import { type TypeAsString } from './getConfigValueTyped.js';
+declare function getConfigValueBuildTime<Type extends TypeAsString = undefined>(pageConfig: PageConfigBuildTime, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
     value: ResolveTypeAsString<Type>;
 });

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

@@ -1,7 +1,7 @@
 export { getConfigValueBuildTime };
 import { assert } from '../utils.js';
-import { getConfigValueTyped } from './getConfigValue.js';
 import { assertIsNotProductionRuntime } from '../../utils/assertIsNotProductionRuntime.js';
+import { getConfigValueTyped } from './getConfigValueTyped.js';
 assertIsNotProductionRuntime();
 function getConfigValueBuildTime(pageConfig, configName, type) {
     const configValue = getConfigValue(pageConfig, configName);

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

@@ -0,0 +1,9 @@
+export { getConfigValueTyped };
+export type { TypeAsString };
+import { type ResolveTypeAsString } from '../utils.js';
+import type { ConfigValue } from './PageConfig.js';
+import type { ConfigNameBuiltIn } from './Config.js';
+type TypeAsString = 'string' | 'boolean' | undefined;
+declare function getConfigValueTyped<Type extends TypeAsString = undefined>(configValue: ConfigValue, configName: ConfigNameBuiltIn, type?: Type): null | (ConfigValue & {
+    value: ResolveTypeAsString<Type>;
+});

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

@@ -0,0 +1,27 @@
+export { getConfigValueTyped };
+import { assert, assertUsage, getValuePrintable } from '../utils.js';
+import pc from '@brillout/picocolors';
+import { getConfigDefinedAtOptional } from './getConfigDefinedAt.js';
+function getConfigValueTyped(configValue, configName, type) {
+    /* [NULL_HANDLING] Do we really need this? This doesn't seem to make sense, let's eventually (re)move this.
+    // Enable users to suppress global config values by setting the local config value to null
+    if (configValue.value === null) return null
+    */
+    const { value, definedAtData } = configValue;
+    if (type)
+        assertConfigValueType(value, type, configName, definedAtData);
+    return configValue;
+}
+function assertConfigValueType(value, type, configName, definedAtData) {
+    assert(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = getValuePrintable(value);
+    const problem = valuePrintable !== null
+        ? `value ${pc.cyan(valuePrintable)}`
+        : `type ${pc.cyan(typeActual)}`;
+    const configDefinedAt = getConfigDefinedAtOptional('Config', configName, definedAtData);
+    const errMsg = `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`;
+    assertUsage(false, errMsg);
+}

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.213";
+export declare const PROJECT_VERSION: "0.4.215";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.213';
+export const PROJECT_VERSION = '0.4.215';

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.213";
+    projectVersion: "0.4.215";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.213",
+  "version": "0.4.215",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -139,7 +139,8 @@
     "fast-glob": "^3.0.0",
     "json5": "^2.0.0",
     "semver": "^7.0.0",
-    "source-map-support": "^0.5.0"
+    "source-map-support": "^0.5.0",
+    "vite": ">=5.1.0"
   },
   "peerDependencies": {
     "react-streaming": ">=0.3.42",
@@ -148,20 +149,26 @@
   "peerDependenciesMeta": {
     "react-streaming": {
       "optional": true
+    },
+    "vite": {
+      "optional": true
     }
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "license": "MIT",
-  "description": "Flexible, lean, community-driven, dependable, fast Vite-based frontend framework.",
+  "description": "The Framework *You* Control - Next.js & Nuxt alternative for unprecedented flexibility and dependability.",
   "keywords": [
+    "vite-plugin",
+    "ssr",
+    "vite",
     "react",
     "vue",
     "solid",
-    "vite",
-    "vite-plugin",
-    "ssr"
+    "next",
+    "remix",
+    "vike"
   ],
   "typesVersions": {
     "*": {

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

@@ -1,6 +0,0 @@
-export { enhanceViteConfig };
-import type { InlineConfig } from 'vite';
-declare function enhanceViteConfig(viteConfig: InlineConfig | undefined, command: 'build' | 'dev' | 'preview' | 'prerender'): Promise<{
-    viteConfigEnhanced: InlineConfig;
-    configVike: import("../../shared/ConfigVike.js").ConfigVikeResolved;
-}>;