vike 0.4.217 → 0.4.218-commit-01a099d

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

@@ -1,38 +1,93 @@
 export { prepareViteApiCall };
-import { resolveConfig } from 'vite';
-import { pluginName } from '../plugin/plugins/commonConfig/pluginName.js';
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+// TODO: enable Vike extensions to add Vite plugins
+import { loadConfigFromFile, resolveConfig } from 'vite';
 import { setOperation } from './context.js';
 import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-async function prepareViteApiCall(viteConfig = {}, operation) {
+import path from 'path';
+import { assert, assertUsage, getGlobalObject, toPosixPath } from './utils.js';
+import pc from '@brillout/picocolors';
+const globalObject = getGlobalObject('prepareViteApiCall.ts', {});
+async function prepareViteApiCall(viteConfig, operation) {
     setOperation(operation);
     return enhanceViteConfig(viteConfig, operation);
 }
-async function enhanceViteConfig(viteConfig = {}, operation) {
-    let viteConfigResolved = await resolveViteConfig(viteConfig, operation);
+async function enhanceViteConfig(viteConfig, operation) {
+    const { root, vikeVitePluginOptions, viteConfigEnhanced } = await getInfoFromVite(viteConfig, operation);
+    await assertViteRoot2(root, viteConfigEnhanced, operation);
+    const { vikeConfigGlobal } = await getVikeConfig2(root, operation === 'dev', vikeVitePluginOptions);
+    return {
+        viteConfigEnhanced,
+        vikeConfigGlobal
+    };
+}
+async function getViteRoot(operation) {
+    if (!globalObject.root)
+        await getInfoFromVite(undefined, operation);
+    assert(globalObject.root);
+    return globalObject.root;
+}
+async function getInfoFromVite(viteConfig, operation) {
+    const viteConfigFromFile = await loadViteConfigFile(viteConfig, operation);
+    const root = normalizeViteRoot(viteConfigFromFile?.root ?? viteConfig?.root ?? process.cwd());
+    globalObject.root = root;
+    let vikeVitePluginOptions;
     let viteConfigEnhanced = viteConfig;
-    // Add vike to plugins if not present
-    if (!viteConfigResolved.plugins.some((p) => p.name === pluginName)) {
-        // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus have vike/plugin may resolved to two different node_modules/vike directories
+    const found = findVikeVitePlugin([...(viteConfig?.plugins ?? []), ...(viteConfigFromFile?.plugins ?? [])]);
+    if (found) {
+        vikeVitePluginOptions = found.vikeVitePluginOptions;
+    }
+    else {
+        // Add Vike to plugins if not present.
+        // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await import('../plugin/index.js');
         viteConfigEnhanced = {
             ...viteConfig,
-            plugins: [...(viteConfig.plugins ?? []), vikePlugin()]
+            plugins: [...(viteConfig?.plugins ?? []), vikePlugin()]
         };
-        viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, operation);
+        const res = findVikeVitePlugin(viteConfigEnhanced.plugins);
+        assert(res);
+        vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
-    // TODO: use loadConfigFromFile() instead of viteConfigResolved
-    const { vikeConfigGlobal } = await getVikeConfig2(viteConfigResolved.root, operation === 'dev', viteConfigResolved._vikeVitePluginOptions);
-    // TODO: enable Vike extensions to add Vite plugins
-    return {
-        viteConfigEnhanced,
-        vikeConfigGlobal
-    };
+    assert(vikeVitePluginOptions);
+    return { root, vikeVitePluginOptions, viteConfigEnhanced };
 }
-async function resolveViteConfig(viteConfig, operation) {
-    const args = getResolveConfigArgs(viteConfig, operation);
-    return await resolveConfig(...args);
+function findVikeVitePlugin(plugins) {
+    let vikeVitePluginOptions;
+    let vikeVitePuginFound = false;
+    plugins.forEach((p) => {
+        if (p && '__vikeVitePluginOptions' in p) {
+            vikeVitePuginFound = true;
+            const options = p.__vikeVitePluginOptions;
+            vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
+            Object.assign(vikeVitePluginOptions, options);
+        }
+    });
+    if (!vikeVitePuginFound)
+        return null;
+    return { vikeVitePluginOptions };
+}
+// Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
+async function loadViteConfigFile(viteConfig, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfig, operation);
+    let config = inlineConfig;
+    let mode = inlineConfig.mode || defaultMode;
+    const configEnv = {
+        mode,
+        command,
+        isSsrBuild: command === 'build' && !!config.build?.ssr,
+        isPreview
+    };
+    let { configFile } = config;
+    if (configFile !== false) {
+        const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger);
+        return loadResult?.config;
+    }
+    return null;
 }
-function getResolveConfigArgs(viteConfig, operation) {
+function getResolveConfigArgs(viteConfig = {}, operation) {
     const inlineConfig = viteConfig;
     const command = operation === 'build' || operation === 'prerender' ? 'build' : 'serve';
     const defaultMode = operation === 'dev' ? 'development' : 'production';
@@ -40,3 +95,18 @@ function getResolveConfigArgs(viteConfig, operation) {
     const isPreview = operation === 'preview';
     return [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
 }
+function normalizeViteRoot(root) {
+    return toPosixPath(path.resolve(root));
+}
+const errMsg = `A Vite plugin is modifying Vite's setting ${pc.cyan('root')} which is forbidden`;
+async function assertViteRoot2(root, viteConfigEnhanced, operation) {
+    const args = getResolveConfigArgs(viteConfigEnhanced, operation);
+    // We can eventually this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
+    const viteConfigResolved = await resolveConfig(...args);
+    assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
+}
+function assertViteRoot(root, config) {
+    if (globalObject.root)
+        assert(normalizeViteRoot(globalObject.root) === normalizeViteRoot(root));
+    assertUsage(normalizeViteRoot(root) === normalizeViteRoot(config.root), errMsg);
+}

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

@@ -1,2 +1,4 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/isObject.js';

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

@@ -4,3 +4,5 @@ import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/isObject.js';

package/dist/esm/node/cli/parseCli.d.ts

@@ -1,4 +1,4 @@
 export { parseCli };
 declare function parseCli(): {
-    command: "dev" | "build" | "preview" | "prerender";
+    command: "build" | "dev" | "preview" | "prerender";
 };

package/dist/esm/node/plugin/index.d.ts

@@ -3,5 +3,5 @@ export { plugin };
 export { plugin as ssr };
 export type { VikeVitePluginOptions as UserConfig };
 export { PROJECT_VERSION as version } from './utils.js';
-import type { VikeVitePluginOptions } from './plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeVitePluginOptions } from './plugins/importUserCode/v1-design/getVikeConfig.js';
 declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): any;

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

@@ -17,7 +17,7 @@ import { extractAssetsPlugin } from './plugins/extractAssetsPlugin.js';
 import { extractExportNamesPlugin } from './plugins/extractExportNamesPlugin.js';
 import { suppressRollupWarning } from './plugins/suppressRollupWarning.js';
 import { setGlobalContext } from './plugins/setGlobalContext.js';
-import { importBuild } from './plugins/importBuild/index.js';
+import { buildEntry } from './plugins/buildEntry/index.js';
 import { commonConfig } from './plugins/commonConfig.js';
 import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
@@ -26,12 +26,12 @@ 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';
+import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegression.js';
 markSetup_vikeVitePlugin();
 assertViteVersion();
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
-function plugin(vikeVitePluginOptions) {
+function plugin(vikeVitePluginOptions = {}) {
     const plugins = [
         ...commonConfig(vikeVitePluginOptions),
         importUserCode(),
@@ -46,13 +46,14 @@ function plugin(vikeVitePluginOptions) {
         extractExportNamesPlugin(),
         suppressRollupWarning(),
         ...setGlobalContext(),
-        ...importBuild(),
+        ...buildEntry(),
         baseUrls(vikeVitePluginOptions),
         envVarsPlugin(),
         fileEnv(),
         workaroundCssModuleHmr(),
-        vite6HmrRegressionWorkaround()
+        workaroundVite6HmrRegression()
     ];
+    Object.assign(plugins, { __vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;
 }
 // Error upon wrong usage

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

@@ -3,6 +3,7 @@ export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../prerender/runPrerender.js';
+import { isPrerenderEnabled } from '../../prerender/isPrerenderEnabled.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
@@ -90,9 +91,7 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
         logErrorHint(err);
         process.exit(1);
     }
-    if (vikeConfigGlobal.prerender &&
-        !vikeConfigGlobal.prerender.disableAutoRun &&
-        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
+    if (isPrerenderEnabled(vikeConfigGlobal)) {
         await runPrerenderFromAutoRun(configInline, false);
         forceExit = true;
     }

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

@@ -1,4 +1,3 @@
 export { baseUrls };
 import type { Plugin } from 'vite';
-import type { VikeVitePluginOptions } from './importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
-declare function baseUrls(vikeVitePluginOptions?: VikeVitePluginOptions): Plugin;
+declare function baseUrls(vikeVitePluginOptions: unknown): Plugin;

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

@@ -1,36 +1,42 @@
 export { baseUrls };
 import { resolveBase, resolveBaseFromResolvedConfig } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfig, getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
 function baseUrls(vikeVitePluginOptions) {
-    let bases;
+    let basesResolved;
+    let root;
     return {
         name: 'vike:baseUrls',
         enforce: 'post',
-        async config(config) {
-            // TODO: fix bug: use getVikeConfig2() and udpate check below
-            bases = resolveBaseFromUserConfig(config, vikeVitePluginOptions);
-            const { baseServer, baseAssets } = bases;
+        async config(config, env) {
+            const isDev = config._isDev;
+            assert(typeof isDev === 'boolean');
+            const operation = env.command === 'build' ? 'build' : env.isPreview ? 'preview' : 'dev';
+            root = config.root ? normalizeViteRoot(config.root) : await getViteRoot(operation);
+            assert(root);
+            const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
+            const vikeConfig = await getVikeConfig2(root, isDev, vikeVitePluginOptions);
+            basesResolved = resolveBase(baseViteOriginal, vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
-            process.env.BASE_SERVER = baseServer;
-            process.env.BASE_ASSETS = baseAssets;
+            process.env.BASE_SERVER = basesResolved.baseServer;
+            process.env.BASE_ASSETS = basesResolved.baseAssets;
             return {
                 envPrefix: [
                     'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
                     'BASE_SERVER',
                     'BASE_ASSETS'
                 ],
-                base: baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
-                _baseViteOriginal: config.base ?? '/__UNSET__' // Vite resolves `_baseViteOriginal: null` to `undefined`
+                base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
+                _baseViteOriginal: baseViteOriginal
             };
         },
         async configResolved(config) {
+            assertViteRoot(root, config);
             const vikeConfig = await getVikeConfig(config);
-            const { baseServer, baseAssets } = vikeConfig.vikeConfigGlobal;
-            const basesResolved = resolveBaseFromResolvedConfig(baseServer, baseAssets, config);
-            // Ensure that the premature base URL resolving we did in config() isn't erroneous
-            assert(basesResolved.baseServer === bases.baseServer);
-            assert(basesResolved.baseAssets === bases.baseAssets);
+            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets, config);
+            assert(basesResolved2.baseServer === basesResolved.baseServer);
+            assert(basesResolved2.baseAssets === basesResolved.baseAssets);
             /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
              *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
              *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
@@ -39,7 +45,3 @@ function baseUrls(vikeVitePluginOptions) {
         }
     };
 }
-function resolveBaseFromUserConfig(config, vikeVitePluginOptions) {
-    const baseViteOriginal = config.base ?? null;
-    return resolveBase(baseViteOriginal, vikeVitePluginOptions?.baseServer ?? null, vikeVitePluginOptions?.baseAssets ?? null);
-}

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

@@ -11,7 +11,7 @@ import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
 import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_assertCssTarget_populate, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
-import { set_ASSETS_MAP } from './importBuild/index.js';
+import { set_ASSETS_MAP } from './buildEntry/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
@@ -117,7 +117,7 @@ async function getEntries(config) {
     if (viteIsSSR(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
-            // importBuild: resolve('dist/esm/node/importBuild.js'), // TODO/next-major-release: remove
+            // buildEntry: resolve('dist/esm/node/buildEntry.js'), // TODO/next-major-release: remove
             ...pageFileEntries,
             // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
             ...pageEntries

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/getVikeManifest.d.ts

@@ -1,5 +1,5 @@
 export { getVikeManifest };
 import { type PluginManifest } from '../../../shared/assertPluginManifest.js';
-import type { VikeConfigGlobal } from '../importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeConfigGlobal } from '../importUserCode/v1-design/getVikeConfig.js';
 import type { ResolvedConfig } from 'vite';
 declare function getVikeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): PluginManifest;

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/index.d.ts

@@ -1,8 +1,8 @@
-export { importBuild };
+export { buildEntry };
 export { set_ASSETS_MAP };
 import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 type Options = Rollup.NormalizedOutputOptions;
-declare function importBuild(): Plugin[];
+declare function buildEntry(): Plugin[];
 /** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
 declare function set_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/index.js

@@ -1,23 +1,23 @@
-export { importBuild };
+export { buildEntry };
 export { set_ASSETS_MAP };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
+import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { getVikeManifest } from './getVikeManifest.js';
+import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
+import fs from 'fs/promises';
 import path from 'path';
 import { createRequire } from 'module';
-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() {
+function buildEntry() {
     let config;
     let vikeConfigGlobal;
     return [
         {
-            name: 'vike:importBuild:config',
+            name: 'vike:buildEntry',
             enforce: 'post',
             async configResolved(config_) {
                 config = config_;
@@ -38,17 +38,16 @@ function getServerProductionEntryCode(config, vikeConfigGlobal) {
     const vikeManifest = getVikeManifest(vikeConfigGlobal, config);
     // Let's eventually simplify and move everything to a single virtual module
     const importerCode = [
-        `  import { setImportBuildGetters } from '${importPath}';`,
+        `  import { setBuildEntry } from '${importPath}';`,
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
         `  {`,
         // We first set the values to a variable because of a Rollup bug, and this workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
         `    const assetsManifest = ${ASSETS_MAP};`,
         `    const pluginManifest = ${JSON.stringify(vikeManifest, null, 2)};`,
-        '    setImportBuildGetters({',
-        `      pageFiles: () => pageFiles,`,
-        `      getAssetsManifest: () => assetsManifest,`,
-        // TODO: rename pluginManifest -> vikeManifest
-        `      pluginManifest: () => pluginManifest,`,
+        '    setBuildEntry({',
+        `      pageFiles,`,
+        `      assetsManifest,`,
+        `      pluginManifest,`,
         '    });',
         `  }`,
         ''
@@ -85,12 +84,12 @@ function find_ASSETS_MAP(bundle) {
 function getImportPath(config) {
     // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
     const filePathAbsolute = toPosixPath(
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
-    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/buildEntry/index.js
+    require_.resolve(`../../../../../../dist/esm/__internal/index.js`));
     if (
-    // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal/loadImportBuild' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
+    // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
     true) {
-        return 'vike/__internal/loadImportBuild';
+        return 'vike/__internal';
     }
     else {
         const { outDirServer } = getOutDirs(config);

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

@@ -1,3 +1,9 @@
 export { commonConfig };
 import { type Plugin } from 'vite';
-declare function commonConfig(vikeVitePluginOptions?: unknown): Plugin[];
+declare module 'vite' {
+    interface UserConfig {
+        _isDev?: boolean;
+        _vikeVitePluginOptions?: unknown;
+    }
+}
+declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];

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

@@ -6,11 +6,11 @@ import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
 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';
 import { isVikeCliOrApi } from '../../api/context.js';
-function commonConfig(vikeVitePluginOptions = {}) {
+const pluginName = 'vike:commonConfig';
+function commonConfig(vikeVitePluginOptions) {
     return [
         {
             name: `${pluginName}:pre`,

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

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

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

@@ -143,9 +143,7 @@ const configDefinitionsBuiltInGlobal = {
         env: { server: true, client: 'if-client-routing' },
         eager: true
     },
-    prerender: {
-        env: { config: true }
-    },
+    prerender: { env: { config: true } },
     disableAutoFullBuild: { env: { config: true } },
     includeAssetsImportedByServer: { env: { config: true } },
     baseAssets: { env: { config: true } },

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