vike 0.4.215 → 0.4.217

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.js

@@ -3,8 +3,8 @@ import { projectInfo } from '../../utils.js';
 import { assertPluginManifest } from '../../../shared/assertPluginManifest.js';
 import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
 import { getRuntimeManifest } from '../../../runtime/globalContext.js';
-function getVikeManifest(configVike) {
-    const runtimeManifest = getRuntimeManifest(configVike);
+function getVikeManifest(vikeConfigGlobal, viteConfig) {
+    const runtimeManifest = getRuntimeManifest(vikeConfigGlobal, viteConfig);
     const manifest = {
         version: projectInfo.projectVersion,
         usesClientRouter: isUsingClientRouter(), // TODO/v1-release: remove

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

@@ -4,37 +4,39 @@ import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
-import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { getVikeManifest } from './getVikeManifest.js';
 import fs from 'fs/promises';
 import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const ASSETS_MAP = '__VITE_ASSETS_MAP__';
 function importBuild() {
     let config;
-    let configVike;
+    let vikeConfigGlobal;
     return [
         {
             name: 'vike:importBuild:config',
             enforce: 'post',
             async configResolved(config_) {
                 config = config_;
-                configVike = await getConfigVike(config);
+                const vikeConfig = await getVikeConfig(config);
+                vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
             }
         },
         ...serverProductionEntryPlugin({
             getServerProductionEntry: () => {
-                return getServerProductionEntryCode(config, configVike);
+                return getServerProductionEntryCode(config, vikeConfigGlobal);
             },
             libraryName: 'Vike'
         })
     ];
 }
-function getServerProductionEntryCode(config, configVike) {
+function getServerProductionEntryCode(config, vikeConfigGlobal) {
     const importPath = getImportPath(config);
-    const vikeManifest = getVikeManifest(configVike);
+    const vikeManifest = getVikeManifest(vikeConfigGlobal, config);
+    // Let's eventually simplify and move everything to a single virtual module
     const importerCode = [
         `  import { setImportBuildGetters } from '${importPath}';`,
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.d.ts

@@ -1,6 +1,6 @@
 export { getVirtualFileImportUserCode };
 import type { ResolvedConfig } from 'vite';
-import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
+import type { VikeConfigGlobal } from './v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
 declare function getVirtualFileImportUserCode(id: string, options: {
     ssr?: boolean;
-} | undefined, configVike: ConfigVikeResolved, config: ResolvedConfig, isDev: boolean): Promise<string>;
+} | undefined, vikeConfigGlobal: VikeConfigGlobal, config: ResolvedConfig, isDev: boolean): Promise<string>;

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -6,16 +6,16 @@ import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'path';
 import { getVirtualFilePageConfigs } from './v1-design/getVirtualFilePageConfigs.js';
 import { isV1Design as isV1Design_ } from './v1-design/getVikeConfig.js';
-async function getVirtualFileImportUserCode(id, options, configVike, config, isDev) {
+async function getVirtualFileImportUserCode(id, options, vikeConfigGlobal, config, isDev) {
     const idParsed = isVirtualFileIdImportUserCode(id);
     assert(idParsed);
     const { isForClientSide, isClientRouting } = idParsed;
     assert(isForClientSide === !viteIsSSR_options(options));
-    const isPrerendering = !!configVike.prerender;
-    const code = await getCode(config, configVike, isForClientSide, isClientRouting, isPrerendering, isDev, id);
+    const isPrerendering = !!vikeConfigGlobal.prerender;
+    const code = await getCode(config, vikeConfigGlobal, isForClientSide, isClientRouting, isPrerendering, isDev, id);
     return code;
 }
-async function getCode(config, configVike, isForClientSide, isClientRouting, isPrerendering, isDev, id) {
+async function getCode(config, vikeConfigGlobal, isForClientSide, isClientRouting, isPrerendering, isDev, id) {
     const { command } = config;
     assert(command === 'serve' || command === 'build');
     const isBuild = command === 'build';
@@ -24,7 +24,7 @@ async function getCode(config, configVike, isForClientSide, isClientRouting, isP
     {
         const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);
-        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id);
+        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfigGlobal, isPrerendering, config, isDev, id);
     }
     debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
     return content;
@@ -54,7 +54,7 @@ function determineInjection({ fileType, isForClientSide, isClientRouting, isPrer
         }
     }
 }
-async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id) {
+async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfigGlobal, isPrerendering, config, isDev, id) {
     let fileContent = `// Generated by https://github.com/vikejs/vike/blob/main/vike/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.ts
 
 export const pageFilesLazy = {};
@@ -68,7 +68,7 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
 
 `;
     // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
-    const isV1Design = await isV1Design_(config, isDev);
+    const isV1Design = await isV1Design_(config);
     fileTypes
         .filter((fileType) => fileType !== '.css')
         .forEach((fileType) => {
@@ -86,7 +86,7 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
             fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames', isV1Design);
         }
     });
-    if (configVike.includeAssetsImportedByServer && isForClientSide) {
+    if (vikeConfigGlobal.includeAssetsImportedByServer && isForClientSide) {
         fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets', isV1Design);
     }
     return fileContent;

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

@@ -1,32 +1,27 @@
 export { importUserCode };
 import { normalizePath } from 'vite';
-import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { getVirtualFilePageConfigValuesAll } from './v1-design/getVirtualFilePageConfigValuesAll.js';
 import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
-import { assert, assertPosixPath, getOutDirs, isDevCheck } from '../../utils.js';
+import { assert, assertPosixPath } from '../../utils.js';
 import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../../shared/virtual-files.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile, isV1Design } from './v1-design/getVikeConfig.js';
+import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile, isV1Design, getVikeConfig } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
 function importUserCode() {
     let config;
-    let configVike;
-    let isDev;
+    let vikeConfigGlobal;
     return {
         name: 'vike:importUserCode',
-        config(_, env) {
-            isDev = isDevCheck(env);
-        },
         async configResolved(config_) {
-            configVike = await getConfigVike(config_);
+            const vikeConfig = await getVikeConfig(config_);
+            vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
             config = config_;
             // TODO/v1-release: remove
             {
-                assert(isDev !== undefined);
-                const isV1 = await isV1Design(config, isDev);
+                const isV1 = await isV1Design(config);
                 if (!isV1)
                     config.experimental.importGlobRestoreExtension = true;
             }
@@ -50,13 +45,14 @@ function importUserCode() {
             if (!isVirtualFileId(id))
                 return undefined;
             id = getVirtualFileId(id);
+            const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             if (isVirtualFileIdPageConfigValuesAll(id)) {
                 const code = await getVirtualFilePageConfigValuesAll(id, isDev, config);
                 return code;
             }
             if (isVirtualFileIdImportUserCode(id)) {
-                const code = await getVirtualFileImportUserCode(id, options, configVike, config, isDev);
+                const code = await getVirtualFileImportUserCode(id, options, vikeConfigGlobal, config, isDev);
                 return code;
             }
         },
@@ -83,8 +79,6 @@ function handleFileAddRemove(server, config) {
 }
 function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
-    assertPosixPath(file);
-    vikeConfigDependencies.forEach((f) => assertPosixPath(f));
     const isVikeConfig = isVikeConfigModule(file);
     const isViteModule = ctx.modules.length > 0;
     /* Should we show this?
@@ -114,6 +108,8 @@ function handleHotUpdate(ctx, config) {
     }
 }
 function isVikeConfigModule(filePathAbsoluteFilesystem) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    vikeConfigDependencies.forEach((f) => assertPosixPath(f));
     return vikeConfigDependencies.has(filePathAbsoluteFilesystem);
 }
 function reloadConfig(filePath, config, op) {
@@ -122,7 +118,7 @@ function reloadConfig(filePath, config, op) {
         const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }
-    reloadVikeConfig(config.root, getOutDirs(config).outDirRoot);
+    reloadVikeConfig(config);
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())

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, crawlWithGit: null | boolean): Promise<{
+declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: null | string, crawlWithGit: null | boolean): Promise<{
     filePathAbsoluteUserRootDir: string;
 }[]>;

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

@@ -13,12 +13,16 @@ assertIsSingleModuleInstance('crawlPlusFiles.ts');
 let gitIsNotUsable = false;
 async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, crawlWithGit) {
     assertPosixPath(userRootDir);
-    assertPosixPath(outDirAbsoluteFilesystem);
-    let outDirRelativeFromUserRootDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
+    //*/
+    const outDirRelativeFromUserRootDir = null;
+    /*/
+    assertPosixPath(outDirAbsoluteFilesystem)
+    let outDirRelativeFromUserRootDir: string | null = path.posix.relative(userRootDir, outDirAbsoluteFilesystem)
     if (outDirRelativeFromUserRootDir.startsWith('../')) {
-        // config.outDir is outside of config.root => it's going to be ignored anyways
-        outDirRelativeFromUserRootDir = null;
+      // config.outDir is outside of config.root => it's going to be ignored anyways
+      outDirRelativeFromUserRootDir = null
     }
+    //*/
     assert(outDirRelativeFromUserRootDir === null ||
         /* Not true if outDirRelativeFromUserRootDir starts with a hidden directory (i.e. a directory with a name that starts with `.`)
         !outDirRelativeFromUserRootDir.startsWith('.') &&

package/dist/esm/{shared/ConfigVike.d.ts → node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.d.ts}

@@ -1,6 +1,8 @@
-export type { ConfigVikeUserProvided };
-export type { ConfigVikeResolved };
-type ConfigVikeResolved = {
+export { resolveVikeConfigGlobal };
+export type { VikeConfigGlobal };
+export type { VikeVitePluginOptions };
+declare function resolveVikeConfigGlobal(vikeVitePluginOptions: unknown, pageConfigGlobalValues: Record<string, unknown>): VikeConfigGlobal;
+type VikeConfigGlobal = {
     prerender: false | {
         noExtraDir: boolean;
         parallel: boolean | number;
@@ -9,8 +11,8 @@ type ConfigVikeResolved = {
     };
     disableAutoFullBuild: boolean | 'prerender' | null;
     includeAssetsImportedByServer: boolean;
-    baseAssets: string;
-    baseServer: string;
+    baseAssets: string | null;
+    baseServer: string | null;
     redirects: Record<string, string>;
     trailingSlash: boolean;
     disableUrlNormalization: boolean;
@@ -18,7 +20,7 @@ type ConfigVikeResolved = {
         git: null | boolean;
     };
 };
-type ConfigVikeUserProvided = {
+type VikeVitePluginOptions = {
     /**
      * Enable pre-rendering.
      *
@@ -44,12 +46,12 @@ type ConfigVikeUserProvided = {
          */
         parallel?: boolean | number;
         /**
-         * Allow only some of your pages to be pre-rendered.
-         *
-         * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
-
-         * @default false
-         */
+     * Allow only some of your pages to be pre-rendered.
+     *
+     * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
+ 
+     * @default false
+     */
         partial?: boolean;
         /**
          * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.

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

@@ -0,0 +1,123 @@
+export { resolveVikeConfigGlobal };
+import pc from '@brillout/picocolors';
+import { assert, assertUsage, hasProp, isObject } from '../../../../utils.js';
+function resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues) {
+    // TODO/v1-release: remove
+    assertVikeConfigGlobal(vikeVitePluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
+    const configs = [vikeVitePluginOptions];
+    assertVikeConfigGlobal(pageConfigGlobalValues, ({ prop, errMsg }) => {
+        // Can we add the config file path ?
+        return `config ${pc.cyan(prop)} ${errMsg}`;
+    });
+    configs.push(pageConfigGlobalValues);
+    const vikeConfigGlobal = {
+        disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
+        prerender: resolvePrerenderOptions(configs),
+        includeAssetsImportedByServer: pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
+        baseServer: pickFirst(configs.map((c) => c.baseServer)) ?? null,
+        baseAssets: pickFirst(configs.map((c) => c.baseAssets)) ?? null,
+        redirects: merge(configs.map((c) => c.redirects)) ?? {},
+        disableUrlNormalization: pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
+        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false,
+        crawl: {
+            git: vikeVitePluginOptions.crawl?.git ?? null
+        }
+    };
+    return vikeConfigGlobal;
+}
+function resolvePrerenderOptions(configs) {
+    if (!configs.some((c) => c.prerender)) {
+        return false;
+    }
+    const configsPrerender = configs.map((c) => c.prerender).filter(isObject2);
+    return {
+        partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false
+    };
+}
+function isObject2(p) {
+    return typeof p === 'object';
+}
+function merge(objs) {
+    const obj = {};
+    objs.forEach((e) => {
+        Object.assign(obj, e);
+    });
+    return obj;
+}
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}
+function assertVikeConfigGlobal(vikeConfigGlobal, wrongUsageMsg) {
+    const wrongUsageError = check(vikeConfigGlobal);
+    if (wrongUsageError) {
+        assertUsage(false, wrongUsageMsg(wrongUsageError));
+    }
+}
+function check(vikeConfigGlobal) {
+    assert(isObject(vikeConfigGlobal));
+    {
+        const prop = 'disableUrlNormalization';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'trailingSlash';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'redirects';
+        const { redirects } = vikeConfigGlobal;
+        if (!(redirects === undefined ||
+            (isObject(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
+            return { prop, errMsg: 'should be an object of strings' };
+    }
+    {
+        const prop = 'disableAutoFullBuild';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') &&
+            !hasProp(vikeConfigGlobal, prop, 'undefined') &&
+            !(vikeConfigGlobal[prop] === 'prerender'))
+            return { prop, errMsg: "should be a boolean or 'prerender'" };
+    }
+    {
+        const prop = 'includeAssetsImportedByServer';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'prerender';
+        if (!hasProp(vikeConfigGlobal, prop, 'object') &&
+            !hasProp(vikeConfigGlobal, prop, 'boolean') &&
+            !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be an object or a boolean' };
+    }
+    const configVikePrerender = vikeConfigGlobal.prerender;
+    if (typeof configVikePrerender === 'object') {
+        {
+            const p = 'partial';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!hasProp(configVikePrerender, p, 'boolean') &&
+                !hasProp(configVikePrerender, p, 'number') &&
+                !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
+        }
+    }
+    return null;
+}

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

@@ -1,4 +1,5 @@
 export { getVikeConfig };
+export { getVikeConfig2 };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
@@ -11,6 +12,7 @@ import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../..
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
 import type { FilePathResolved } from '../../../../../shared/page-configs/FilePath.js';
+import type { VikeConfigGlobal } from './getVikeConfig/resolveVikeConfigGlobal.js';
 type InterfaceFile = InterfaceConfigFile | InterfaceValueFile;
 type InterfaceFileCommons = {
     locationId: LocationId;
@@ -34,14 +36,14 @@ type ConfigName = string;
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
-    globalVikeConfig: Record<string, unknown>;
+    vikeConfigGlobal: VikeConfigGlobal;
 };
 declare const vikeConfigDependencies: Set<string>;
-declare function reloadVikeConfig(userRootDir: string, outDirRoot: string): void;
-declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, { crawlWithGit, tolerateInvalidConfig }?: {
-    crawlWithGit?: null | boolean;
-    tolerateInvalidConfig?: true;
+declare function reloadVikeConfig(config: ResolvedConfig): void;
+declare function getVikeConfig(config: ResolvedConfig, { doNotRestartViteOnError }?: {
+    doNotRestartViteOnError?: true;
 }): Promise<VikeConfigObject>;
-declare function isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
+declare function getVikeConfig2(userRootDir: string, isDev: boolean, vikeVitePluginOptions: unknown): Promise<VikeConfigObject>;
+declare function isV1Design(config: ResolvedConfig): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;
 declare function getConfigValueInterfaceFile(interfaceFile: InterfaceFile, configName: string): unknown;

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

@@ -1,10 +1,11 @@
 export { getVikeConfig };
+export { getVikeConfig2 };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
 export { getConfigValueInterfaceFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, getOutDirs, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
@@ -21,17 +22,20 @@ import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig
 import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
+import { resolveVikeConfigGlobal } from './getVikeConfig/resolveVikeConfigGlobal.js';
 assertIsNotProductionRuntime();
-let devServerIsCorrupt = false;
+let restartVite = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
-function reloadVikeConfig(userRootDir, outDirRoot) {
+function reloadVikeConfig(config) {
+    const userRootDir = config.root;
+    const vikeVitePluginOptions = config._vikeVitePluginOptions;
+    assert(vikeVitePluginOptions);
     vikeConfigDependencies.clear();
     clearFilesEnvMap();
-    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, true);
+    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
     handleReloadSideEffects();
 }
 async function handleReloadSideEffects() {
@@ -55,8 +59,8 @@ async function handleReloadSideEffects() {
             wasConfigInvalid = false;
             logConfigErrorRecover();
         }
-        if (devServerIsCorrupt) {
-            devServerIsCorrupt = false;
+        if (restartVite) {
+            restartVite = false;
             const viteDevServer = getViteDevServer();
             assert(viteDevServer);
             removeSuperfluousViteLog_enable();
@@ -65,23 +69,31 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(config, isDev, { crawlWithGit, tolerateInvalidConfig } = {}) {
-    const { outDirRoot } = getOutDirs(config);
+async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
     const userRootDir = config.root;
+    const vikeVitePluginOptions = config._vikeVitePluginOptions;
+    assert(vikeVitePluginOptions);
+    const isDev = config._isDev;
+    assert(typeof isDev === 'boolean');
+    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError ?? false);
+}
+async function getVikeConfig2(userRootDir, isDev, vikeVitePluginOptions) {
+    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, false);
+}
+async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     if (!vikeConfigPromise) {
-        const crawlWithGit_ = crawlWithGit !== undefined ? crawlWithGit : (await getConfigVike(config)).crawl.git;
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, crawlWithGit_, tolerateInvalidConfig);
+        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     }
     return await vikeConfigPromise;
 }
-async function isV1Design(config, isDev) {
-    const vikeConfig = await getVikeConfig(config, isDev);
+async function isV1Design(config) {
+    const vikeConfig = await getVikeConfig(config);
     const { pageConfigs } = vikeConfig;
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, outDirRoot, crawlWithGit) {
-    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, crawlWithGit);
+async function loadInterfaceFiles(userRootDir, crawlWithGit) {
+    const plusFiles = await findPlusFiles(userRootDir, null, crawlWithGit);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -190,12 +202,12 @@ function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
         });
     });
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, crawlWithGit, tolerateInvalidConfig) {
+async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, outDirRoot, crawlWithGit);
+        ret = await loadVikeConfig(userRootDir, vikeVitePluginOptions);
     }
     catch (err_) {
         hasError = true;
@@ -217,8 +229,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
         }
         else {
             logConfigError(err);
-            if (!tolerateInvalidConfig) {
-                devServerIsCorrupt = true;
+            if (!doNotRestartViteOnError) {
+                restartVite = true;
             }
             const dummyData = {
                 pageConfigs: [],
@@ -226,16 +238,18 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                globalVikeConfig: {}
+                vikeConfigGlobal: resolveVikeConfigGlobal({}, {})
             };
             return dummyData;
         }
     }
 }
-async function loadVikeConfig(userRootDir, outDirRoot, crawlWithGit) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, crawlWithGit);
+async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
+    const crawlWithGit = resolveVikeConfigGlobal(vikeVitePluginOptions, {}).crawl.git ?? null;
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, crawlWithGit);
     const importedFilesLoaded = {};
-    const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
+    const { pageConfigGlobal, pageConfigGlobalValues } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
+    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -285,7 +299,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, crawlWithGit) {
         return pageConfig;
     }));
     assertPageConfigs(pageConfigs);
-    return { pageConfigs, pageConfigGlobal, globalVikeConfig };
+    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal };
 }
 // TODO/soon: refactor
 //  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
@@ -395,7 +409,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             });
         });
     }
-    const globalVikeConfig = {};
+    const pageConfigGlobalValues = {};
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsBuiltInGlobal,
         configValueSources: {}
@@ -415,10 +429,10 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
                 return;
             const { filePathToShowToUser } = configValueSource.definedAtFilePath;
             assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
-            globalVikeConfig[configName] = configValueSource.value;
+            pageConfigGlobalValues[configName] = configValueSource.value;
         }
     }));
-    return { pageConfigGlobal, globalVikeConfig };
+    return { pageConfigGlobal, pageConfigGlobalValues };
 }
 async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
     const sourcesInfo = [];

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

@@ -6,7 +6,6 @@ import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js'
 import { debug } from './debug.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { fixServerAssets_isEnabled } from '../../buildConfig/fixServerAssets.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
@@ -19,11 +18,11 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await getVikeConfig(config, isDev, { tolerateInvalidConfig: true });
+    const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const { pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig, { id, pageId });
-    const configVike = await getConfigVike(config);
-    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
+    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }

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

@@ -5,7 +5,7 @@ import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, isDev, { tolerateInvalidConfig: true });
+    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, { doNotRestartViteOnError: true });
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {