vike 0.4.231 → 0.4.232-commit-134207d

package/dist/esm/node/{plugin/plugins/importUserCode/v1-design/getVikeConfig.js → vite/shared/resolveVikeConfigInternal.js}

@@ -1,175 +1,202 @@
-export { getVikeConfig };
-export { getVikeConfigOptional };
-export { getVikeConfig2 };
+// Internal usage
+export { getVikeConfigInternal };
+export { getVikeConfigInternalOptional };
+export { getVikeConfigInternalSync };
+export { setVikeConfigContext };
 export { reloadVikeConfig };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
-export { isOverriden };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance } from '../../../utils.js';
-import { configDefinitionsBuiltIn } from './getVikeConfig/configDefinitionsBuiltIn.js';
-import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isVikeConfigInvalid, isVikeConfigInvalid_set } from '../../../../runtime/renderPage/isVikeConfigInvalid.js';
-import { getViteDevServer } from '../../../../runtime/globalContext.js';
-import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
-import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
+export { isOverridden };
+// Public usage
+export { getVikeConfig };
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance, genPromise, } from '../utils.js';
+import { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
+import { getViteDevServer } from '../../runtime/globalContext.js';
+import { logConfigError, logConfigErrorRecover } from './loggerNotProd.js';
+import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable, } from './loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
-import { getConfigDefinedAt, getDefinedByString } from '../../../../../shared/page-configs/getConfigDefinedAt.js';
-import { loadPointerImport, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
-import { resolvePointerImport } from './getVikeConfig/resolvePointerImport.js';
-import { getFilePathResolved } from '../../../shared/getFilePath.js';
-import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from '../../../../../shared/page-configs/getUserFriendlyConfigs.js';
-import { getConfigValuesBase, isJsonValue } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { getPlusFilesAll } from './getVikeConfig/getPlusFilesAll.js';
-import { getEnvVarObject } from '../../../shared/getEnvVarObject.js';
-import { getApiOperation } from '../../../../api/context.js';
-import { getCliOptions } from '../../../../cli/context.js';
+import { getConfigDefinedAt, getDefinedByString } from '../../../shared/page-configs/getConfigDefinedAt.js';
+import { loadPointerImport, loadValueFile } from './resolveVikeConfigInternal/loadFileAtConfigTime.js';
+import { resolvePointerImport } from './resolveVikeConfigInternal/resolvePointerImport.js';
+import { getFilePathResolved } from './getFilePath.js';
+import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
+import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEager, } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { getConfigValuesBase, isJsonValue } from '../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { getPlusFilesAll, } from './resolveVikeConfigInternal/getPlusFilesAll.js';
+import { getEnvVarObject } from './getEnvVarObject.js';
+import { getApiOperation } from '../../api/context.js';
+import { getCliOptions } from '../../cli/context.js';
+import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
+import { getProxyForPublicUsage } from '../../../shared/getProxyForPublicUsage.js';
+import { setVikeConfigError } from '../../shared/getVikeConfigError.js';
 assertIsNotProductionRuntime();
+// We can simply use global variables since Vike's config is:
+//  - global
+//  - independent of Vite (therefore we don't need to tie Vike's config with Vite's `config` object)
 assertIsSingleModuleInstance('v1-design/getVikeConfig.ts');
 let restartVite = false;
-let wasConfigInvalid = null;
+let vikeConfigHasBuildError = null;
+let isV1Design_ = null;
 let vikeConfigPromise = null;
-function reloadVikeConfig(config) {
-    const userRootDir = config.root;
-    const vikeVitePluginOptions = config._vikeVitePluginOptions;
+// TODO/v1-release: remove
+let vikeConfigSync = null;
+let vikeConfigCtx = null; // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
+let prerenderContext;
+function reloadVikeConfig() {
+    assert(vikeConfigCtx);
+    const { userRootDir, vikeVitePluginOptions } = vikeConfigCtx;
     assert(vikeVitePluginOptions);
-    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
-    handleReloadSideEffects();
+    resolveVikeConfigInternal_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
 }
-async function handleReloadSideEffects() {
-    wasConfigInvalid = !!isVikeConfigInvalid;
-    const vikeConfigPromisePrevious = vikeConfigPromise;
-    try {
-        await vikeConfigPromise;
-    }
-    catch (err) {
-        // handleReloadSideEffects() is only called in dev.
-        // In dev, if loadVikeConfig_withErrorHandling() throws an error, then it's a vike bug.
-        console.error(err);
-        assert(false);
-    }
-    if (vikeConfigPromise !== vikeConfigPromisePrevious) {
-        // Let the next handleReloadSideEffects() call handle side effects
-        return;
-    }
-    if (!isVikeConfigInvalid) {
-        if (wasConfigInvalid) {
-            wasConfigInvalid = false;
-            logConfigErrorRecover();
-        }
-        if (restartVite) {
-            restartVite = false;
-            const viteDevServer = getViteDevServer();
-            assert(viteDevServer);
-            removeSuperfluousViteLog_enable();
-            await viteDevServer.restart(true);
-            removeSuperfluousViteLog_disable();
-        }
-    }
+async function getVikeConfigInternal(
+// I don't remember the logic behind it — neither why we restart Vite's dev server, nor why we sometimes don't.
+// TO-DO: eventually rethink all that. Some + settings are expected to influence Vite's config (restarting Vite's dev server is needed) while some don't.
+doNotRestartViteOnError = false) {
+    assert(vikeConfigCtx);
+    const { userRootDir, isDev, vikeVitePluginOptions } = vikeConfigCtx;
+    const vikeConfig = await getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
+    return vikeConfig;
 }
-// TODO/soon: predominantly use getVikeConfigInternal() instead of getVikeConfig() then maybe refector?
-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);
+// TODO/v1-release: remove
+function getVikeConfigInternalSync() {
+    assert(vikeConfigSync);
+    return vikeConfigSync;
 }
-async function getVikeConfig2(userRootDir, isDev, vikeVitePluginOptions) {
-    assert(vikeVitePluginOptions);
-    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, false);
+// TO-DO/eventually: this maybe(/probably?) isn't safe against race conditions upon file changes in development, thus:
+// - Like getGlobalContext() and getGlobalContextSync() — make getVikeConfig() async and provide a getVikeConfigSync() while discourage using it
+// Public usage
+/**
+ * Get all the information Vike knows about the app in your Vite plugin.
+ *
+ * https://vike.dev/getVikeConfig
+ */
+function getVikeConfig(
+// TO-DO/eventually: remove unused arguments (older versions used it and we didn't remove it yet to avoid a TypeScript breaking change)
+// - No rush: we can do it later since it's getVikeConfig() is a beta feature as documented at https://vike.dev/getVikeConfig
+config) {
+    const vikeConfig = getVikeConfigInternalSync();
+    assertUsage(vikeConfig, 'getVikeConfig() can only be used when Vite is loaded (i.e. during development or build) — Vite is never loaded in production.');
+    const vikeConfigPublic = getProxyForPublicUsage(vikeConfig, 'vikeConfig');
+    return vikeConfigPublic;
 }
-async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+function setVikeConfigContext(vikeConfigCtx_) {
+    // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
+    vikeConfigCtx = vikeConfigCtx_;
+}
+async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     if (!vikeConfigPromise) {
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
+        resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     }
-    return await vikeConfigPromise;
+    assert(vikeConfigPromise);
+    const vikeConfig = await vikeConfigPromise;
+    return vikeConfig;
 }
-async function getVikeConfigOptional() {
+async function getVikeConfigInternalOptional() {
     if (!vikeConfigPromise)
         return null;
-    return await vikeConfigPromise;
+    const vikeConfig = await vikeConfigPromise;
+    return vikeConfig;
 }
-function isV1Design(config) {
-    const vikeConfig = config._vikeConfigObject;
-    assert(vikeConfig);
-    const { pageConfigs } = vikeConfig;
-    const isV1Design = pageConfigs.length > 0;
-    return isV1Design;
+function isV1Design() {
+    assert(typeof isV1Design_ === 'boolean');
+    return isV1Design_;
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
+    const { promise, resolve, reject } = genPromise();
+    vikeConfigPromise = promise;
+    const esbuildCache = {
+        transpileCache: {},
+        vikeConfigDependencies: new Set(),
+    };
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, vikeVitePluginOptions);
+        ret = await resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache);
     }
     catch (err_) {
         hasError = true;
         err = err_;
     }
+    // There is a newer call — let the new call supersede the old one.
+    // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
+    if (vikeConfigPromise !== promise) {
+        // vikeConfigPromise.then(resolve).catch(reject)
+        try {
+            resolve(await vikeConfigPromise);
+        }
+        catch (err) {
+            reject(err);
+        }
+        return;
+    }
     if (!hasError) {
         assert(ret);
         assert(err === undefined);
-        isVikeConfigInvalid_set(false);
-        return ret;
+        const hadError = vikeConfigHasBuildError;
+        vikeConfigHasBuildError = false;
+        setVikeConfigError({ errorBuild: false });
+        if (hadError) {
+            logConfigErrorRecover();
+            if (restartVite) {
+                restartVite = false;
+                restartViteDevServer();
+            }
+        }
+        resolve(ret);
     }
     else {
         assert(ret === undefined);
         assert(err);
-        isVikeConfigInvalid_set({ err });
+        vikeConfigHasBuildError = true;
+        setVikeConfigError({ errorBuild: { err } });
+        if (!doNotRestartViteOnError)
+            restartVite = true;
         if (!isDev) {
-            assert(getViteDevServer() === null);
-            throw err;
+            reject(err);
         }
         else {
             logConfigError(err);
-            if (!doNotRestartViteOnError) {
-                restartVite = true;
-            }
-            const dummyData = {
-                pageConfigs: [],
-                pageConfigGlobal: {
-                    configDefinitions: {},
-                    configValueSources: {}
-                },
-                global: getUserFriendlyConfigsGlobal({ pageConfigGlobalValues: {} }),
-                pages: {},
-                vikeConfigDependencies: new Set()
-            };
-            return dummyData;
+            resolve(getVikeConfigDummy(esbuildCache));
         }
     }
 }
-async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const esbuildCache = {
-        transpileCache: {},
-        vikeConfigDependencies: new Set()
-    };
+async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esbuildCache) {
     const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
+    if (!isV1Design_)
+        isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
     // global
     const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
-    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({ pageConfigGlobalValues });
+    const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({ pageConfigGlobalValues });
     // pages
-    const userFriendlyConfigsPageEager = objectFromEntries(pageConfigs.map((pageConfig) => {
+    const vikeConfigPublicPagesEager = objectFromEntries(pageConfigs.map((pageConfig) => {
         const pageConfigValues = getConfigValues(pageConfig, true);
-        return getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues);
+        return resolveVikeConfigPublicPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
-    return {
-        pageConfigs,
-        pageConfigGlobal,
-        global: userFriendlyConfigsGlobal,
-        pages: userFriendlyConfigsPageEager,
-        vikeConfigDependencies: esbuildCache.vikeConfigDependencies
+    const prerenderContext = resolvePrerenderContext({
+        config: vikeConfigPublicGlobal.config,
+        _from: vikeConfigPublicGlobal._from,
+        _pageConfigs: pageConfigs,
+    });
+    const vikeConfig = {
+        _pageConfigs: pageConfigs,
+        _pageConfigGlobal: pageConfigGlobal,
+        config: vikeConfigPublicGlobal.config,
+        _from: vikeConfigPublicGlobal._from,
+        pages: vikeConfigPublicPagesEager,
+        prerenderContext,
+        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
+    vikeConfigSync = vikeConfig;
+    return vikeConfig;
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const plusFilesAllOrdered = Object.values(plusFilesAll)
@@ -198,7 +225,7 @@ async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache)
             configDefinitions,
             plusFiles,
             plusFilesRelevant,
-            configNamesKnownLocal
+            configNamesKnownLocal,
         };
     }));
     const configDefinitionsResolved = {
@@ -206,7 +233,7 @@ async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache)
         configDefinitionsLocal,
         configDefinitionsAll,
         configNamesKnownAll,
-        configNamesKnownGlobal
+        configNamesKnownGlobal,
     };
     assertKnownConfigs(configDefinitionsResolved);
     return configDefinitionsResolved;
@@ -229,7 +256,7 @@ async function loadCustomConfigBuildTimeFiles(plusFiles, configDefinitions, user
 function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir) {
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsResolved.configDefinitionsGlobal,
-        configValueSources: {}
+        configValueSources: {},
     };
     objectEntries(configDefinitionsResolved.configDefinitionsGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, 
@@ -267,7 +294,7 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
             configDefinitions: configDefinitionsLocal,
             plusFiles: plusFilesRelevant,
             configValueSources,
-            configValuesComputed
+            configValuesComputed,
         };
         return pageConfig;
     });
@@ -297,7 +324,7 @@ function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDef
         // It's `null` when the config is defined by `vike(options)` in vite.config.js
         assert(plusFile);
         const { filePathAbsoluteUserRootDir } = plusFile.filePath;
-        // Allow local Vike extensions to set gloabl configs (`filePathAbsoluteUserRootDir===null` for Vike extension)
+        // Allow local Vike extensions to set global configs (`filePathAbsoluteUserRootDir===null` for Vike extension)
         if (!filePathAbsoluteUserRootDir)
             return;
         assert(!plusFile.isExtensionConfig);
@@ -383,9 +410,9 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
         sources.push(getSourceNonConfigFile(configName, value, {
             ...getFilePathResolved({
                 userRootDir,
-                filePathAbsoluteUserRootDir: '/vite.config.js'
+                filePathAbsoluteUserRootDir: '/vite.config.js',
             }),
-            fileExportPathToShowToUser: null
+            fileExportPathToShowToUser: null,
         }));
     });
 }
@@ -420,12 +447,12 @@ function getVikeConfigFromCliOrEnv() {
     const configFromEnvVar = getEnvVarObject('VIKE_CONFIG');
     const vikeConfigFromCliOrEnv = {
         ...configFromCliOptions, // Lower precedence
-        ...configFromEnvVar // Higher precedence
+        ...configFromEnvVar, // Higher precedence
     };
     return {
         vikeConfigFromCliOrEnv,
         configFromCliOptions,
-        configFromEnvVar
+        configFromEnvVar,
     };
 }
 function getSourceNonConfigFile(configName, value, definedAt) {
@@ -439,7 +466,7 @@ function getSourceNonConfigFile(configName, value, definedAt) {
         locationId: '/',
         plusFile: null,
         valueIsLoadedWithImport: false,
-        valueIsDefinedByPlusValueFile: false
+        valueIsDefinedByPlusValueFile: false,
     };
     return source;
 }
@@ -526,7 +553,7 @@ function sortPlusFilesSameLocationId(plusFile1, plusFile2, configName) {
             return ret;
     }
     // Config set by +{configName}.js (highest precedence)
-    // No need to make it deterministic: the overall order is arleady deterministic, see sortMakeDeterministic() at getPlusFilesAll()
+    // No need to make it deterministic: the overall order is already deterministic, see sortMakeDeterministic() at getPlusFilesAll()
     return 0;
 }
 function resolveConfigValueSources(configName, configDef, plusFilesRelevant, userRootDir, isGlobal, plusFilesAll) {
@@ -558,11 +585,11 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
     assert(confVal);
     const configValueSourceCommon = {
         locationId: plusFile.locationId,
-        plusFile
+        plusFile,
     };
     const definedAtFilePath_ = {
         ...plusFile.filePath,
-        fileExportPathToShowToUser: ['default', configName]
+        fileExportPathToShowToUser: ['default', configName],
     };
     // +client.js
     if (configDef._valueIsFilePath) {
@@ -583,7 +610,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             valueFilePath = plusFile.filePath.filePathAbsoluteVite;
             definedAtFilePath = {
                 ...plusFile.filePath,
-                fileExportPathToShowToUser: []
+                fileExportPathToShowToUser: [],
             };
         }
         const configValueSource = {
@@ -594,7 +621,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             configEnv: configDef.env,
             valueIsLoadedWithImport: false,
             valueIsDefinedByPlusValueFile: false,
-            definedAt: definedAtFilePath
+            definedAt: definedAtFilePath,
         };
         return configValueSource;
     }
@@ -607,10 +634,10 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             const value = pointerImport.fileExportValueLoaded
                 ? {
                     valueIsLoaded: true,
-                    value: pointerImport.fileExportValue
+                    value: pointerImport.fileExportValue,
                 }
                 : {
-                    valueIsLoaded: false
+                    valueIsLoaded: false,
                 };
             const configValueSource = {
                 ...configValueSourceCommon,
@@ -618,7 +645,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
                 configEnv: resolveConfigEnv(configDef.env, pointerImport.fileExportPath),
                 valueIsLoadedWithImport: true,
                 valueIsDefinedByPlusValueFile: false,
-                definedAt: pointerImport.fileExportPath
+                definedAt: pointerImport.fileExportPath,
             };
             return configValueSource;
         }
@@ -630,7 +657,7 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
             configEnv: configDef.env,
             valueIsLoadedWithImport: false,
             valueIsDefinedByPlusValueFile: false,
-            definedAt: definedAtFilePath_
+            definedAt: definedAtFilePath_,
         };
         return configValueSource;
     }
@@ -649,8 +676,8 @@ function getConfigValueSource(configName, plusFile, configDef, userRootDir) {
                 fileExportPathToShowToUser: configName === plusFile.configName
                     ? []
                     : // Side-effect config (e.g. `export { frontmatter }` of .md files)
-                        [configName]
-            }
+                        [configName],
+            },
         };
         return configValueSource;
     }
@@ -673,7 +700,7 @@ function resolveIsGlobalValue(configDefGlobal, source, plusFilesAll) {
     let isGlobal;
     if (isCallable(configDefGlobal))
         isGlobal = configDefGlobal(source.value, {
-            isGlobalLocation: isGlobalLocation(source.locationId, plusFilesAll)
+            isGlobalLocation: isGlobalLocation(source.locationId, plusFilesAll),
         });
     else
         isGlobal = configDefGlobal ?? false;
@@ -710,20 +737,20 @@ function getConfigDefinitions(plusFilesRelevant, filter) {
             assert(plusFile.isConfigFile);
             configDef._userEffectDefinedAtFilePath = {
                 ...plusFile.filePath,
-                fileExportPathToShowToUser: ['default', 'meta', configName, 'effect']
+                fileExportPathToShowToUser: ['default', 'meta', configName, 'effect'],
             };
         });
         objectEntries(meta).forEach(([configName, configDefinitionUserLand]) => {
             if ('isDefinedByPeerDependency' in configDefinitionUserLand) {
                 configDefinitionUserLand = {
                     env: { client: false, server: false, config: false },
-                    ...configDefinitionUserLand
+                    ...configDefinitionUserLand,
                 };
             }
             // User can override an existing config definition
             configDefinitions[configName] = {
                 ...configDefinitions[configName],
-                ...configDefinitionUserLand
+                ...configDefinitionUserLand,
             };
         });
     });
@@ -801,13 +828,13 @@ function runEffect(configName, configDef, source) {
         return null;
     // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
     assertUsage(configDef.env.config, [
-        `Cannot add meta.effect to ${pc.cyan(configName)} because its meta.env is ${pc.cyan(JSON.stringify(configDef.env))} but an effect can only be added to a config that has a meta.env with ${pc.cyan('{ config: true }')}.`
+        `Cannot add meta.effect to ${pc.cyan(configName)} because its meta.env is ${pc.cyan(JSON.stringify(configDef.env))} but an effect can only be added to a config that has a meta.env with ${pc.cyan('{ config: true }')}.`,
     ].join(' '));
     assert(source.valueIsLoaded);
     // Call effect
     const configModFromEffect = configDef.effect({
         configValue: source.value,
-        configDefinedAt: getConfigDefinedAt('Config', configName, source.definedAt)
+        configDefinedAt: getConfigDefinedAt('Config', configName, source.definedAt),
     });
     if (!configModFromEffect)
         return null;
@@ -828,7 +855,7 @@ function applyEffectConfVal(configModFromEffect, sourceEffect, configValueSource
             valueIsLoadedWithImport: false,
             valueIsDefinedByPlusValueFile: false,
             valueIsLoaded: true,
-            value: configValue
+            value: configValue,
         };
         assert(sourceEffect.valueIsLoaded);
         const isValueGlobalSource = resolveIsGlobalValue(configDefEffect.global, sourceEffect, plusFilesAll);
@@ -860,11 +887,11 @@ function applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEf
                 assertUsage(keys.includes('env'), notSupported);
                 assertUsage(keys.length === 1, notSupported);
             }
-            const envOverriden = configTargetDef.env;
+            const envOverridden = configTargetDef.env;
             const sources = configValueSources[configTargetName];
             sources?.forEach((configValueSource) => {
                 // Apply effect
-                configValueSource.configEnv = envOverriden;
+                configValueSource.configEnv = envOverridden;
             });
         });
     });
@@ -879,7 +906,7 @@ function getComputed(configValueSources, configDefinitions) {
             return;
         configValuesComputed[configName] = {
             value,
-            configEnv: configDef.env
+            configEnv: configDef.env,
         };
     });
     return configValuesComputed;
@@ -924,7 +951,7 @@ function assertKnownConfig(configName, configNamesKnownRelevant, configDefinitio
             title: ui,
             ssr: ui,
             stream: ui,
-            Wrapper: ui
+            Wrapper: ui,
         };
         if (configName in knownVikeExntensionConfigs) {
             const requiredVikeExtension = joinEnglish(knownVikeExntensionConfigs[configName].map((e) => pc.bold(e)), 'or');
@@ -971,7 +998,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     assert(filesystemRouteString.startsWith('/'));
     const routeFilesystem = {
         routeString: filesystemRouteString,
-        definedAtLocation: filesystemRouteDefinedBy
+        definedAtLocation: filesystemRouteDefinedBy,
     };
     return { routeFilesystem, isErrorPage: undefined };
 }
@@ -1070,7 +1097,7 @@ function isGlobalLocation(locationId, plusFilesAll) {
         .map(([locationId]) => locationId);
     return locationIdsPage.every((locId) => isInherited(locationId, locId));
 }
-function isOverriden(source, configName, pageConfig) {
+function isOverridden(source, configName, pageConfig) {
     const configDef = pageConfig.configDefinitions[configName];
     assert(configDef);
     if (configDef.cumulative)
@@ -1081,3 +1108,56 @@ function isOverriden(source, configName, pageConfig) {
     assert(idx >= 0);
     return idx > 0;
 }
+function resolvePrerenderContext(vikeConfig) {
+    const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
+    prerenderContext ?? (prerenderContext = {
+        isPrerenderingEnabled: false,
+        isPrerenderingEnabledForAllPages: false,
+        // Set at runPrerender()
+        output: null,
+        // Set at runPrerender()
+        pageContexts: null,
+    });
+    prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
+    prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
+    return prerenderContext;
+}
+function restartViteDevServer() {
+    const viteDevServer = getViteDevServer();
+    assert(viteDevServer);
+    removeSuperfluousViteLog_enable();
+    (async () => {
+        try {
+            await viteDevServer.restart(true);
+        }
+        catch (err) {
+            console.error('Vite restart error:');
+            console.error(err);
+        }
+    })();
+    removeSuperfluousViteLog_disable();
+}
+function getVikeConfigDummy(esbuildCache) {
+    const globalDummy = resolveVikeConfigPublicGlobal({ pageConfigGlobalValues: {} });
+    const pageConfigsDummy = [];
+    const prerenderContextDummy = resolvePrerenderContext({
+        config: globalDummy.config,
+        _from: globalDummy._from,
+        _pageConfigs: pageConfigsDummy,
+    });
+    const vikeConfigDummy = {
+        _pageConfigs: pageConfigsDummy,
+        _pageConfigGlobal: {
+            configDefinitions: {},
+            configValueSources: {},
+        },
+        config: globalDummy.config,
+        _from: globalDummy._from,
+        pages: {},
+        prerenderContext: prerenderContextDummy,
+        _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
+    };
+    vikeConfigSync = vikeConfigDummy;
+    isV1Design_ = true;
+    return vikeConfigDummy;
+}

package/dist/esm/node/{plugin → vite}/utils.d.ts

@@ -4,22 +4,16 @@ export * from '../../utils/includes.js';
 export * from '../../utils/isDev.js';
 export * from '../../utils/getMostSimilar.js';
 export * from '../../utils/getRandomId.js';
-export * from '../../utils/joinEnglish.js';
 export * from '../../utils/escapeRegex.js';
-export * from '../../utils/stripAnsi.js';
 export * from '../../utils/trimWithAnsi.js';
 export * from '../../utils/removeEmptyLines.js';
 export * from '../../utils/findPackageJson.js';
-export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
-export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
-export * from '../../utils/isArray.js';
-export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/isEqualStringList.js';
 export * from '../../utils/isDocker.js';
 export * from '../../utils/isVitest.js';