vike 0.4.218-commit-85af52a → 0.4.218-commit-ea8bb27

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

@@ -7,7 +7,7 @@ export { isV1Design };
 export { getConfigValueInterfaceFile };
 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 { configDefinitionsBuiltInAll } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
 import { isTemporaryBuildFile } from './getVikeConfig/transpileAndExecuteFile.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
@@ -25,6 +25,8 @@ import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getC
 import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
 import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
 import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
+const configDefinitionsBuiltIn = getConfigDefinitionsBuiltIn();
+const configDefinitionsBuiltInGlobal = getConfigDefinitionsBuiltInGlobal();
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -241,9 +243,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configValueSources: {}
                 },
                 vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
-                vikeConfigNew: {
-                    global: getPageConfigUserFriendlyNew({ configValues: {} })
-                }
+                global: getPageConfigUserFriendlyNew({ configValues: {} })
             };
             return dummyData;
         }
@@ -252,7 +252,97 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
     const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir);
     const importedFilesLoaded = {};
-    const { pageConfigGlobal, vikeConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions);
+    const [globalConfigs, pageConfigs] = await Promise.all([
+        getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions),
+        getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded)
+    ]);
+    return { pageConfigs, ...globalConfigs };
+}
+async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
+    const locationIds = objectKeys(interfaceFilesByLocationId);
+    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
+        return isGlobalLocation(locationId, locationIds);
+    }));
+    // Validate that global configs live in global interface files
+    {
+        const interfaceFilesGlobalPaths = [];
+        objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
+            assert(isGlobalLocation(locationId, locationIds));
+            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
+                if (filePathAbsoluteUserRootDir) {
+                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
+                }
+            });
+        });
+        const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))));
+        objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+            interfaceFiles.forEach((interfaceFile) => {
+                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
+                    if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
+                        assertUsage(false, [
+                            `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(configName)} which is global:`,
+                            globalPaths.length
+                                ? `define ${pc.cyan(configName)} in ${joinEnglish(globalPaths, 'or')} instead`
+                                : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead`
+                        ].join(' '));
+                    }
+                });
+            });
+        });
+    }
+    const pageConfigGlobalValues = {};
+    const pageConfigGlobal = {
+        configDefinitions: configDefinitionsBuiltInGlobal,
+        configValueSources: {}
+    };
+    await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
+        const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir, importedFilesLoaded);
+        const configValueSource = sources[0];
+        if (!configValueSource)
+            return;
+        pageConfigGlobal.configValueSources[configName] = sources;
+        // TODO/now
+        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
+            assert(!('value' in configValueSource));
+        }
+        else {
+            assert('value' in configValueSource);
+            // TODO/now
+            if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
+                return;
+            pageConfigGlobalValues[configName] = configValueSource.value;
+        }
+    }));
+    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
+    {
+        assert(isObject(vikeVitePluginOptions));
+        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+            var _a;
+            assert(includes(objectKeys(configDefinitionsBuiltInGlobal), configName));
+            const configDef = configDefinitionsBuiltInGlobal[configName];
+            const sources = ((_a = pageConfigGlobal.configValueSources)[configName] ?? (_a[configName] = []));
+            sources.push({
+                value,
+                configEnv: configDef.env,
+                definedAtFilePath: {
+                    ...getFilePathResolved({
+                        userRootDir,
+                        filePathAbsoluteUserRootDir: '/vite.config.js'
+                    }),
+                    fileExportPathToShowToUser: null
+                },
+                locationId: '/',
+                isOverriden: configDef.cumulative ? false : sources.length > 0,
+                valueIsImportedAtRuntime: false,
+                valueIsDefinedByPlusFile: false
+            });
+        });
+    }
+    const configValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues });
+    return { pageConfigGlobal, vikeConfigGlobal, global };
+}
+async function getPageConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -302,13 +392,11 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
         return pageConfig;
     }));
     assertPageConfigs(pageConfigs);
-    const configValues = getConfigValues(pageConfigGlobal);
-    const global = getPageConfigUserFriendlyNew({ configValues });
-    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal, vikeConfigNew: { global } };
+    return pageConfigs;
 }
 function getConfigValues(pageConfig) {
     const configValues = {};
-    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config).forEach((entry) => {
+    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
             assert('value' in entry); // Help TS
             const { configValueBase, value, configName } = entry;
@@ -334,7 +422,7 @@ function getConfigValues(pageConfig) {
     });
     return configValues;
 }
-// TODO/soon: refactor
+// TODO/now: refactor
 //  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
 //    - This assertUsage() message is slightly better: use this one for getGlobalConfigs()
 // Global configs should be defined at global locations
@@ -351,7 +439,7 @@ function assertUsageGlobalConfigs(interfaceFilesRelevantList, configDefinitions,
             if (isGlobalConfig(configName))
                 return;
             const configDef = getConfigDefinition(configDefinitions, configName, interfaceFile.filePath.filePathToShowToUser);
-            if (configDef.global) {
+            if (configDef.global === true) {
                 const locationIds = objectKeys(interfaceFilesByLocationId);
                 if (!isGlobalLocation(interfaceFile.locationId, locationIds)) {
                     const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
@@ -410,85 +498,6 @@ function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
     return interfaceFilesRelevant;
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
-    const locationIds = objectKeys(interfaceFilesByLocationId);
-    const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
-        return isGlobalLocation(locationId, locationIds);
-    }));
-    // Validate that global configs live in global interface files
-    {
-        const interfaceFilesGlobalPaths = [];
-        objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
-            assert(isGlobalLocation(locationId, locationIds));
-            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
-                if (filePathAbsoluteUserRootDir) {
-                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
-                }
-            });
-        });
-        const globalPaths = Array.from(new Set(interfaceFilesGlobalPaths.map((p) => path.posix.dirname(p))));
-        objectEntries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-            interfaceFiles.forEach((interfaceFile) => {
-                Object.keys(interfaceFile.fileExportsByConfigName).forEach((configName) => {
-                    if (!isGlobalLocation(locationId, locationIds) && isGlobalConfig(configName)) {
-                        assertUsage(false, [
-                            `${interfaceFile.filePath.filePathToShowToUser} defines the config ${pc.cyan(configName)} which is global:`,
-                            globalPaths.length
-                                ? `define ${pc.cyan(configName)} in ${joinEnglish(globalPaths, 'or')} instead`
-                                : `create a global config (e.g. /pages/+config.js) and define ${pc.cyan(configName)} there instead`
-                        ].join(' '));
-                    }
-                });
-            });
-        });
-    }
-    const pageConfigGlobalValues = {};
-    const pageConfigGlobal = {
-        configDefinitions: configDefinitionsBuiltInGlobal,
-        configValueSources: {}
-    };
-    await Promise.all(objectEntries(configDefinitionsBuiltInGlobal).map(async ([configName, configDef]) => {
-        const sources = await resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir, importedFilesLoaded);
-        const configValueSource = sources[0];
-        if (!configValueSource)
-            return;
-        pageConfigGlobal.configValueSources[configName] = sources;
-        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
-            assert(!('value' in configValueSource));
-        }
-        else {
-            assert('value' in configValueSource);
-            if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
-                return;
-            pageConfigGlobalValues[configName] = configValueSource.value;
-        }
-    }));
-    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
-    {
-        assert(isObject(vikeVitePluginOptions));
-        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
-            if (pageConfigGlobal.configValueSources[configName])
-                return;
-            pageConfigGlobal.configValueSources[configName] = [];
-            pageConfigGlobal.configValueSources[configName].push({
-                value,
-                configEnv: { config: true },
-                definedAtFilePath: {
-                    ...getFilePathResolved({
-                        userRootDir,
-                        filePathAbsoluteUserRootDir: '/vite.config.js'
-                    }),
-                    fileExportPathToShowToUser: null
-                },
-                locationId: '/',
-                isOverriden: false,
-                valueIsImportedAtRuntime: false,
-                valueIsDefinedByPlusFile: false
-            });
-        });
-    }
-    return { pageConfigGlobal, pageConfigGlobalValues, vikeConfigGlobal };
-}
 async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
     const sourcesInfo = [];
     // interfaceFilesRelevant is sorted by sortAfterInheritanceOrder()
@@ -1031,6 +1040,7 @@ function isLoadableAtBuildTime(configDef) {
     return !!configDef.env.config && !configDef._valueIsFilePath;
 }
 function isGlobalConfig(configName) {
+    // TODO/now
     if (configName === 'prerender')
         return false;
     const configNamesGlobal = getConfigNamesGlobal();
@@ -1039,6 +1049,12 @@ function isGlobalConfig(configName) {
 function getConfigNamesGlobal() {
     return Object.keys(configDefinitionsBuiltInGlobal);
 }
+function getConfigDefinitionsBuiltInGlobal() {
+    return objectFromEntries(objectEntries(configDefinitionsBuiltInAll).filter(([_configName, configDef]) => configDef.global !== undefined));
+}
+function getConfigDefinitionsBuiltIn() {
+    return objectFromEntries(objectEntries(configDefinitionsBuiltInAll).filter(([_configName, configDef]) => configDef.global !== true));
+}
 function assertConfigExists(configName, configNamesRelevant, filePathToShowToUser) {
     const configNames = [...configNamesRelevant, ...getConfigNamesGlobal()];
     if (configNames.includes(configName))
@@ -1065,23 +1081,15 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
 function getConfigValueInterfaceFile(interfaceFile, configName) {
     return interfaceFile.fileExportsByConfigName[configName]?.configValue;
 }
-// TODO: refactor code below
+// TODO/now: refactor code below
 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 configs = [vikeVitePluginOptions, 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
     };
@@ -1102,84 +1110,6 @@ function resolvePrerenderOptions(configs) {
 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/getVirtualFilePageConfigValuesAll.js

@@ -31,7 +31,7 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const importStatements = [];
     const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: false }, ''));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '', false));
     lines.push('};');
     if (!fixServerAssets_isEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);

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

@@ -33,7 +33,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
         lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: true }, '    '));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
@@ -43,7 +43,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), { isEager: true }, '    '));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

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

@@ -4,8 +4,8 @@ export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender } from './utils.js';
-import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject } from './utils.js';
+import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
 import { getGlobalContext, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
@@ -70,6 +70,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
+    validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         assert(standaloneTrigger);
         assertWarning(prerenderConfig, `You're executing ${pc.cyan(standaloneTrigger)} but the config ${pc.cyan('prerender')} isn't set to true`, {
@@ -79,8 +80,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
-    const renderContext = await getRenderContext();
-    renderContext.pageFilesAll.forEach(assertExportNames);
+    const globalContext = getGlobalContext();
+    globalContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {};
     objectAssign(prerenderContext, {
         _urlHandler: null,
@@ -89,10 +90,10 @@ async function runPrerender(options = {}, standaloneTrigger) {
         pageContextInit: options.pageContextInit ?? null
     });
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
-    await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
-    await callOnPrerenderStartHook(prerenderContext, renderContext);
+    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
+    await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
+    await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
+    await callOnPrerenderStartHook(prerenderContext);
     const prerenderedPageContexts = {};
     let prerenderedCount = 0;
     const onComplete = async (htmlFile) => {
@@ -104,14 +105,14 @@ async function runPrerender(options = {}, standaloneTrigger) {
     };
     await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
     warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete);
+    await prerender404(prerenderedPageContexts, prerenderContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
+    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial);
     return { viteConfig };
 }
-async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
+async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
@@ -129,7 +130,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
     });
     // Old design
     // TODO/v1-release: remove
-    await Promise.all(renderContext.pageFilesAll
+    const globalContext = getGlobalContext();
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('doNotPrerender'))
@@ -141,8 +143,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
         assert(p.loadFile);
         await p.loadFile();
     })));
-    renderContext.allPageIds.forEach((pageId) => {
-        const pageFilesServerSide = getPageFilesServerSide(renderContext.pageFilesAll, pageId);
+    globalContext.allPageIds.forEach((pageId) => {
+        const pageFilesServerSide = getPageFilesServerSide(globalContext.pageFilesAll, pageId);
         for (const p of pageFilesServerSide) {
             if (!p.exportNames?.includes('doNotPrerender'))
                 continue;
@@ -171,10 +173,11 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     assert(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
+    const globalContext = getGlobalContext();
     // V1 design
-    await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
+    await Promise.all(globalContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
         const pageConfigLoaded = await loadConfigValues(pageConfig, false);
         const hook = getHookFromPageConfig(pageConfigLoaded, hookName);
@@ -190,7 +193,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         });
     })));
     // 0.4 design
-    await Promise.all(renderContext.pageFilesAll
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('prerender'))
@@ -231,7 +234,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
                     assertUsage(false, `URL ${pc.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = createPageContext(url, renderContext, prerenderContext);
+            const pageContextNew = createPageContext(url, prerenderContext);
             objectAssign(pageContextNew, {
                 _providedByHook: {
                     hookFilePath,
@@ -248,9 +251,10 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         });
     })));
 }
-async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit) {
+async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit) {
     // Pre-render pages with a static route
-    await Promise.all(renderContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
+    const globalContext = getGlobalContext();
+    await Promise.all(globalContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
         const { pageId } = pageRoute;
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
@@ -275,7 +279,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             return;
         }
         const routeParams = {};
-        const pageContext = createPageContext(urlOriginal, renderContext, prerenderContext);
+        const pageContext = createPageContext(urlOriginal, prerenderContext);
         objectAssign(pageContext, {
             _providedByHook: null,
             routeParams,
@@ -293,7 +297,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-function createPageContext(urlOriginal, renderContext, prerenderContext) {
+function createPageContext(urlOriginal, prerenderContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
@@ -305,17 +309,18 @@ function createPageContext(urlOriginal, renderContext, prerenderContext) {
     };
     objectAssign(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
+        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit);
         objectAssign(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext, renderContext) {
+async function callOnPrerenderStartHook(prerenderContext) {
+    const globalContext = getGlobalContext();
     let onPrerenderStartHook;
     // V1 design
-    if (renderContext.pageConfigs.length > 0) {
+    if (globalContext.pageConfigs.length > 0) {
         const hookName = 'onPrerenderStart';
-        const hook = getHookFromPageConfigGlobal(renderContext.pageConfigGlobal, hookName);
+        const hook = getHookFromPageConfigGlobal(globalContext.pageConfigGlobal, hookName);
         if (hook) {
             assert(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
@@ -327,9 +332,9 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     }
     // Old design
     // TODO/v1-release: remove
-    if (renderContext.pageConfigs.length === 0) {
+    if (globalContext.pageConfigs.length === 0) {
         const hookTimeout = getHookTimeoutDefault('onBeforePrerender');
-        const pageFilesWithOnBeforePrerenderHook = renderContext.pageFilesAll.filter((p) => {
+        const pageFilesWithOnBeforePrerenderHook = globalContext.pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
@@ -517,27 +522,28 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
         assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial) {
-    const isV1 = renderContext.pageConfigs.length > 0;
+function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial) {
+    const globalContext = getGlobalContext();
+    const isV1 = globalContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
     const optOutName = isV1 ? 'prerender' : 'doNotPrerender'
     const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
     */
-    renderContext.allPageIds
+    globalContext.allPageIds
         .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
-        .filter((pageId) => !isErrorPage(pageId, renderContext.pageConfigs))
+        .filter((pageId) => !isErrorPage(pageId, globalContext.pageConfigs))
         .forEach((pageId) => {
         const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete) {
+async function prerender404(prerenderedPageContexts, prerenderContext, onComplete) {
     if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
-            result = await prerender404Page(renderContext, prerenderContext.pageContextInit);
+            result = await prerender404Page(prerenderContext.pageContextInit);
         }
         catch (err) {
             assertIsNotAbort(err, 'the 404 page');
@@ -717,3 +723,38 @@ function makePageContextComputedUrlNonEnumerable(pageContexts) {
         });
     }
 }
+function validatePrerenderConfig(
+// Guaranteed by configDef.type to be either an object or boolean
+prerenderConfig) {
+    if (!prerenderConfig || typeof prerenderConfig === 'boolean')
+        return;
+    assert(isObject(prerenderConfig));
+    const wrongValue = (() => {
+        {
+            const p = 'partial';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!hasProp(prerenderConfig, p, 'boolean') &&
+                !hasProp(prerenderConfig, p, 'number') &&
+                !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean or a number' };
+        }
+    })();
+    if (wrongValue) {
+        const { prop, errMsg } = wrongValue;
+        assertUsage(false, `Setting ${pc.cyan(`prerender.${prop}`)} ${errMsg}`);
+    }
+}