vike 0.4.160 → 0.4.161

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

@@ -44,11 +44,7 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
         p = toPosixPath(p);
         assert(!p.startsWith(userRootDir));
         const filePathRelativeToUserRootDir = path.posix.join('/', p);
-        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
-        return {
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteFilesystem
-        };
+        return { filePathRelativeToUserRootDir };
     });
     return plusFiles;
 }

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

@@ -5,26 +5,53 @@ export { getLocationId };
 export { sortAfterInheritanceOrder };
 export { isGlobalLocation };
 export { applyFilesystemRoutingRootEffect };
+export type { LocationId };
 export { getLogicalPath };
 /**
- * getLocationId('/pages/some-page/+Page.js') => '/pages/some-page'
- * getLocationId('/pages/some-page') => '/pages/some-page'
- * getLocationId('/renderer/+config.js') => '/renderer'
+ * The `locationId` value is used for filesystem inheritance.
+ *
+ * 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`)
+ *  - `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
+ *  import vikeVue from 'vike-vue/config'
+ *  // Should only apply to /pages/admin/**
+ *  export default { extends: [vikeVue] }
+ *  ```
+ *  ```js
+ *  // /pages/marketing/+config.h.js
+ *  import vikeReact from 'vike-react/config'
+ *  // Should only apply to /pages/marketing/**
+ *  export default { extends: [vikeReact] }
+ *  ```
  */
-declare function getLocationId(filePathAbsoluteVite: string): string;
-/** Get URL determined by filesystem path */
-declare function getFilesystemRouteString(locationId: string): string;
+type LocationId = string & {
+    __brand: 'LocationId';
+};
+/**
+ * `getLocationId('/pages/some-page/+Page.js')` => `'/pages/some-page'`
+ * `getLocationId('/renderer/+config.js')` => `'/renderer'`
+ *
+ * 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/**`).
+ */
+declare function getLocationId(filePathRelativeToUserRootDir: string): LocationId;
+/** Filesystem Routing: get the URL */
+declare function getFilesystemRouteString(locationId: LocationId): string;
 /**
  * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
- * getLogicalPath('some-npm-pkg/renderer', ['renderer']) => '/'
  */
-declare function getLogicalPath(someDir: string, removeDirs: string[]): string;
+declare function getLogicalPath(locationId: LocationId, removeDirs: string[]): string;
 /** Whether configs defined in `locationId` apply in every `locationIds` */
-declare function isGlobalLocation(locationId: string, locationIds: string[]): boolean;
-declare function sortAfterInheritanceOrder(locationId1: string, locationId2: string, locationIdPage: string): -1 | 1 | 0;
+declare function isGlobalLocation(locationId: LocationId, locationIds: LocationId[]): boolean;
+declare function sortAfterInheritanceOrder(locationId1: LocationId, locationId2: LocationId, locationIdPage: LocationId): -1 | 1 | 0;
 /** Whether configs defined at `locationId1` also apply at `locationId2` */
-declare function isInherited(locationId1: string, locationId2: string): boolean;
-declare function getFilesystemRouteDefinedBy(locationId: string): string;
+declare function isInherited(locationId1: LocationId, locationId2: LocationId): boolean;
+declare function getFilesystemRouteDefinedBy(locationId: LocationId): string;
 declare function applyFilesystemRoutingRootEffect(routeFilesystem: string, filesystemRoutingRootEffect: {
     before: string;
     after: string;

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

@@ -7,40 +7,47 @@ export { isGlobalLocation };
 export { applyFilesystemRoutingRootEffect };
 // For ./filesystemRouting.spec.ts
 export { getLogicalPath };
-import { assert, assertPosixPath, getNpmPackageImportPath, isNpmPackageImport, higherFirst } from '../../../../utils.js';
+import { assert, assertPosixPath, higherFirst } from '../../../../utils.js';
 /**
- * getLocationId('/pages/some-page/+Page.js') => '/pages/some-page'
- * getLocationId('/pages/some-page') => '/pages/some-page'
- * getLocationId('/renderer/+config.js') => '/renderer'
+ * `getLocationId('/pages/some-page/+Page.js')` => `'/pages/some-page'`
+ * `getLocationId('/renderer/+config.js')` => `'/renderer'`
+ *
+ * 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(filePathAbsoluteVite) {
-    const locationId = removeFilename(filePathAbsoluteVite, true);
+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.
+filePathRelativeToUserRootDir) {
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assert(filePathRelativeToUserRootDir.startsWith('/'));
+    const locationId = removeFilename(filePathRelativeToUserRootDir);
     assertLocationId(locationId);
     return locationId;
 }
-/** Get URL determined by filesystem path */
+/** Filesystem Routing: get the URL */
 function getFilesystemRouteString(locationId) {
     return getLogicalPath(locationId, ['renderer', 'pages', 'src', 'index']);
 }
-/** Get apply root for config inheritance */
-function getInheritanceRoot(someDir) {
-    return getLogicalPath(someDir, ['renderer']);
+/** Filesystem Inheritance: get the apply root */
+function getInheritanceRoot(locationId) {
+    return getLogicalPath(locationId, ['renderer']);
 }
 /**
  * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
- * getLogicalPath('some-npm-pkg/renderer', ['renderer']) => '/'
  */
-function getLogicalPath(someDir, removeDirs) {
-    someDir = removeNpmPackageName(someDir);
-    someDir = removeDirectories(someDir, removeDirs);
-    assertIsPath(someDir);
-    return someDir;
+function getLogicalPath(locationId, removeDirs) {
+    let logicalPath = removeDirectories(locationId, removeDirs);
+    assertIsPath(logicalPath);
+    return logicalPath;
 }
 /** Whether configs defined in `locationId` apply in every `locationIds` */
 function isGlobalLocation(locationId, locationIds) {
     return locationIds.every((locId) => isInherited(locationId, locId) || locationIsRendererDir(locId));
 }
 function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
+    assertLocationId(locationId1);
+    assertLocationId(locationId2);
+    if (locationId1 === locationId2)
+        return 0;
     const inheritanceRoot1 = getInheritanceRoot(locationId1);
     const inheritanceRoot2 = getInheritanceRoot(locationId2);
     const inheritanceRootPage = getInheritanceRoot(locationIdPage);
@@ -56,15 +63,10 @@ function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
         assert(inheritanceRoot1.length !== inheritanceRoot2.length);
         return higherFirst((inheritanceRoot) => inheritanceRoot.length)(inheritanceRoot1, inheritanceRoot2);
     }
-    // Should be true since we aggregate interface files by locationId
-    assert(locationId1 !== locationId2);
     // locationId1 first, i.e. `indexOf(locationId1) < indexOf(locationId2)`
     const locationId1First = -1;
     // locationId2 first, i.e. `indexOf(locationId2) < indexOf(locationId1)`
     const locationId2First = 1;
-    if (locationIsNpmPackage(locationId1) !== locationIsNpmPackage(locationId2)) {
-        return locationIsNpmPackage(locationId1) ? locationId2First : locationId1First;
-    }
     if (locationIsRendererDir(locationId1) !== locationIsRendererDir(locationId2)) {
         return locationIsRendererDir(locationId1) ? locationId2First : locationId1First;
     }
@@ -75,9 +77,6 @@ function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
     }
     return locationId1 > locationId2 ? locationId1First : locationId2First;
 }
-function locationIsNpmPackage(locationId) {
-    return !locationId.startsWith('/');
-}
 function locationIsRendererDir(locationId) {
     return locationId.split('/').includes('renderer');
 }
@@ -87,19 +86,6 @@ function isInherited(locationId1, locationId2) {
     const inheritanceRoot2 = getInheritanceRoot(locationId2);
     return startsWith(inheritanceRoot2, inheritanceRoot1);
 }
-function removeNpmPackageName(somePath) {
-    if (!isNpmPackageImport(somePath)) {
-        assert(somePath.startsWith('/'));
-        return somePath;
-    }
-    const importPath = getNpmPackageImportPath(somePath);
-    if (!importPath)
-        return '/';
-    assertPosixPath(importPath);
-    assert(!importPath.startsWith('/'));
-    somePath = '/' + importPath;
-    return somePath;
-}
 function removeDirectories(somePath, removeDirs) {
     assertPosixPath(somePath);
     somePath = somePath
@@ -110,17 +96,13 @@ function removeDirectories(somePath, removeDirs) {
         somePath = '/';
     return somePath;
 }
-function removeFilename(filePathAbsoluteVite, optional) {
-    assertPosixPath(filePathAbsoluteVite);
-    assert(filePathAbsoluteVite.startsWith('/') || isNpmPackageImport(filePathAbsoluteVite));
+function removeFilename(filePathRelativeToUserRootDir) {
+    const filePathParts = filePathRelativeToUserRootDir.split('/');
     {
-        const filename = filePathAbsoluteVite.split('/').slice(-1)[0];
-        if (!filename.includes('.')) {
-            assert(optional);
-            return filePathAbsoluteVite;
-        }
+        const filename = filePathParts.slice(-1)[0];
+        assert(filename.includes('.'));
     }
-    let locationId = filePathAbsoluteVite.split('/').slice(0, -1).join('/');
+    let locationId = filePathParts.slice(0, -1).join('/');
     if (locationId === '')
         locationId = '/';
     assertLocationId(locationId);
@@ -142,7 +124,7 @@ function applyFilesystemRoutingRootEffect(routeFilesystem, filesystemRoutingRoot
     return routeFilesystem;
 }
 function assertLocationId(locationId) {
-    assert(locationId.startsWith('/') || isNpmPackageImport(locationId));
+    assert(locationId.startsWith('/'));
     assert(!locationId.endsWith('/') || locationId === '/');
 }
 function assertIsPath(logicalPath) {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/{loadFileConfigEnv.js → loadFileAtConfigTime.js}

@@ -6,7 +6,7 @@ import { assertPosixPath, assert, assertUsage, assertWarning, hasProp, assertIsN
 import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
-import { parseImportData } from './transformImports.js';
+import { parseImportData } from './transformFileImports.js';
 import { getConfigFileExport } from '../getConfigFileExport.js';
 import { assertImportPath, resolveImportPath } from './resolveImportPath.js';
 assertIsNotProductionRuntime();
@@ -14,7 +14,7 @@ assertIsNotProductionRuntime();
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
     const f = import_.filePathAbsoluteFilesystem;
     if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = transpileAndExecuteFile(import_, true, userRootDir).then((r) => r.fileExports);
+        importedFilesLoaded[f] = transpileAndExecuteFile(import_, false, userRootDir).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, true, userRootDir);
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, false, userRootDir);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
@@ -34,7 +34,7 @@ async function loadValueFile(interfaceValueFile, configName, userRootDir) {
 async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, false, userRootDir, isConfigOfExtension);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, !isConfigOfExtension, userRootDir, isConfigOfExtension);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
         ...visited,
         filePathAbsoluteFilesystem

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

@@ -0,0 +1,5 @@
+export { resolveFilePathRelativeToUserRootDir };
+export { resolveFilePathAbsoluteFilesystem };
+import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+declare function resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir: string, userRootDir: string): FilePathResolved;
+declare function resolveFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem: string, userRootDir: string): FilePathResolved;

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

@@ -0,0 +1,27 @@
+export { resolveFilePathRelativeToUserRootDir };
+export { resolveFilePathAbsoluteFilesystem };
+import path from 'path';
+import { assert, assertPosixPath } from '../../../../utils.js';
+function resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir, userRootDir) {
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assertPosixPath(userRootDir);
+    const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelativeToUserRootDir);
+    return getFilePathResolved(filePathRelativeToUserRootDir, filePathAbsoluteFilesystem);
+}
+function resolveFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem, userRootDir) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    assertPosixPath(userRootDir);
+    let filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    assert(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'));
+    filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
+    return getFilePathResolved(filePathRelativeToUserRootDir, filePathAbsoluteFilesystem);
+}
+function getFilePathResolved(filePathRelativeToUserRootDir, filePathAbsoluteFilesystem) {
+    return {
+        filePathRelativeToUserRootDir,
+        filePathAbsoluteVite: filePathRelativeToUserRootDir,
+        filePathAbsoluteFilesystem,
+        filePathToShowToUser: filePathRelativeToUserRootDir,
+        importPathAbsolute: null
+    };
+}

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

@@ -3,7 +3,7 @@ export { resolveImportPath };
 export { assertImportPath };
 export { clearFilesEnvMap };
 import type { ConfigEnvInternal, DefinedAtFileFullInfo, FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
-import { type ImportData } from './transformImports.js';
+import { type ImportData } from './transformFileImports.js';
 declare function resolveImport(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | (DefinedAtFileFullInfo & {
     fileExportName: string;
 });

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

@@ -4,7 +4,7 @@ export { assertImportPath };
 export { clearFilesEnvMap };
 import pc from '@brillout/picocolors';
 import { assert, assertPosixPath, assertUsage, deepEqual, requireResolve } from '../../../../utils.js';
-import { parseImportData } from './transformImports.js';
+import { parseImportData } from './transformFileImports.js';
 import path from 'path';
 const filesEnvMap = new Map();
 function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {

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

@@ -1,4 +1,4 @@
-export { transformImports };
+export { transformFileImports };
 export { parseImportData };
 export { isImportData };
 export type { FileImport };
@@ -8,7 +8,7 @@ type FileImport = {
     importString: string;
     importLocalName: string;
 };
-declare function transformImports(code: string, filePathToShowToUser2: string, skipWarnings?: true): {
+declare function transformFileImports(code: string, filePathToShowToUser2: string, skipWarnings?: true): {
     noTransformation: true;
 } | {
     noTransformation: false;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/{transformImports.js → transformFileImports.js}

@@ -1,4 +1,4 @@
-export { transformImports };
+export { transformFileImports };
 export { parseImportData };
 export { isImportData };
 // Playground: https://github.com/brillout/acorn-playground
@@ -7,8 +7,8 @@ export { isImportData };
 import { parse } from 'acorn';
 import { assert, assertUsage, assertWarning, styleFileRE } from '../../../../utils.js';
 import pc from '@brillout/picocolors';
-function transformImports(code, filePathToShowToUser2, 
-// For ./transformImports.spec.ts
+function transformFileImports(code, filePathToShowToUser2, 
+// For ./transformFileImports.spec.ts
 skipWarnings) {
     const spliceOperations = [];
     const fileImportsTransformed = [];
@@ -23,8 +23,8 @@ skipWarnings) {
             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 => transformImports() => esbuild for bundling.
-        //   - Or we use an esbuild plugin to apply transformImports(). Maybe we can completely skip the need for acorn?
+        // - 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
@@ -32,7 +32,7 @@ skipWarnings) {
         //   - 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 transformImports()?
+        //     - 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)

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, isValueFile: boolean, userRootDir: string, isConfigOfExtension?: boolean): Promise<{
+declare function transpileAndExecuteFile(filePath: FilePathResolved, transformImports: boolean, userRootDir: string, doNotTranspile?: boolean): Promise<{
     fileExports: Record<string, unknown>;
 }>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;

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

@@ -8,13 +8,14 @@ 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, transformImports } from './transformImports.js';
+import { isImportData, 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, isValueFile, userRootDir, isConfigOfExtension = false) {
-    if (isConfigOfExtension) {
+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);
@@ -23,21 +24,20 @@ async function transpileAndExecuteFile(filePath, isValueFile, userRootDir, isCon
         return { fileExports };
     }
     else {
-        const { code, fileImportsTransformed } = await transpileFile(filePath, isValueFile, userRootDir);
-        const fileExports = await executeTranspiledFile(filePath, code, fileImportsTransformed, isValueFile);
+        const { code, fileImportsTransformed } = await transpileFile(filePath, transformImports, userRootDir);
+        const fileExports = await executeTranspiledFile(filePath, code, fileImportsTransformed);
         return { fileExports };
     }
 }
-async function transpileFile(filePath, isValueFile, userRootDir) {
+async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem } = filePath;
     const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    const importsAreTransformed = !isValueFile;
-    let code = await transpileWithEsbuild(filePath, userRootDir, importsAreTransformed, isValueFile);
+    let code = await transpileWithEsbuild(filePath, userRootDir, transformImports);
     let fileImportsTransformed = null;
-    if (importsAreTransformed) {
-        const res = transformImports_(code, filePath);
+    if (transformImports) {
+        const res = transformFileImports_(code, filePath);
         if (res) {
             code = res.code;
             fileImportsTransformed = res.fileImportsTransformed;
@@ -45,21 +45,16 @@ async function transpileFile(filePath, isValueFile, userRootDir) {
     }
     else {
         if (isHeaderFile(filePathAbsoluteFilesystem)) {
-            if (isValueFile) {
-                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 });
-            }
-            else {
-                assert(false);
-            }
+            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 });
         }
     }
     return { code, fileImportsTransformed };
 }
-function transformImports_(codeOriginal, filePath) {
+function transformFileImports_(codeOriginal, filePath) {
     const { filePathAbsoluteFilesystem } = filePath;
     const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
     // Replace import statements with import strings
-    const res = transformImports(codeOriginal, filePathToShowToUser2);
+    const res = transformFileImports(codeOriginal, filePathToShowToUser2);
     if (res.noTransformation) {
         return null;
     }
@@ -72,8 +67,7 @@ function transformImports_(codeOriginal, filePath) {
     }
     return { code, fileImportsTransformed };
 }
-async function transpileWithEsbuild(filePath, userRootDir, importsAreTransformed, isValueFile) {
-    const isConfigFile = !isValueFile;
+async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
     const entryFilePath = filePath.filePathAbsoluteFilesystem;
     const entryFileDir = path.posix.dirname(entryFilePath);
     const options = {
@@ -94,12 +88,12 @@ async function transpileWithEsbuild(filePath, userRootDir, importsAreTransformed
         // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
         treeShaking: false,
         minify: false,
-        metafile: isConfigFile,
+        metafile: !transformImports,
         // We cannot bundle imports that are meant to be transformed
-        bundle: !importsAreTransformed
+        bundle: !transformImports
     };
     // Track dependencies
-    if (isConfigFile) {
+    if (!transformImports) {
         options.packages = 'external';
         options.plugins = [
             {
@@ -134,7 +128,7 @@ async function transpileWithEsbuild(filePath, userRootDir, importsAreTransformed
         throw err;
     }
     // Track dependencies
-    if (isConfigFile) {
+    if (!transformImports) {
         assert(result.metafile);
         Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
             filePathRelative = toPosixPath(filePathRelative);
@@ -147,7 +141,7 @@ async function transpileWithEsbuild(filePath, userRootDir, importsAreTransformed
     assert(typeof code === 'string');
     return code;
 }
-async function executeTranspiledFile(filePath, code, fileImportsTransformed, isValueFile) {
+async function executeTranspiledFile(filePath, code, fileImportsTransformed) {
     const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = 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
@@ -161,7 +155,7 @@ async function executeTranspiledFile(filePath, code, fileImportsTransformed, isV
     finally {
         clean();
     }
-    if (fileImportsTransformed && !isValueFile) {
+    if (fileImportsTransformed) {
         assert(filePathRelativeToUserRootDir !== undefined);
         const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
         assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2);

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

@@ -2,11 +2,14 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
+export { isV1Design };
 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 = {
+    locationId: LocationId;
     filePath: FilePathResolved;
     fileExportsByConfigName: Record<ConfigName, {
         configValue?: unknown;
@@ -26,4 +29,5 @@ type VikeConfig = {
 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 isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;