vike 0.4.161-commit-b829fee → 0.4.162-commit-49fe40c

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

@@ -2,52 +2,55 @@ export { transformFileImports };
 export { parseImportData };
 export { isImportData };
 // Playground: https://github.com/brillout/acorn-playground
-// Import attributes support: https://github.com/acornjs/acorn/issues/983
-//  - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
+// Notes about `with { type: 'pointer' }`
+// - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
+// - Acorn support for import attributes: https://github.com/acornjs/acorn/issues/983
+//   - Acorn plugin: https://github.com/acornjs/acorn/issues/983
+//   - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
+// - Using a import path suffix such as `import { Layout } from './Layout?real` breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
+// - Node.js >=21 supports import attribtues: https://nodejs.org/api/esm.html#import-attributes
+// - Esbuid supports
+//   - Blocker: https://github.com/evanw/esbuild/issues/3646
+//     - Ugly hack to make it work: https://github.com/brillout/esbuild-playground/tree/experiment/import-attribute
+//   - Discussion with esbuild maintainer: https://github.com/evanw/esbuild/issues/3384
+// - Using a magic comment `// @vike-real-import` is probably a bad idea:
+//   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
+//   - Using source maps to track these magic comments is brittle (source maps can easily break)
 import { parse } from 'acorn';
 import { assert, assertUsage, assertWarning, styleFileRE } from '../../../../utils.js';
 import pc from '@brillout/picocolors';
-function transformFileImports(code, filePathToShowToUser2, 
+// TODO: rename transformFileImports() => transformPointerImports()
+function transformFileImports(code, filePathToShowToUser2, pointerImports, 
 // For ./transformFileImports.spec.ts
 skipWarnings) {
     const spliceOperations = [];
-    const fileImportsTransformed = [];
     // Performance trick
     if (!code.includes('import'))
-        return { noTransformation: true };
+        return null;
     const imports = getImports(code);
     if (imports.length === 0)
-        return { noTransformation: true };
+        return null;
     imports.forEach((node) => {
         if (node.type !== 'ImportDeclaration')
             return;
         const importPath = node.source.value;
         assert(typeof importPath === 'string');
-        // - This doesn't work. To make it work we would need to run esbuild twice: esbuild for TypeScript to JavaScript => transformFileImports() => esbuild for bundling.
-        //   - Or we use an esbuild plugin to apply transformFileImports(). Maybe we can completely skip the need for acorn?
-        // - ?real breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
-        // - Import attributes would be the best.
-        //   - But it only works with Node.js >=21: https://nodejs.org/api/esm.html#import-attributes
-        //     - But it's probably ok to tell users "to use real imports you need Node.js 21 or above".
-        //   - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
-        //   - Esbuid seems to support it: https://esbuild.github.io/plugins/#on-load-arguments:~:text=This%20contains%20a%20map%20of%20the%20import%20attributes%20that
-        //   - acorn supports it over an acorn plugin: https://github.com/acornjs/acorn/issues/983
-        //     - Maybe we can use an esbuild plugin instead of acorn to apply transformFileImports()?
-        // - Using a magic comment `// @vike-real-import` is tricky:
-        //   - Esbuild removes comments: https://github.com/evanw/esbuild/issues/1439#issuecomment-877656182
-        //   - Using source maps to track these magic comments is brittle (source maps can easily break)
-        if (importPath.endsWith('?real')) {
-            const { start, end } = node.source;
-            spliceOperations.push({
-                start,
-                end,
-                replacement: importPath.slice(0, -1 * '?real'.length)
-            });
-            return;
+        if (pointerImports !== 'all') {
+            assert(importPath in pointerImports);
+            const isPointerImport = pointerImports[importPath];
+            assert(isPointerImport === true || isPointerImport === false);
+            if (!isPointerImport)
+                return;
         }
         const { start, end } = node;
         const importStatementCode = code.slice(start, end);
-        // No variable imported
+        /* Pointer import without importing any value => doesn't make sense and doesn't have any effect.
+        ```js
+        // Useless
+        import './some.css'
+        // Useless
+        import './Layout.jsx'
+        ``` */
         if (node.specifiers.length === 0) {
             const isWarning = !styleFileRE.test(importPath);
             let quote = indent(importStatementCode);
@@ -58,8 +61,9 @@ skipWarnings) {
                 quote = pc.bold(pc.red(quote));
             }
             const errMsg = [
-                `As explained in https://vike.dev/header-file the following import in ${filePathToShowToUser2} has no effect:`,
-                quote
+                `The following import in ${filePathToShowToUser2} has no effect:`,
+                quote,
+                'See https://vike.dev/config#pointer-imports'
             ].join('\n');
             if (!skipWarnings) {
                 if (!isWarning) {
@@ -88,11 +92,6 @@ skipWarnings) {
             })();
             const importString = serializeImportData({ importPath, exportName, importStringWasGenerated: true });
             replacement += `const ${importLocalName} = '${importString}';`;
-            fileImportsTransformed.push({
-                importStatementCode,
-                importString,
-                importLocalName
-            });
         });
         spliceOperations.push({
             start,
@@ -101,7 +100,7 @@ skipWarnings) {
         });
     });
     const codeMod = spliceMany(code, spliceOperations);
-    return { code: codeMod, fileImportsTransformed, noTransformation: false };
+    return codeMod;
 }
 function getImports(code) {
     const { body } = parse(code, {

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

@@ -4,7 +4,7 @@ export { getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import 'source-map-support/register.js';
 import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
-declare function transpileAndExecuteFile(filePath: FilePathResolved, transformImports: boolean, userRootDir: string, doNotTranspile?: boolean): Promise<{
+declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isConfigFile: boolean | 'is-extension-config'): Promise<{
     fileExports: Record<string, unknown>;
 }>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;

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

@@ -6,7 +6,6 @@ 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 = {
@@ -28,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,11 +62,11 @@ 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;
 }
@@ -77,8 +76,8 @@ async function isV1Design(config, isDev) {
     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) => {
@@ -104,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/**
@@ -119,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);
             });
         }),
@@ -186,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;
@@ -227,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)
@@ -403,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);
@@ -711,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/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

@@ -530,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) {
@@ -646,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)})`, {