vike 0.4.161 → 0.4.162-commit-8995471

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

@@ -7,65 +7,58 @@ import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath } from '../../../../utils.js';
-import { isImportData, transformFileImports } from './transformFileImports.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isJavaScriptFile, createDebugger } from '../../../../utils.js';
+import { transformFileImports } from './transformFileImports.js';
 import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
-import { getConfigFileExport } from '../getConfigFileExport.js';
 assertIsNotProductionRuntime();
-async function transpileAndExecuteFile(filePath, transformImports, userRootDir, doNotTranspile = false) {
-    if (doNotTranspile) {
-        assert(!transformImports);
-        const fileExports = await executeFile(filePath.filePathAbsoluteFilesystem, filePath);
-        if (isHeaderFile(filePath.filePathAbsoluteFilesystem)) {
-            const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-            assertWarning(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files don't apply to the config files of extensions`, { onlyOnce: true });
-        }
+const debug = createDebugger('vike:pointer-imports');
+async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
+    const { filePathAbsoluteFilesystem } = filePath;
+    const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
+    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+    assertUsage(isJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUser2} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
+    const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
+    if (isHeader) {
+        assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUser2} to ${removeHeaderFileExtension(filePathToShowToUser2)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
+    }
+    if (isConfigFile === 'is-extension-config' && !isHeader && fileExtension.endsWith('js')) {
+        // This doesn't track dependencies => we should never use this for user land configs
+        const fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
         return { fileExports };
     }
     else {
-        const { code, fileImportsTransformed } = await transpileFile(filePath, transformImports, userRootDir);
-        const fileExports = await executeTranspiledFile(filePath, code, fileImportsTransformed);
+        const transformImports = isConfigFile && (isHeader ? 'all' : true);
+        const code = await transpileFile(filePath, transformImports, userRootDir);
+        const fileExports = await executeTranspiledFile(filePath, code);
         return { fileExports };
     }
 }
 async function transpileFile(filePath, transformImports, userRootDir) {
-    const { filePathAbsoluteFilesystem } = filePath;
     const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+    const { filePathAbsoluteFilesystem } = filePath;
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    let code = await transpileWithEsbuild(filePath, userRootDir, transformImports);
-    let fileImportsTransformed = null;
+    if (debug.isEnabled)
+        debug('transpile', filePathToShowToUser2);
+    let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
+    if (debug.isEnabled)
+        debug(`code, post esbuild (${filePathToShowToUser2})`, code);
+    let isImportTransformed = false;
     if (transformImports) {
-        const res = transformFileImports_(code, filePath);
-        if (res) {
-            code = res.code;
-            fileImportsTransformed = res.fileImportsTransformed;
+        const codeMod = transformFileImports(code, filePathToShowToUser2, pointerImports);
+        if (codeMod) {
+            code = codeMod;
+            isImportTransformed = true;
+            if (debug.isEnabled)
+                debug(`code, post transformImports() (${filePathToShowToUser2})`, code);
         }
     }
-    else {
-        if (isHeaderFile(filePathAbsoluteFilesystem)) {
-            assertWarning(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files only apply to +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
-        }
+    if (!isImportTransformed) {
+        if (debug.isEnabled)
+            debug(`code, no transformImports() (${filePathToShowToUser2})`);
     }
-    return { code, fileImportsTransformed };
-}
-function transformFileImports_(codeOriginal, filePath) {
-    const { filePathAbsoluteFilesystem } = filePath;
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-    // Replace import statements with import strings
-    const res = transformFileImports(codeOriginal, filePathToShowToUser2);
-    if (res.noTransformation) {
-        return null;
-    }
-    const { code, fileImportsTransformed } = res;
-    if (!isHeaderFile(filePathAbsoluteFilesystem)) {
-        const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser2);
-        assertWarning(false, `Rename ${filePathToShowToUser2} to ${filePathCorrect}, see https://vike.dev/header-file`, {
-            onlyOnce: true
-        });
-    }
-    return { code, fileImportsTransformed };
+    return code;
 }
 async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
     const entryFilePath = filePath.filePathAbsoluteFilesystem;
@@ -88,14 +81,63 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
         treeShaking: false,
         minify: false,
-        metafile: !transformImports,
-        // We cannot bundle imports that are meant to be transformed
-        bundle: !transformImports
+        metafile: transformImports !== 'all',
+        bundle: transformImports !== 'all'
     };
-    // Track dependencies
-    if (!transformImports) {
+    let pointerImports;
+    if (transformImports === 'all') {
+        pointerImports = 'all';
         options.packages = 'external';
+    }
+    else {
+        const pointerImports_ = (pointerImports = {});
         options.plugins = [
+            // Determine what import should be externalized (and then transformed to a pointer/fake import)
+            {
+                name: 'vike:externalize-heuristic',
+                setup(build) {
+                    // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
+                    const useEsbuildResolver = 'useEsbuildResolver';
+                    // https://github.com/brillout/esbuild-playground
+                    build.onResolve({ filter: /.*/ }, async (args) => {
+                        if (args.kind !== 'import-statement')
+                            return;
+                        if (args.pluginData?.[useEsbuildResolver])
+                            return;
+                        const isImportAbsolute = !args.path.startsWith('.');
+                        const { path, ...opts } = args;
+                        opts.pluginData = { [useEsbuildResolver]: true };
+                        const resolved = await build.resolve(path, opts);
+                        // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
+                        //  - This is temporary, see comment below.
+                        const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
+                        const isPointerImport = 
+                        // .jsx, .vue, .svg, ... => obviously not config code
+                        !isJavaScriptFile(resolved.path) ||
+                            // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
+                            //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
+                            //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
+                            isVikeExtensionConfigImport ||
+                            // Cannot be resolved by esbuild => take a leap of faith and make it a pointer import.
+                            //  - For example if esbuild cannot resolve a path alias while Vite can.
+                            //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
+                            resolved.errors.length > 0;
+                        pointerImports_[args.path] = isPointerImport;
+                        const isExternal = isPointerImport ||
+                            // npm package imports that aren't pointer imports (e.g. Vite plugin import)
+                            isImportAbsolute;
+                        if (debug.isEnabled)
+                            debug('onResolved()', { args, resolved, isPointerImport, isExternal });
+                        if (isExternal) {
+                            return { external: true, path: args.path };
+                        }
+                        else {
+                            return resolved;
+                        }
+                    });
+                }
+            },
+            // Track dependencies
             {
                 name: 'vike:dependency-tracker',
                 setup(b) {
@@ -128,7 +170,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         throw err;
     }
     // Track dependencies
-    if (!transformImports) {
+    if (transformImports !== 'all') {
         assert(result.metafile);
         Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
             filePathRelative = toPosixPath(filePathRelative);
@@ -139,10 +181,10 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
     }
     const code = result.outputFiles[0].text;
     assert(typeof code === 'string');
-    return code;
+    return { code, pointerImports };
 }
-async function executeTranspiledFile(filePath, code, fileImportsTransformed) {
-    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
+async function executeTranspiledFile(filePath, code) {
+    const { filePathAbsoluteFilesystem } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
     const filePathTmp = getFilePathTmp(filePathAbsoluteFilesystem);
@@ -155,11 +197,6 @@ async function executeTranspiledFile(filePath, code, fileImportsTransformed) {
     finally {
         clean();
     }
-    if (fileImportsTransformed) {
-        assert(filePathRelativeToUserRootDir !== undefined);
-        const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-        assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2);
-    }
     return fileExports;
 }
 async function executeFile(filePathToExecuteAbsoluteFilesystem, filePathSourceFile) {
@@ -222,59 +259,27 @@ function isTmpFile(filePath) {
     const fileName = path.posix.basename(filePath);
     return fileName.startsWith(tmpPrefix);
 }
-function assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2) {
-    const fileExport = getConfigFileExport(fileExports, filePathToShowToUser2);
-    const exportedStrings = getExportedStrings(fileExport);
-    Object.values(exportedStrings).forEach((exportVal) => {
-        if (typeof exportVal !== 'string')
-            return;
-        if (!isImportData(exportVal))
-            return;
-        const importString = exportVal;
-        fileImportsTransformed.forEach((fileImport) => {
-            if (fileImport.importString === importString) {
-                fileImport.isReExported = true;
-            }
-        });
-    });
-    const fileImportsTransformedUnused = fileImportsTransformed.filter((fi) => !fi.isReExported);
-    if (fileImportsTransformedUnused.length === 0)
-        return;
-    const importStatements = unique(fileImportsTransformedUnused.map((fi) => fi.importStatementCode));
-    const importNamesUnused = fileImportsTransformedUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
-    const singular = fileImportsTransformedUnused.length === 1;
-    assertWarning(fileImportsTransformedUnused.length === 0, [
-        `${filePathToShowToUser2} imports the following:`,
-        ...importStatements.map((s) => pc.cyan(`  ${s}`)),
-        `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${pc.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
-    ].join('\n'), { onlyOnce: true });
-}
-function getExportedStrings(obj) {
-    const exportedStrings = [];
-    Object.values(obj).forEach((val) => {
-        if (typeof val === 'string') {
-            exportedStrings.push(val);
-        }
-        else if (Array.isArray(val)) {
-            val.forEach((v) => {
-                if (typeof v === 'string') {
-                    exportedStrings.push(v);
-                }
-            });
-        }
-    });
-    return exportedStrings;
-}
 function isHeaderFile(filePath) {
     assertPosixPath(filePath);
-    const basenameParts = path.posix.basename(filePath).split('.');
-    return basenameParts.includes('h');
+    const fileExtensions = getFileExtensions(filePath);
+    return fileExtensions.includes('h');
 }
-function appendHeaderFileExtension(filePath) {
-    const basenameParts = path.posix.basename(filePath).split('.');
-    basenameParts.splice(-1, 0, 'h');
-    const basenameCorrect = basenameParts.join('.');
-    return path.posix.join(path.posix.dirname(filePath), basenameCorrect);
+function getFileExtensions(filePath) {
+    const fileExtensions = path.posix.basename(filePath).split('.').slice(1);
+    return fileExtensions;
+}
+function getFileExtension(filePath) {
+    const fileExtensions = path.posix.basename(filePath).split('.').slice(1);
+    return fileExtensions.pop();
+}
+function removeHeaderFileExtension(filePath) {
+    assertPosixPath(filePath);
+    const fileName = path.posix.basename(filePath);
+    const fileNameParts = fileName.split('.');
+    const fileNamePartsMod = fileNameParts.filter((p) => p !== 'h');
+    assert(fileNamePartsMod.length < fileNameParts.length);
+    const fileNameMod = fileNamePartsMod.join('.');
+    return path.posix.join(path.posix.dirname(filePath), fileNameMod);
 }
 // Needed for the npm package 'source-map-support'. The Error.prepareStackTrace() hook of 'source-map-support' needs to be called before the file containing the source map is removed. The clean() call above removes the transpiled file from disk but it contains the inline source map.
 function triggerPrepareStackTrace(err) {

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

@@ -3,9 +3,9 @@ export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
+export type { VikeConfig };
 export type { InterfaceValueFile };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime, FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
-import type { ExtensionResolved } from '../../../../../shared/ConfigVike.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
 type InterfaceFileCommons = {
@@ -27,7 +27,7 @@ type VikeConfig = {
     globalVikeConfig: Record<string, unknown>;
 };
 declare const vikeConfigDependencies: Set<string>;
-declare function reloadVikeConfig(userRootDir: string, outDirRoot: string, extensions: ExtensionResolved[]): void;
-declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean, extensions?: ExtensionResolved[]): Promise<VikeConfig>;
+declare function reloadVikeConfig(userRootDir: string, outDirRoot: string): void;
+declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
 declare function isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;

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

@@ -14,7 +14,6 @@ import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNot
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/helpers.js';
-import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
 import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
@@ -26,10 +25,10 @@ let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
-function reloadVikeConfig(userRootDir, outDirRoot, extensions) {
+function reloadVikeConfig(userRootDir, outDirRoot) {
     vikeConfigDependencies.clear();
     clearFilesEnvMap();
-    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, extensions, true);
+    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, true);
     handleReloadSideEffects();
 }
 async function handleReloadSideEffects() {
@@ -63,20 +62,22 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(config, isDev, tolerateInvalidConfig = false, extensions) {
+async function getVikeConfig(config, isDev, tolerateInvalidConfig = false) {
     const { outDirRoot } = getOutDirs(config);
     const userRootDir = config.root;
     if (!vikeConfigPromise) {
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions ?? (await getConfigVike(config)).extensions, tolerateInvalidConfig);
+        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, tolerateInvalidConfig);
     }
     return await vikeConfigPromise;
 }
 async function isV1Design(config, isDev) {
-    const isV1Design = (await getVikeConfig(config, isDev)).pageConfigs.length > 0;
+    const vikeConfig = await getVikeConfig(config, isDev);
+    const { pageConfigs } = vikeConfig;
+    const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
-    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, extensions);
+async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
+    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -102,14 +103,14 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
             extendsConfigs.forEach((extendsConfig) => {
                 /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
                 ```js
-                // /pages/admin/+config.h.js
+                // /pages/admin/+config.js
         
                 import vikeVue from 'vike-vue/config'
                 // Should only apply to /pages/admin/**
                 export default { extends: [vikeVue] }
                 ```
                 ```js
-                // /pages/marketing/+config.h.js
+                // /pages/marketing/+config.js
         
                 import vikeReact from 'vike-react/config'
                 // Should only apply to /pages/marketing/**
@@ -117,6 +118,28 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
                 ```
                 */
                 const interfaceFile = getInterfaceFileFromConfigFile(extendsConfig, true, locationId);
+                {
+                    const alreadyMigrated = [
+                        'vike-react',
+                        'vike-react-query',
+                        'vike-react-zustand',
+                        'vike-vue',
+                        'vike-pinia',
+                        'vike-solid'
+                    ];
+                    const extensionName = extendsConfig.filePath.importPathAbsolute.split('/')[0];
+                    const warnMsg = alreadyMigrated.includes(extensionName)
+                        ? `You're using a deprecated version of the Vike extension ${extensionName}, update ${extensionName} to its latest version.`
+                        : `The config of the Vike extension ${extensionName} should set a ${pc.cyan('name')} value`;
+                    const isNameDefined = interfaceFile.fileExportsByConfigName.name?.configValue;
+                    if (alreadyMigrated) {
+                        // Eventually always make it a assertUsage()
+                        assertWarning(isNameDefined, warnMsg, { onlyOnce: true });
+                    }
+                    else {
+                        assertUsage(isNameDefined, warnMsg);
+                    }
+                }
                 interfaceFilesByLocationId[locationId].push(interfaceFile);
             });
         }),
@@ -184,12 +207,12 @@ function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
         });
     });
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig) {
+async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, tolerateInvalidConfig) {
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, outDirRoot, isDev, extensions);
+        ret = await loadVikeConfig(userRootDir, outDirRoot, isDev);
     }
     catch (err_) {
         hasError = true;
@@ -225,8 +248,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
         }
     }
 }
-async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions);
+async function loadVikeConfig(userRootDir, outDirRoot, isDev) {
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, isDev);
     const importedFilesLoaded = {};
     const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
@@ -401,7 +424,7 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
             // Make this value:
             //   /pages/some-page/+{configName}.js > `export default`
             // override that value:
-            //   /pages/some-page/+config.h.js > `export default { someConfig }`
+            //   /pages/some-page/+config.js > `export default { someConfig }`
             const interfaceFileWinner = interfaceValueFile ?? interfaceConfigFile;
             if (interfaceFileWinner) {
                 const interfaceFilesOverriden = [...interfaceValueFiles, ...interfaceConfigFiles].filter((f) => f !== interfaceFileWinner);
@@ -709,26 +732,9 @@ function getComputed(configValueSources, configDefinitions) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
+async function findPlusFiles(userRootDir, outDirRoot, isDev) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
     const plusFiles = files.map(({ filePathRelativeToUserRootDir }) => resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir, userRootDir));
-    // TODO/v1-release: remove
-    extensions.forEach((extension) => {
-        extension.pageConfigsDistFiles?.forEach((pageConfigDistFile) => {
-            if (!pageConfigDistFile.importPath.includes('+'))
-                return;
-            assert(pageConfigDistFile.importPath.includes('+'));
-            assert(path.posix.basename(pageConfigDistFile.importPath).startsWith('+'));
-            const { importPath, filePath } = pageConfigDistFile;
-            plusFiles.push({
-                filePathRelativeToUserRootDir: null,
-                filePathAbsoluteVite: importPath,
-                filePathAbsoluteFilesystem: filePath,
-                filePathToShowToUser: importPath,
-                importPathAbsolute: importPath
-            });
-        });
-    });
     return plusFiles;
 }
 function getConfigName(filePath) {

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

@@ -1,5 +1,5 @@
 export { setGlobalContext };
-import { setGlobalContext_viteDevServer, setGlobalContext_vitePreviewServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
+import { setGlobalContext_viteDevServer } from '../../runtime/globalContext.js';
 function setGlobalContext() {
     return {
         name: 'vike:setGlobalContext',
@@ -9,20 +9,6 @@ function setGlobalContext() {
             handler(viteDevServer) {
                 setGlobalContext_viteDevServer(viteDevServer);
             }
-        },
-        configurePreviewServer: {
-            order: 'pre',
-            handler(vitePreviewServer) {
-                setGlobalContext_vitePreviewServer(
-                // Type cast won't be necessary after https://github.com/vitejs/vite/pull/14119 is released in Vite 5
-                vitePreviewServer);
-            }
-        },
-        configResolved: {
-            order: 'pre',
-            handler(config) {
-                setGlobalContext_viteConfig(config);
-            }
         }
     };
 }

package/dist/esm/node/plugin/shared/rollupSourceMap.d.ts

@@ -0,0 +1,14 @@
+export { sourceMapRemove };
+export { sourceMapPassthrough };
+/** Remove entire source mapping, to save KBs. */
+declare function sourceMapRemove(code: string): {
+    code: string;
+    map: {
+        mappings: '';
+    };
+};
+/** Don't provide any source map, pass through current source map instead. */
+declare function sourceMapPassthrough(code: string): {
+    code: string;
+    map: null;
+};

package/dist/esm/node/plugin/shared/rollupSourceMap.js

@@ -0,0 +1,17 @@
+export { sourceMapRemove };
+export { sourceMapPassthrough };
+// https://rollupjs.org/guide/en/#source-code-transformations
+/** Remove entire source mapping, to save KBs. */
+function sourceMapRemove(code) {
+    return {
+        code,
+        map: { mappings: '' }
+    };
+}
+/** Don't provide any source map, pass through current source map instead. */
+function sourceMapPassthrough(code) {
+    return {
+        code,
+        map: null
+    };
+}

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

@@ -1,7 +1,6 @@
 export * from '../runtime/utils.js';
 export * from '../../utils/viteIsSSR.js';
 export * from '../../utils/getFilePathAbsolute.js';
-export * from '../../utils/getDependencyPackageJson.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';

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

@@ -7,7 +7,6 @@ export * from '../runtime/utils.js';
 // Utils only needed by `plugin/*`
 export * from '../../utils/viteIsSSR.js';
 export * from '../../utils/getFilePathAbsolute.js';
-export * from '../../utils/getDependencyPackageJson.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';

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

@@ -36,11 +36,11 @@ type PrerenderOptions = {
     root?: string;
     /** @deprecated Define `prerender({ viteConfig: { configFile }})` instead. */
     configFile?: string;
-    /** @deprecated Define `partial` in vite.config.js instead, see https://vike.dev/prerender-config */
+    /** @deprecated Define `partial` in vite.config.js instead, see https://vike.dev/prerender */
     partial?: boolean;
-    /** @deprecated Define `noExtraDir` in vite.config.js instead, see https://vike.dev/prerender-config */
+    /** @deprecated Define `noExtraDir` in vite.config.js instead, see https://vike.dev/prerender */
     noExtraDir?: boolean;
-    /** @deprecated Define `parallel` in vite.config.js instead, see https://vike.dev/prerender-config */
+    /** @deprecated Define `parallel` in vite.config.js instead, see https://vike.dev/prerender */
     parallel?: number;
     /** @deprecated */
     outDir?: string;

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

@@ -10,7 +10,7 @@ import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
-import { getGlobalContext, initGlobalContext } from '../runtime/globalContext.js';
+import { getGlobalContext, initGlobalContext, setGlobalContext_prerender } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
 import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
@@ -62,6 +62,7 @@ async function runPrerender(options, manuallyTriggered) {
     handleNodeEnv();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
+    setGlobalContext_prerender(viteConfig);
     assertLoadedConfig(viteConfig, options);
     const configVike = await getConfigVike(viteConfig);
     const { outDirClient, outDirRoot } = getOutDirs(viteConfig);
@@ -529,7 +530,7 @@ function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderCon
         .filter((pageId) => !isErrorPage(pageId, renderContext.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-config#partial) to suppress this warning.`, { onlyOnce: true });
+        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) {
@@ -645,7 +646,7 @@ function checkOutdatedOptions(options) {
     assertUsage(options.root === undefined, 'Option `prerender({ root })` deprecated: set `prerender({ viteConfig: { root }})` instead.', { showStackTrace: true });
     assertUsage(options.configFile === undefined, 'Option `prerender({ configFile })` deprecated: set `prerender({ viteConfig: { configFile }})` instead.', { showStackTrace: true });
     ['noExtraDir', 'partial', 'parallel'].forEach((prop) => {
-        assertUsage(options[prop] === undefined, `[prerender()] Option ${pc.cyan(prop)} is deprecated. Define ${pc.cyan(prop)} in vite.config.js instead. See https://vike.dev/prerender-config`, { showStackTrace: true });
+        assertUsage(options[prop] === undefined, `[prerender()] Option ${pc.cyan(prop)} is deprecated. Define ${pc.cyan(prop)} in vite.config.js instead. See https://vike.dev/prerender`, { showStackTrace: true });
     });
     ['base', 'outDir'].forEach((prop) => {
         assertWarning(options[prop] === undefined, `[prerender()] Option ${pc.cyan(prop)} is outdated and has no effect (vike now automatically determines ${pc.cyan(prop)})`, {

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

@@ -10,4 +10,4 @@ export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/nodeEnv.js';
+export * from '../../utils/assertNodeEnv.js';

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

@@ -12,4 +12,4 @@ export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/nodeEnv.js';
+export * from '../../utils/assertNodeEnv.js';