vike 0.4.160 → 0.4.161-commit-0e9c635

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

@@ -3,6 +3,7 @@ export { envVarsPlugin };
 export { applyEnvVar };
 import { loadEnv } from 'vite';
 import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, getFilePathRelativeToUserRootDir, lowerFirst } from '../utils.js';
+import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
 function envVarsPlugin() {
     let envsAll;
     let config;
@@ -62,8 +63,11 @@ function envVarsPlugin() {
                 // Apply
                 code = applyEnvVar(envName, envVal, code);
             });
-            // No need for low-resolution source map since line numbers didn't change. (Does Vite do high-resolution column numbers source mapping?)
-            return code;
+            // Line numbers didn't change.
+            //  - We only break the column number of a couple of lines, wich is acceptable.
+            //  - Anyways, I'm not even sure Vite supports high-resolution column number source mapping.
+            const ret = sourceMapPassthrough(code);
+            return ret;
         }
     };
 }

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

@@ -1,6 +1,6 @@
-// Alternative: use `ssrEmitAssets: true`
-//  - See https://github.com/vitejs/vite/pull/11430
-// This plugin makes client-side bundles include the CSS imports living in server-side-only code.
+// Remove this workaround if the other workaround config.build.ssrEmitAssets turns out to be reliable.
+//  - Remove this file then revert this commit: https://github.com/vikejs/vike/commit/805a18974f13420a78fcc30fdd676696e405c3ca
+// Workaround to make client-side bundles include the CSS imports living in server-side-only code.
 //  - This is needed for HTML-only pages, and React Server Components.
 //  - We recommend using the debug flag to get an idea of how this plugin works: `$ DEBUG=vike:extractAssets pnpm exec vite build`. Then have a look at `dist/client/manifest.json` and see how `.page.server.js` entries have zero JavaScript but only CSS.
 //  - This appraoch supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
@@ -11,8 +11,11 @@ import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
-import { removeSourceMap } from '../shared/removeSourceMap.js';
+import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 import pc from '@brillout/picocolors';
+import { fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
+import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
+import { assertV1Design } from '../../shared/assertV1Design.js';
 const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
@@ -23,6 +26,8 @@ const debugEnabled = isDebugEnabled(debugNamespace);
 function extractAssetsPlugin() {
     let config;
     let configVike;
+    let vikeConfig;
+    let isServerAssetsFixEnabled;
     return [
         // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also satic files imports e.g. `import logoURL from './logo.svg.js'`).
         {
@@ -34,13 +39,18 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(id)) {
                     return;
                 }
+                if (isServerAssetsFixEnabled) {
+                    // I'm guessing isServerAssetsFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
+                    assertV1Design(true, vikeConfig.pageConfigs);
+                    assert(false);
+                }
                 assert(configVike.includeAssetsImportedByServer);
                 assert(!viteIsSSR_options(options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
                 const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
                 debugTransformResult(id, code, importStatements);
-                return removeSourceMap(code);
+                return sourceMapRemove(code);
             }
         },
         // This plugin appends `?extractAssets` to module IDs
@@ -131,6 +141,8 @@ function extractAssetsPlugin() {
             async configResolved(config_) {
                 configVike = await getConfigVike(config_);
                 config = config_;
+                vikeConfig = await getVikeConfig(config, false);
+                isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
             },
             load(id) {
                 if (!isVirtualFileId(id))

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

@@ -3,7 +3,7 @@ export { isUsingClientRouter };
 export { extractExportNamesRE };
 import { assert, getFileExtension, viteIsSSR_options, createDebugger, isDebugEnabled, getGlobalObject, assertUsage } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
-import { removeSourceMap } from '../shared/removeSourceMap.js';
+import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debugNamespace = 'vike:extractExportNames';
 const debug = createDebugger(debugNamespace);
@@ -38,7 +38,7 @@ async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
         globalObject.usesClientRouter = true;
     }
     const code = getCode(exportNames, wildcardReExports, isClientSide, isProduction, id);
-    return removeSourceMap(code);
+    return sourceMapRemove(code);
 }
 function getCode(exportNames, wildcardReExports, isClientSide, isProduction, id) {
     let code = '';

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.d.ts

@@ -1,5 +1,4 @@
 export { getVikeManifest };
-import { ResolvedConfig } from 'vite';
 import { type PluginManifest } from '../../../shared/assertPluginManifest.js';
 import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
-declare function getVikeManifest(config: ResolvedConfig, configVike: ConfigVikeResolved): PluginManifest;
+declare function getVikeManifest(configVike: ConfigVikeResolved): PluginManifest;

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.js

@@ -1,32 +1,15 @@
 export { getVikeManifest };
-import { projectInfo, toPosixPath, assertPosixPath, isNotNullish } from '../../utils.js';
+import { projectInfo } from '../../utils.js';
 import { assertPluginManifest } from '../../../shared/assertPluginManifest.js';
 import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
-import path from 'path';
 import { getRuntimeManifest } from '../../../runtime/globalContext.js';
-function getVikeManifest(config, configVike) {
+function getVikeManifest(configVike) {
     const runtimeManifest = getRuntimeManifest(configVike);
     const manifest = {
         version: projectInfo.projectVersion,
         usesClientRouter: isUsingClientRouter(), // TODO/v1-release: remove
-        manifestKeyMap: getManifestKeyMap(configVike, config),
         ...runtimeManifest
     };
     assertPluginManifest(manifest);
     return manifest;
 }
-function getManifestKeyMap(configVike, config) {
-    const manifestKeyMap = {};
-    configVike.extensions
-        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-        .flat()
-        .filter(isNotNullish)
-        .forEach(({ importPath, filePath }) => {
-        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
-        const filePathRelative = path.posix.relative(config.root, toPosixPath(filePath));
-        assertPosixPath(filePathRelative);
-        assertPosixPath(importPath);
-        manifestKeyMap[importPath] = filePathRelative;
-    });
-    return manifestKeyMap;
-}

package/dist/esm/node/plugin/plugins/importBuild/index.d.ts

@@ -1,3 +1,8 @@
 export { importBuild };
-import type { Plugin } from 'vite';
+export { set_constant_ASSETS_MAP };
+import type { Plugin, Rollup } from 'vite';
+type Bundle = Rollup.OutputBundle;
+type Options = Rollup.NormalizedOutputOptions;
 declare function importBuild(): Plugin[];
+/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
+declare function set_constant_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;

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

@@ -1,6 +1,7 @@
 export { importBuild };
+export { set_constant_ASSETS_MAP };
 import { serverEntryPlugin, findServerEntry } from '@brillout/vite-plugin-server-entry/plugin.js';
-import { assert, getOutDirs, toPosixPath, viteIsSSR } from '../../utils.js';
+import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
@@ -21,11 +22,6 @@ function importBuild() {
             async configResolved(config_) {
                 config = config_;
                 configVike = await getConfigVike(config);
-            },
-            async writeBundle(options, bundle) {
-                if (!viteIsSSR(config))
-                    return;
-                await replace_ASSETS_MAP(options, bundle);
             }
         },
         ...serverEntryPlugin({
@@ -38,7 +34,7 @@ function importBuild() {
 }
 function getEntryCode(config, configVike) {
     const importPath = getImportPath(config);
-    const vikeManifest = getVikeManifest(config, configVike);
+    const vikeManifest = getVikeManifest(configVike);
     const importerCode = [
         `  import { setImportBuildGetters } from '${importPath}';`,
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
@@ -58,7 +54,8 @@ function getEntryCode(config, configVike) {
     ].join('\n');
     return importerCode;
 }
-async function replace_ASSETS_MAP(options, bundle) {
+/** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
+async function set_constant_ASSETS_MAP(options, bundle) {
     const { dir } = options;
     assert(dir);
     // This will probably fail with @vitejs/plugin-legacy

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

@@ -1,10 +1,10 @@
 export { getVirtualFileImportUserCode };
-import { assert, assertPosixPath, viteIsSSR_options, isNotNullish, scriptFileExtensions, debugGlob, getOutDirs } from '../../utils.js';
+import { assert, assertPosixPath, viteIsSSR_options, scriptFileExtensions, debugGlob, getOutDirs, isVersionOrAbove } from '../../utils.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { fileTypes, determineFileType } from '../../../../shared/getPageFiles/fileTypes.js';
+import { version as viteVersion } from 'vite';
+import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'path';
 import { getVirtualFilePageConfigs } from './v1-design/getVirtualFilePageConfigs.js';
-import { generateEagerImport } from './generateEagerImport.js';
 async function getVirtualFileImportUserCode(id, options, configVike, config, isDev) {
     const idParsed = isVirtualFileIdImportUserCode(id);
     assert(idParsed);
@@ -21,53 +21,13 @@ async function getCode(config, configVike, isForClientSide, isClientRouting, isP
     assert(isDev === !isBuild);
     let content = '';
     {
-        const globRoots = getGlobRoots(config, configVike);
+        const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);
         content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id);
     }
-    {
-        const extensionsImportPaths = configVike.extensions
-            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
-            .flat()
-            .filter(isNotNullish)
-            .map(({ importPath }) => importPath);
-        content += generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering);
-    }
     debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
     return content;
 }
-function generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering) {
-    let fileContent = '\n\n';
-    extensionsImportPaths
-        .filter((importPath) => {
-        assert(
-        // V1 design
-        importPath.includes('+') ||
-            // V0.4 design
-            importPath.includes('.page.'));
-        return !importPath.includes('+');
-    })
-        .forEach((importPath) => {
-        const fileType = determineFileType(importPath);
-        const { includeImport, includeExportNames } = determineInjection({
-            fileType,
-            isForClientSide,
-            isClientRouting,
-            isPrerendering,
-            isBuild
-        });
-        if (includeImport) {
-            fileContent += addImport(importPath, fileType, false, isBuild);
-        }
-        if (includeExportNames) {
-            fileContent += addImport(importPath, fileType, true, isBuild);
-        }
-        if (!includeImport && !includeExportNames && !isForClientSide) {
-            fileContent += `pageFilesList.push("${importPath}");` + '\n';
-        }
-    });
-    return fileContent;
-}
 function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild }) {
     if (!isForClientSide) {
         return {
@@ -93,42 +53,6 @@ function determineInjection({ fileType, isForClientSide, isClientRouting, isPrer
         }
     }
 }
-function addImport(importPath, fileType, exportNames, isBuild) {
-    const pageFilesVar = (() => {
-        if (exportNames) {
-            if (isBuild) {
-                return 'pageFilesExportNamesEager';
-            }
-            else {
-                return 'pageFilesExportNamesLazy';
-            }
-        }
-        else {
-            if (fileType === '.page.route') {
-                return 'pageFilesEager';
-            }
-            else {
-                return 'pageFilesLazy';
-            }
-        }
-    })();
-    const query = !exportNames ? '' : '?extractExportNames';
-    let fileContent = '';
-    const mapVar = `${pageFilesVar}['${fileType}']`;
-    fileContent += `${mapVar} = ${mapVar} ?? {};\n`;
-    const value = (() => {
-        if (!pageFilesVar.endsWith('Eager')) {
-            return `() => import('${importPath}${query}')`;
-        }
-        else {
-            const { importName, importStatement } = generateEagerImport(`${importPath}${query}`);
-            fileContent += importStatement + '\n';
-            return importName;
-        }
-    })();
-    fileContent += `${mapVar}['${importPath}'] = ${value};\n`;
-    return fileContent;
-}
 async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id) {
     let fileContent = `// Generatead by node/plugin/plugins/virtualFiles/index.ts
 
@@ -206,10 +130,15 @@ function getGlobs(globRoots, isBuild, fileType, query) {
             varNameLocals.push(varNameLocal);
             const globIncludePath = `'${getGlobPath(globRoot.includeDir, fileType)}'`;
             const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
-            const globOptions = JSON.stringify({ eager: isEager, as: query });
-            assert(globOptions.startsWith('{"eager":true') || globOptions.startsWith('{"eager":false'));
+            const globOptions = { eager: isEager };
+            if (isVersionOrAbove(viteVersion, '5.1.0')) {
+                globOptions.as = query;
+            }
+            else {
+                globOptions.query = `?${query}`;
+            }
             const globPaths = globExcludePath ? `[${globIncludePath}, ${globExcludePath}]` : `[${globIncludePath}]`;
-            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${globOptions});`;
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${JSON.stringify(globOptions)});`;
             return globLine;
         }),
         `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
@@ -217,22 +146,13 @@ function getGlobs(globRoots, isBuild, fileType, query) {
         ''
     ].join('\n');
 }
-function getGlobRoots(config, configVike) {
+function getGlobRoots(config) {
     const globRoots = [
         {
             includeDir: '/',
             excludeDir: path.posix.relative(config.root, getOutDirs(config).outDirRoot)
         }
     ];
-    configVike.extensions
-        .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
-        .filter(isNotNullish)
-        .forEach((pageConfigsSrcDir) => {
-        const globRoot = {
-            includeDir: path.posix.relative(config.root, pageConfigsSrcDir)
-        };
-        globRoots.push(globRoot);
-    });
     return globRoots;
 }
 function getGlobPath(globRootDir, fileType) {

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

@@ -1,6 +1,7 @@
 export { configDefinitionsBuiltIn };
 export { configDefinitionsBuiltInGlobal };
 export type { ConfigDefinition };
+export type { ConfigDefinitions };
 export type { ConfigDefinitionInternal };
 export type { ConfigNameGlobal };
 export type { ConfigEffect };
@@ -54,6 +55,7 @@ type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
     _userEffectDefinedAt?: DefinedAtFileFullInfo;
     env: ConfigEnvInternal;
 };
+type ConfigDefinitions = Record<string, ConfigDefinitionInternal>;
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;
 declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'extensions' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';

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

@@ -1,5 +1,4 @@
 export { crawlPlusFiles };
 declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
     filePathRelativeToUserRootDir: string;
-    filePathAbsoluteFilesystem: string;
 }[]>;

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;