vike 0.4.161-commit-b829fee → 0.4.162

package/dist/cjs/utils/isScriptFile.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scriptFileExtensionList = exports.scriptFileExtensions = exports.isTemplateFile = exports.isScriptFile = void 0;
+exports.scriptFileExtensionList = exports.scriptFileExtensions = exports.isTemplateFile = exports.isJavaScriptFile = exports.isScriptFile = void 0;
 const assert_js_1 = require("./assert.js");
 // We can't use a RegExp:
 //  - Needs to work with Micromatch: https://github.com/micromatch/micromatch because:
@@ -12,6 +12,7 @@ const assert_js_1 = require("./assert.js");
 //     - We cannot implement a blacklist with a glob pattern.
 //     - A post `import.meta.glob()` blacklist filtering doesn't work because Vite would still process the files (e.g. including them in the bundle).
 // prettier-ignore
+// biome-ignore format:
 const extJavaScript = [
     'js',
     'ts',
@@ -19,6 +20,10 @@ const extJavaScript = [
     'cts',
     'mjs',
     'mts',
+];
+// prettier-ignore
+// biome-ignore format:
+const extJsx = [
     'jsx',
     'tsx',
     'cjsx',
@@ -27,6 +32,7 @@ const extJavaScript = [
     'mtsx',
 ];
 // prettier-ignore
+// biome-ignore format:
 const extTemplates = [
     'vue',
     'svelte',
@@ -34,19 +40,24 @@ const extTemplates = [
     'md',
     'mdx'
 ];
-const scriptFileExtensionList = [...extJavaScript, ...extTemplates];
+const scriptFileExtensionList = [...extJavaScript, ...extJsx, ...extTemplates];
 exports.scriptFileExtensionList = scriptFileExtensionList;
 const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
 exports.scriptFileExtensions = scriptFileExtensions;
 function isScriptFile(filePath) {
     const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
-    (0, assert_js_1.assert)(!isJavaScriptFile(filePath) || yes);
+    if (isJavaScriptFile(filePath))
+        (0, assert_js_1.assert)(yes);
     return yes;
 }
 exports.isScriptFile = isScriptFile;
 function isJavaScriptFile(filePath) {
-    return /\.(c|m)?(j|t)sx?$/.test(filePath);
+    const yes1 = /\.(c|m)?(j|t)s$/.test(filePath);
+    const yes2 = extJavaScript.some((ext) => filePath.endsWith('.' + ext));
+    (0, assert_js_1.assert)(yes1 === yes2);
+    return yes1;
 }
+exports.isJavaScriptFile = isJavaScriptFile;
 function isTemplateFile(filePath) {
     return extTemplates.some((ext) => filePath.endsWith('.' + ext));
 }

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.161-commit-b829fee';
+const PROJECT_VERSION = '0.4.162';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/__internal/index.js

@@ -2,7 +2,7 @@
 export { route, getPagesAndRoutes };
 import { route as routeInternal } from '../shared/route/index.js';
 import { getGlobalContext, initGlobalContext } from '../node/runtime/globalContext.js';
-import { setNodeEnvToProduction } from '../utils/nodeEnv.js';
+import { setNodeEnvToProduction } from '../utils/assertNodeEnv.js';
 import { assert } from '../utils/assert.js';
 import { getRenderContext } from '../node/runtime/renderPage/renderPageAlreadyRouted.js';
 /**

package/dist/esm/client/shared/loadUserFilesClientSide.js

@@ -12,6 +12,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
     const isDev = import.meta.env.DEV;
     try {
         // prettier-ignore
+        // biome-ignore format:
         const result = await Promise.all([
             pageConfig && loadConfigValues(pageConfig, isDev),
             ...pageFilesClientSide.map((p) => p.loadFile?.()),

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

@@ -19,7 +19,6 @@ import { suppressRollupWarning } from './plugins/suppressRollupWarning.js';
 import { setGlobalContext } from './plugins/setGlobalContext.js';
 import { importBuild } from './plugins/importBuild/index.js';
 import { commonConfig } from './plugins/commonConfig.js';
-import { extensionsAssets } from './plugins/extensionsAssets.js';
 import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
 import pc from '@brillout/picocolors';
@@ -44,7 +43,6 @@ function plugin(vikeConfig) {
         suppressRollupWarning(),
         setGlobalContext(),
         ...importBuild(),
-        extensionsAssets(),
         baseUrls(vikeConfig),
         envVarsPlugin(),
         fileEnv()

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

@@ -228,6 +228,7 @@ function addLogHook() {
     });
     // Exhaustive list extracted from writeLine() calls at https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts
     // prettier-ignore
+    // biome-ignore format:
     const viteTransientLogs = [
         'transforming (',
         'rendering chunks (',

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

@@ -1,9 +1,7 @@
 export { resolveVikeConfig };
 import { assertVikeConfig } from './assertVikeConfig.js';
 import { isDev2 } from '../../utils.js';
-import { findConfigVikeFromStemPackages } from './findConfigVikeFromStemPackages.js';
 import { pickFirst } from './pickFirst.js';
-import { resolveExtensions } from './resolveExtensions.js';
 import { resolveBase } from './resolveBase.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
@@ -21,10 +19,8 @@ function resolveVikeConfig(vikeConfig) {
 async function getConfigVikPromise(vikeConfig, config) {
     const fromPluginOptions = (vikeConfig ?? {});
     const fromViteConfig = (config.vike ?? {});
-    const fromStemPackages = await findConfigVikeFromStemPackages(config.root);
-    const configs = [fromPluginOptions, ...fromStemPackages, fromViteConfig];
-    const extensions = resolveExtensions(configs, config);
-    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config, isDev2(config), false, extensions);
+    const configs = [fromPluginOptions, fromViteConfig];
+    const { globalVikeConfig: fromPlusConfigFile } = await getVikeConfig(config, isDev2(config), false);
     configs.push(fromPlusConfigFile);
     assertVikeConfig(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?
@@ -36,7 +32,6 @@ async function getConfigVikPromise(vikeConfig, config) {
     const { baseServer, baseAssets } = resolveBase(configs, config);
     const configVike = {
         disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
-        extensions,
         prerender: resolvePrerenderOptions(configs),
         includeAssetsImportedByServer: pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
         baseServer,

package/dist/esm/node/plugin/plugins/devConfig/determineFsAllowList.d.ts

@@ -1,4 +1,3 @@
 export { determineFsAllowList };
 import type { ResolvedConfig } from 'vite';
-import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
-declare function determineFsAllowList(config: ResolvedConfig, configVike: ConfigVikeResolved): Promise<void>;
+declare function determineFsAllowList(config: ResolvedConfig): Promise<void>;

package/dist/esm/node/plugin/plugins/devConfig/determineFsAllowList.js

@@ -1,7 +1,6 @@
 export { determineFsAllowList };
 import { searchForWorkspaceRoot } from 'vite';
 import path from 'path';
-import fs from 'fs';
 import { assert } from '../../utils.js';
 import { createRequire } from 'module';
 import { dirname } from 'path';
@@ -10,7 +9,7 @@ import { fileURLToPath } from 'url';
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const __dirname_ = dirname(fileURLToPath(importMetaUrl));
-async function determineFsAllowList(config, configVike) {
+async function determineFsAllowList(config) {
     const fsAllow = config.server.fs.allow;
     // fsAllow should already contain searchForWorkspaceRoot()
     assert(fsAllow.length >= 1);
@@ -27,10 +26,4 @@ async function determineFsAllowList(config, configVike) {
         require_.resolve(`${vikeRoot}/dist/esm/node/plugin/plugins/devConfig/index.js`);
         fsAllow.push(vikeRoot);
     }
-    // Add Vike extensions, e.g. node_modules/stem-react/
-    configVike.extensions.forEach(({ npmPackageRootDir }) => {
-        const npmPackageRootDirReal = fs.realpathSync(npmPackageRootDir);
-        fsAllow.push(npmPackageRootDir);
-        fsAllow.push(npmPackageRootDirReal);
-    });
 }

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.d.ts

@@ -1,4 +1,3 @@
 export { determineOptimizeDeps };
 import type { ResolvedConfig } from 'vite';
-import { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
-declare function determineOptimizeDeps(config: ResolvedConfig, configVike: ConfigVikeResolved, isDev: true): Promise<void>;
+declare function determineOptimizeDeps(config: ResolvedConfig, isDev: true): Promise<void>;

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -1,11 +1,11 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, getFilePathAbsolute, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
+import { assert, getFilePathAbsolute, isNpmPackageImport, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValueSourcesNotOverriden } from '../../shared/getConfigValueSourcesNotOverriden.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-async function determineOptimizeDeps(config, configVike, isDev) {
+async function determineOptimizeDeps(config, isDev) {
     const { pageConfigs } = await getVikeConfig(config, isDev);
     const { entries, include } = await getPageDeps(config, pageConfigs, isDev);
     {
@@ -16,7 +16,6 @@ async function determineOptimizeDeps(config, configVike, isDev) {
         const entriesVirtualFiles = getVirtualFiles(config, pageConfigs);
         entries.push(...entriesVirtualFiles);
     }
-    include.push(...getExtensionsDeps(configVike));
     /* Other Vite plugins may populate optimizeDeps, e.g. Cypress: https://github.com/vikejs/vike/issues/386
     assert(config.optimizeDeps.entries === undefined)
     */
@@ -88,22 +87,6 @@ function getVirtualFiles(config, pageConfigs) {
         entriesVirtualFiles.push(virtualFileIdImportUserCodeClientSR);
     return entriesVirtualFiles;
 }
-function getExtensionsDeps(configVike) {
-    return [
-        /* Doesn't work since `pageConfigsSrcDir` is a directory. We could make it work by using find-glob.
-        ...configVike.extensions
-          .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
-          .flat()
-          .filter(isNotNullish),
-        //*/
-        ...configVike.extensions
-            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-            .flat()
-            .filter(isNotNullish)
-            .filter(({ importPath }) => !importPath.endsWith('.css'))
-            .map(({ importPath }) => importPath)
-    ];
-}
 function normalizeEntries(entries) {
     if (Array.isArray(entries))
         return entries;

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

@@ -1,7 +1,6 @@
 export { devConfig };
 import { determineOptimizeDeps } from './determineOptimizeDeps.js';
 import { determineFsAllowList } from './determineFsAllowList.js';
-import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { addSsrMiddleware } from '../../shared/addSsrMiddleware.js';
 import { markEnvAsViteDev } from '../../utils.js';
 import { improveViteLogs } from '../../shared/loggerVite.js';
@@ -55,9 +54,8 @@ function devConfig() {
             },
             async configResolved(config_) {
                 config = config_;
-                const configVike = await getConfigVike(config);
-                await determineOptimizeDeps(config, configVike, isDev);
-                await determineFsAllowList(config, configVike);
+                await determineOptimizeDeps(config, isDev);
+                await determineFsAllowList(config);
                 if (!isErrorDebug()) {
                     await installHttpRequestAsyncStore();
                     improveViteLogs(config);

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

@@ -101,25 +101,6 @@ function extractAssetsPlugin() {
                 if (!isScriptFile(file)) {
                     return emptyModule(file, importer);
                 }
-                // If the dependency is a Vike extension and has `configVike.extension[number].pageConfigsSrcDir`, then include its CSS
-                if (configVike.extensions
-                    .filter(({ pageConfigsSrcDir }) => pageConfigsSrcDir !== null)
-                    .some(({ npmPackageName }) => {
-                    const check1 = source === npmPackageName ||
-                        source.startsWith(npmPackageName + '/') ||
-                        // Include relative imports within modules of `npmPackageName`. (This only works for dependencies: user may use import path aliases.)
-                        source.startsWith('.');
-                    // This doesn't work for linked dependencies
-                    const check2 = file.includes('node_modules/' + npmPackageName + '/') ||
-                        file.includes('node_modules\\' + npmPackageName + '\\');
-                    if (check1) {
-                        return true;
-                    }
-                    assert(!check2);
-                    return false;
-                })) {
-                    return appendExtractAssetsQuery(file, importer);
-                }
                 // If the import path resolves to a file in `node_modules/`, we ignore that file:
                 //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
                 //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is non-standard; we can safely not support this case. (I'm not aware of any library that does this.)

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

@@ -33,7 +33,7 @@ function importUserCode() {
         },
         handleHotUpdate(ctx) {
             try {
-                return handleHotUpdate(ctx, config, configVike);
+                return handleHotUpdate(ctx, config);
             }
             catch (err) {
                 // Vite swallows errors thrown by handleHotUpdate()
@@ -57,11 +57,11 @@ function importUserCode() {
         },
         configureServer(server) {
             isDev1_onConfigureServer();
-            handleFileAddRemove(server, config, configVike);
+            handleFileAddRemove(server, config);
         }
     };
 }
-function handleFileAddRemove(server, config, configVike) {
+function handleFileAddRemove(server, config) {
     server.watcher.prependListener('add', (f) => listener(f, false));
     server.watcher.prependListener('unlink', (f) => listener(f, true));
     return;
@@ -73,11 +73,11 @@ function handleFileAddRemove(server, config, configVike) {
             virtualModules.forEach((mod) => {
                 server.moduleGraph.invalidateModule(mod);
             });
-            reloadConfig(file, config, configVike, isRemove ? 'removed' : 'created');
+            reloadConfig(file, config, isRemove ? 'removed' : 'created');
         }
     }
 }
-function handleHotUpdate(ctx, config, configVike) {
+function handleHotUpdate(ctx, config) {
     const { file, server } = ctx;
     assertPosixPath(file);
     vikeConfigDependencies.forEach((f) => assertPosixPath(f));
@@ -108,7 +108,7 @@ function handleHotUpdate(ctx, config, configVike) {
         /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
         assert(!isViteModule)
         */
-        reloadConfig(file, config, configVike, 'modified');
+        reloadConfig(file, config, 'modified');
         const virtualModules = getVirtualModules(server);
         return virtualModules;
     }
@@ -116,13 +116,13 @@ function handleHotUpdate(ctx, config, configVike) {
 function isVikeConfigModule(filePathAbsoluteFilesystem) {
     return vikeConfigDependencies.has(filePathAbsoluteFilesystem);
 }
-function reloadConfig(filePath, config, configVike, op) {
+function reloadConfig(filePath, config, op) {
     {
         const filePathToShowToUser = pc.dim(getFilePathRelativeToUserRootDir(filePath, config.root, true));
         const msg = `${op} ${filePathToShowToUser}`;
         logConfigInfo(msg, 'info');
     }
-    reloadVikeConfig(config.root, getOutDirs(config).outDirRoot, configVike.extensions);
+    reloadVikeConfig(config.root, getOutDirs(config).outDirRoot);
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())

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

@@ -60,15 +60,7 @@ function getConfigValueSerialized(value, configName, definedAt) {
         */
         const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
         assert(configValueFilePathToShowToUser);
-        assertUsage(false, [
-            `The code of ${pc.cyan(configName)} cannot live inside ${configValueFilePathToShowToUser},`,
-            'see https://vike.dev/header-file#runtime-code'
-            /* I guess showing this is more confusing than adding value.
-            `(technically speaking: the value of ${pc.cyan(
-              configName
-            )} isn't serializable (${serializationErrMsg}) and it's therefore runtime code that needs to be imported).`
-            //*/
-        ].join(' '));
+        assertUsage(false, `${pc.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
     }
     configValueSerialized = JSON.stringify(configValueSerialized);
     return configValueSerialized;

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

@@ -88,6 +88,9 @@ const configDefinitionsBuiltIn = {
     },
     cacheControl: {
         env: { server: true }
+    },
+    name: {
+        env: { config: true }
     }
 };
 const configDefinitionsBuiltInGlobal = {

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

@@ -13,18 +13,18 @@ export { getLogicalPath };
  * Each config value is assigned with a `locationId` value. That's the source-of-truth for determining inheritance between config values.
  *
  * For Vike extensions, `locationId` is different than the config value's `definedAt`, for example the `onRenderHtml()` hook of `vike-react`:
- *  - `locationId === '/pages'` (the directory of `/pages/+config.h.js` which extends `vike-react`)
+ *  - `locationId === '/pages'` (the directory of `/pages/+config.js` which extends `vike-react`)
  *  - `definedAt.filePathAbsoluteFilesystem === '/home/rom/code/my-vike-app/node_modules/vike-react/dist/renderer/onRenderHtml.js'` (the file where the value is defined)
  *
  *  This is an important distinction 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/**
  *  export default { extends: [vikeReact] }

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

@@ -15,7 +15,7 @@ import { assert, assertPosixPath, higherFirst } from '../../../../utils.js';
  * The value `locationId` is always a user-land path, because Filesystem Routing/Inheritance only applies to the user-land (Vike never uses Filesystem Routing/Inheritance for `node_modules/**`).
  */
 function getLocationId(
-// We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.h.js` that extends the Vike extension.
+// We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.js` that extends the Vike extension.
 filePathRelativeToUserRootDir) {
     assertPosixPath(filePathRelativeToUserRootDir);
     assert(filePathRelativeToUserRootDir.startsWith('/'));

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

@@ -15,7 +15,7 @@ declare function loadImportedFile(import_: FilePathResolved & {
     fileExportName: string;
 }, userRootDir: string, importedFilesLoaded: ImportedFilesLoaded): Promise<unknown>;
 declare function loadValueFile(interfaceValueFile: InterfaceValueFile, configName: string, userRootDir: string): Promise<void>;
-declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isConfigOfExtension: boolean): Promise<{
+declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isExtensionConfig: boolean): Promise<{
     configFile: ConfigFile;
     extendsConfigs: ConfigFile[];
 }>;

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

@@ -14,7 +14,7 @@ assertIsNotProductionRuntime();
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
     const f = import_.filePathAbsoluteFilesystem;
     if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = transpileAndExecuteFile(import_, false, userRootDir).then((r) => r.fileExports);
+        importedFilesLoaded[f] = transpileAndExecuteFile(import_, userRootDir, false).then((r) => r.fileExports);
     }
     const fileExports = await importedFilesLoaded[f];
     const fileExport = fileExports[import_.fileExportName];
@@ -22,7 +22,7 @@ async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
 }
 // Load +{configName}.js
 async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, false, userRootDir);
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -31,10 +31,10 @@ async function loadValueFile(interfaceValueFile, configName, userRootDir) {
     });
 }
 // Load +config.js, including all its extends fake imports
-async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
+async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, !isConfigOfExtension, userRootDir, isConfigOfExtension);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
         filePathAbsoluteFilesystem

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

@@ -115,7 +115,7 @@ function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
         assertUsage(false, [
             `${filePathForEnvCheck} defines the value of configs living in different environments:`,
             ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.cyan(JSON.stringify(c.configEnv))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file'
+            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports'
         ].join('\n'));
     }
 }

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

@@ -1,20 +1,8 @@
 export { transformFileImports };
 export { parseImportData };
 export { isImportData };
-export type { FileImport };
 export type { ImportData };
-type FileImport = {
-    importStatementCode: string;
-    importString: string;
-    importLocalName: string;
-};
-declare function transformFileImports(code: string, filePathToShowToUser2: string, skipWarnings?: true): {
-    noTransformation: true;
-} | {
-    noTransformation: false;
-    code: string;
-    fileImportsTransformed: FileImport[];
-};
+declare function transformFileImports(code: string, filePathToShowToUser2: string, pointerImports: 'all' | Record<string, boolean>, skipWarnings?: true): string | null;
 /**
  * Data Structure holding info about import statement:
  *   `import { someExport as someImport } from './some-file'`

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;