vike 0.4.165 → 0.4.166

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

@@ -3,7 +3,7 @@ export { loadValueFile };
 export { loadConfigFile };
 export type { ImportedFilesLoaded };
 export type { ConfigFile };
-import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 import type { InterfaceValueFile } from '../getVikeConfig.js';
 type ImportedFilesLoaded = Record<string, Promise<Record<string, unknown>>>;
 type ConfigFile = {

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

@@ -2,13 +2,14 @@
 export { loadImportedFile };
 export { loadValueFile };
 export { loadConfigFile };
-import { assertPosixPath, assert, assertUsage, assertWarning, hasProp, assertIsNotProductionRuntime, isNpmPackageImport } from '../../../../utils.js';
+import { assert, assertUsage, assertWarning, hasProp, assertIsNotProductionRuntime, isNpmPackageImport } from '../../../../utils.js';
 import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
 import { parseImportData } from './transformFileImports.js';
 import { getConfigFileExport } from '../getConfigFileExport.js';
 import { assertImportPath, resolveImportPath } from './resolveImportPath.js';
+import { getFilePathResolved } from '../../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
 // Load fake import
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
@@ -58,21 +59,12 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsImportData.map((importData) => {
-        const { importPath: importPath } = importData;
+        const { importPath: importPathAbsolute } = importData;
         const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
         assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
-        warnUserLandExtension(importPath, configFilePath);
-        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
-        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
-        const filePathAbsoluteVite = filePathRelativeToUserRootDir ?? importPath;
-        extendsConfigFiles.push({
-            filePathAbsoluteFilesystem,
-            filePathAbsoluteVite,
-            filePathRelativeToUserRootDir,
-            filePathToShowToUser: filePathAbsoluteVite,
-            importPathAbsolute: importPath
-        });
+        warnUserLandExtension(importPathAbsolute, configFilePath);
+        const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir, importPathAbsolute });
+        extendsConfigFiles.push(filePath);
     });
     const extendsConfigs = [];
     await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
@@ -83,17 +75,6 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
-    assertPosixPath(filePathAbsoluteFilesystem);
-    assertPosixPath(userRootDir);
-    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        return null;
-    }
-    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
-    if (!filePathRelativeToUserRootDir.startsWith('/'))
-        filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
-    return filePathRelativeToUserRootDir;
-}
 function warnUserLandExtension(importPath, configFilePath) {
     assertWarning(isNpmPackageImport(importPath), `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
 }

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

@@ -2,8 +2,9 @@ export { resolveImport };
 export { resolveImportPath };
 export { assertImportPath };
 export { clearFilesEnvMap };
-import type { ConfigEnvInternal, DefinedAtFileFullInfo, FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal, DefinedAtFileFullInfo } from '../../../../../../shared/page-configs/PageConfig.js';
 import { type ImportData } from './transformFileImports.js';
+import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.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

@@ -6,6 +6,7 @@ import pc from '@brillout/picocolors';
 import { assert, assertPosixPath, assertUsage, deepEqual, requireResolve } from '../../../../utils.js';
 import { parseImportData } from './transformFileImports.js';
 import path from 'path';
+import { getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
 const filesEnvMap = new Map();
 function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
@@ -23,14 +24,8 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
         // ```
         assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
-        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
-        const filePath = {
-            filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteVite: filePathRelativeToUserRootDir,
-            filePathToShowToUser: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
+        const filePathAbsoluteUserRootDir = resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
+        const filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null });
         return {
             ...filePath,
             fileExportName: exportName,
@@ -41,13 +36,11 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        const filePath = {
+        const filePath = getFilePathUnresolved({
             filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir: null,
-            filePathAbsoluteVite: importPath,
-            filePathToShowToUser: importPath,
+            filePathAbsoluteUserRootDir: null,
             importPathAbsolute: importPath
-        };
+        });
         return {
             ...filePath,
             fileExportName: exportName,
@@ -55,11 +48,11 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         };
     }
 }
-function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
+function resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
-    let filePathRelativeToUserRootDir;
+    let filePathAbsoluteUserRootDir;
     if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
+        filePathAbsoluteUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
     }
     else {
         assertUsage(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
@@ -68,14 +61,14 @@ function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, imp
         // assert(filePathAbsoluteFilesystem.startsWith('/'))
         // filePath = `/@fs${filePathAbsoluteFilesystem}`
         // /*/
-        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
-        // assert(filePathRelativeToUserRootDir.startsWith('../'))
-        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
+        // filePathAbsoluteUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
+        // assert(filePathAbsoluteUserRootDir.startsWith('../'))
+        // filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir
         // //*/
     }
-    assertPosixPath(filePathRelativeToUserRootDir);
-    assert(filePathRelativeToUserRootDir.startsWith('/'));
-    return filePathRelativeToUserRootDir;
+    assertPosixPath(filePathAbsoluteUserRootDir);
+    assert(filePathAbsoluteUserRootDir.startsWith('/'));
+    return filePathAbsoluteUserRootDir;
 }
 function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;

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

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

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

@@ -14,13 +14,12 @@ import 'source-map-support/register.js';
 assertIsNotProductionRuntime();
 const debug = createDebugger('vike:pointer-imports');
 async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
-    const { filePathAbsoluteFilesystem } = filePath;
+    const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-    assertUsage(isJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUser2} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
+    assertUsage(isJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
-        assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUser2} to ${removeHeaderFileExtension(filePathToShowToUser2)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
+        assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
     }
     if (isConfigFile === 'is-extension-config' && !isHeader && fileExtension.endsWith('js')) {
         // This doesn't track dependencies => we should never use this for user land configs
@@ -35,28 +34,27 @@ async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
     }
 }
 async function transpileFile(filePath, transformImports, userRootDir) {
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-    const { filePathAbsoluteFilesystem } = filePath;
+    const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     if (debug.isEnabled)
-        debug('transpile', filePathToShowToUser2);
+        debug('transpile', filePathToShowToUserResolved);
     let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
     if (debug.isEnabled)
-        debug(`code, post esbuild (${filePathToShowToUser2})`, code);
+        debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
-        const codeMod = transformFileImports(code, filePathToShowToUser2, pointerImports);
+        const codeMod = transformFileImports(code, filePathToShowToUserResolved, pointerImports);
         if (codeMod) {
             code = codeMod;
             isImportTransformed = true;
             if (debug.isEnabled)
-                debug(`code, post transformImports() (${filePathToShowToUser2})`, code);
+                debug(`code, post transformImports() (${filePathToShowToUserResolved})`, code);
         }
     }
     if (!isImportTransformed) {
         if (debug.isEnabled)
-            debug(`code, no transformImports() (${filePathToShowToUser2})`);
+            debug(`code, no transformImports() (${filePathToShowToUserResolved})`);
     }
     return code;
 }
@@ -292,19 +290,12 @@ function triggerPrepareStackTrace(err) {
     }
 }
 function getErrIntroMsg(operation, filePath) {
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+    const { filePathToShowToUserResolved } = filePath;
     const msg = [
         // prettier ignore
         pc.red(`Failed to ${operation}`),
-        pc.bold(pc.red(filePathToShowToUser2)),
+        pc.bold(pc.red(filePathToShowToUserResolved)),
         pc.red(`because:`)
     ].join(' ');
     return msg;
 }
-/** `filePath.filePathToShowToUser` may show the import path of a package, use `filePathToShowToUser2` instead always show a file path instead. */
-function getFilePathToShowToUser2(filePath) {
-    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
-    const filePathToShowToUser2 = filePathRelativeToUserRootDir || filePathAbsoluteFilesystem;
-    assert(filePathToShowToUser2);
-    return filePathToShowToUser2;
-}

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

@@ -5,9 +5,10 @@ export { isVikeConfigFile };
 export { isV1Design };
 export type { VikeConfigObject };
 export type { InterfaceValueFile };
-import type { PageConfigGlobalBuildTime, PageConfigBuildTime, FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
+import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
+import type { FilePathResolved } from '../../../../../shared/page-configs/FilePath.js';
 type InterfaceFileCommons = {
     locationId: LocationId;
     filePath: FilePathResolved;
@@ -28,6 +29,6 @@ type VikeConfigObject = {
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(userRootDir: string, outDirRoot: string): void;
-declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean): Promise<VikeConfigObject>;
+declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: true): Promise<VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;

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

@@ -19,7 +19,7 @@ import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
 import { clearFilesEnvMap, resolveImport } from './getVikeConfig/resolveImportPath.js';
-import { resolveFilePathRelativeToUserRootDir } from './getVikeConfig/resolveFilePath.js';
+import { getFilePathResolved } from '../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -62,7 +62,7 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(config, isDev, tolerateInvalidConfig = false) {
+async function getVikeConfig(config, isDev, tolerateInvalidConfig) {
     const { outDirRoot } = getOutDirs(config);
     const userRootDir = config.root;
     if (!vikeConfigPromise) {
@@ -92,11 +92,11 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
     await Promise.all([
         // Config files
         ...configFiles.map(async (filePath) => {
-            const { filePathRelativeToUserRootDir } = filePath;
-            assert(filePathRelativeToUserRootDir);
+            const { filePathAbsoluteUserRootDir } = filePath;
+            assert(filePathAbsoluteUserRootDir);
             const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
-            assert(filePath.filePathRelativeToUserRootDir);
-            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            assert(filePath.filePathAbsoluteUserRootDir);
+            const locationId = getLocationId(filePathAbsoluteUserRootDir);
             const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
             interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
             interfaceFilesByLocationId[locationId].push(interfaceFile);
@@ -145,11 +145,11 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
         }),
         // Value files
         ...valueFiles.map(async (filePath) => {
-            const { filePathRelativeToUserRootDir } = filePath;
-            assert(filePathRelativeToUserRootDir);
-            const configName = getConfigName(filePathRelativeToUserRootDir);
+            const { filePathAbsoluteUserRootDir } = filePath;
+            assert(filePathAbsoluteUserRootDir);
+            const configName = getConfigName(filePathAbsoluteUserRootDir);
             assert(configName);
-            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            const locationId = getLocationId(filePathAbsoluteUserRootDir);
             const interfaceFile = {
                 locationId,
                 filePath,
@@ -348,9 +348,9 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         const interfaceFilesGlobalPaths = [];
         objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
             assert(isGlobalLocation(locationId, locationIds));
-            interfaceFiles.forEach(({ filePath: { filePathRelativeToUserRootDir } }) => {
-                if (filePathRelativeToUserRootDir) {
-                    interfaceFilesGlobalPaths.push(filePathRelativeToUserRootDir);
+            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
+                if (filePathAbsoluteUserRootDir) {
+                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
                 }
             });
         });
@@ -459,10 +459,10 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
 }
 function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
     return lowerFirst((interfaceFile) => {
-        const { filePathRelativeToUserRootDir } = interfaceFile.filePath;
+        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
         assert(isInterfaceFileUserLand(interfaceFile));
-        assert(filePathRelativeToUserRootDir);
-        return filePathRelativeToUserRootDir.length;
+        assert(filePathAbsoluteUserRootDir);
+        return filePathAbsoluteUserRootDir.length;
     })(interfaceFile1, interfaceFile2);
 }
 function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
@@ -536,6 +536,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 configName !== 'extends') {
                 if (import_.filePathAbsoluteFilesystem) {
                     assert(hasProp(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
+                    assert(hasProp(import_, 'filePathToShowToUserResolved', 'string')); // Help TS
                     const fileExport = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
                     configValueSource.value = fileExport;
                 }
@@ -739,7 +740,7 @@ function getComputed(configValueSources, configDefinitions) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathRelativeToUserRootDir }) => resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir, userRootDir));
+    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null }));
     return plusFiles;
 }
 function getConfigName(filePath) {
@@ -829,9 +830,9 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     const configDefinedAt = getConfigDefinedAtString('Config', configName, configFilesystemRoutingRoot);
     assertUsage(typeof value === 'string', `${configDefinedAt} should be a string`);
     assertUsage(value.startsWith('/'), `${configDefinedAt} is ${pc.cyan(value)} but it should start with a leading slash ${pc.cyan('/')}`);
-    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAt;
-    assert(filePathRelativeToUserRootDir);
-    const before = getFilesystemRouteString(getLocationId(filePathRelativeToUserRootDir));
+    const { filePathAbsoluteUserRootDir } = configFilesystemRoutingRoot.definedAt;
+    assert(filePathAbsoluteUserRootDir);
+    const before = getFilesystemRouteString(getLocationId(filePathAbsoluteUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };

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

@@ -0,0 +1,20 @@
+export { getFilePathResolved };
+export { getFilePathUnresolved };
+import type { FilePath, FilePathResolved } from '../../../shared/page-configs/FilePath.js';
+declare function getFilePathUnresolved(args: {
+    filePathAbsoluteFilesystem: string | null;
+    filePathAbsoluteUserRootDir: string | null;
+    importPathAbsolute: string | null;
+} & ({
+    filePathAbsoluteUserRootDir: string;
+} | {
+    importPathAbsolute: string;
+})): FilePath;
+declare function getFilePathResolved(args: {
+    userRootDir: string;
+    importPathAbsolute: string | null;
+} & ({
+    filePathAbsoluteFilesystem: string;
+} | {
+    filePathAbsoluteUserRootDir: string;
+})): FilePathResolved;

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

@@ -0,0 +1,82 @@
+export { getFilePathResolved };
+export { getFilePathUnresolved };
+import path from 'path';
+import { assert, assertPosixPath, hasProp } from '../utils.js';
+function getFilePathUnresolved(args) {
+    const { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir } = args;
+    let filePathAbsoluteVite;
+    if (args.filePathAbsoluteUserRootDir !== null) {
+        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
+    }
+    else {
+        assert(args.importPathAbsolute !== null); // Help TS
+        filePathAbsoluteVite = args.importPathAbsolute;
+    }
+    return {
+        ...args,
+        filePathAbsoluteVite,
+        filePathToShowToUser: filePathAbsoluteVite,
+        filePathToShowToUserResolved: filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem
+    };
+}
+function getFilePathResolved(args) {
+    const { userRootDir, importPathAbsolute } = args;
+    let filePathAbsoluteFilesystem;
+    let filePathAbsoluteUserRootDir;
+    if ('filePathAbsoluteFilesystem' in args) {
+        filePathAbsoluteFilesystem = args.filePathAbsoluteFilesystem;
+        filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
+    }
+    else {
+        filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
+        filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
+    }
+    let filePathResolved;
+    const common = {
+        filePathAbsoluteUserRootDir,
+        filePathAbsoluteFilesystem,
+        importPathAbsolute,
+        userRootDir
+    };
+    if (importPathAbsolute) {
+        filePathResolved = getFilePathUnresolved({
+            ...common,
+            importPathAbsolute
+        });
+    }
+    else {
+        assert(filePathAbsoluteUserRootDir);
+        filePathResolved = getFilePathUnresolved({
+            ...common,
+            filePathAbsoluteUserRootDir
+        });
+    }
+    assert(filePathAbsoluteFilesystem);
+    assert(hasProp(filePathResolved, 'filePathAbsoluteFilesystem', 'string'));
+    assert(hasProp(filePathResolved, 'filePathToShowToUserResolved', 'string'));
+    return filePathResolved;
+}
+function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
+    assertPosixPath(filePathAbsoluteUserRootDir);
+    assertPosixPath(userRootDir);
+    const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathAbsoluteUserRootDir);
+    return filePathAbsoluteFilesystem;
+}
+function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    assertPosixPath(userRootDir);
+    const filePathRelative = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        assert(filePathRelative.startsWith('../'));
+        return null;
+    }
+    assert(!filePathRelative.startsWith('.') && !filePathRelative.startsWith('/'));
+    const filePathAbsoluteUserRootDir = `/${filePathRelative}`;
+    {
+        let check = filePathAbsoluteFilesystem.slice(userRootDir.length);
+        if (!check.startsWith('/'))
+            check = '/' + check;
+        assert(filePathAbsoluteUserRootDir === check);
+    }
+    return filePathAbsoluteUserRootDir;
+}

package/dist/esm/node/plugin/shared/loggerNotProd/errorWithCodeSnippet.js

@@ -7,7 +7,7 @@ export { isEquivalentErrorWithCodeSnippet };
 export { getPrettyErrMessage };
 // Copied & adapted from https://github.com/vitejs/vite/blob/9c114c5c72a6af87e3330d5573362554b4511265/packages/vite/src/node/server/middlewares/error.ts
 import pc from '@brillout/picocolors';
-import { assert, escapeRegex, getFilePathRelativeToUserRootDir, isObject, removeEmptyLines, stripAnsi, toPosixPath } from '../../utils.js';
+import { assert, escapeRegex, getFilePathAbsoluteUserRootDir, isObject, removeEmptyLines, stripAnsi, toPosixPath } from '../../utils.js';
 function isErrorWithCodeSnippet(err) {
     if (!isObject(err)) {
         return false;
@@ -46,7 +46,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     let { id, frame } = err;
     const msgFirstLine = [
         pc.red('Failed to transpile'),
-        pc.bold(pc.red(getFilePathRelativeToUserRootDir(normalizeId(id), userRootDir))),
+        pc.bold(pc.red(getFilePathAbsoluteUserRootDir(normalizeId(id), userRootDir))),
         pc.red('because:')
     ].join(' ');
     const errMsg = getPrettyErrMessage(err);

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -138,6 +138,7 @@ async function mergeScriptEntries(pageAssets, isProduction) {
 function getPageContextJsonScriptTag(pageContext) {
     const pageContextSerialized = sanitizeJson(serializePageContextClientSide(pageContext));
     const htmlTag = `<script id="vike_pageContext" type="application/json">${pageContextSerialized}</script>`;
+    // Used by contra.com https://github.com/gajus
     // @ts-expect-error
     pageContext._pageContextHtmlTag = htmlTag;
     return htmlTag;

package/dist/esm/node/runtime/html/injectAssets/injectHtmlTags.js

@@ -94,7 +94,7 @@ function injectBreakLines(htmlFragment, before, after) {
     const whitespaceExtra = paddingParent ? '  ' : '';
     const whitespace = `${paddingParent}${whitespaceExtra}`;
     const padding = `\n${whitespace}`;
-    htmlFragment = htmlFragment.split(/<(?=[^\/])/).join(`${padding}<`);
+    htmlFragment = htmlFragment.replace(/<[^\/]/g, (match) => `${padding}${match}`);
     if (isBlankLine) {
         assert(htmlFragment.startsWith(padding), { htmlFragment });
         htmlFragment = whitespaceExtra + htmlFragment.slice(padding.length);

package/dist/esm/node/runtime/renderPage/getPageAssets/getManifestEntry.js

@@ -48,35 +48,37 @@ function getManifestEntry(id, assetsManifest) {
         const [manifestKey, manifestEntry] = found;
         return { manifestEntry, manifestKey };
     }
+    /* Can we remove this?
     // extensions[number].pageConfigsSrcDir
     if (id.startsWith('/node_modules/') || id.startsWith('/../')) {
-        let manifestKeyEnd = id.split('/node_modules/').slice(-1)[0];
-        assert(manifestKeyEnd, debugInfo);
-        assert(!manifestKeyEnd.startsWith('/'), debugInfo);
-        manifestKeyEnd = '/' + manifestKeyEnd;
-        {
-            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
-            if (manifestEntry) {
-                assert(manifestKey, debugInfo);
-                return { manifestEntry, manifestKey };
-            }
-        }
-        {
-            assert(manifestKeyEnd.startsWith('/'), debugInfo);
-            const dirS = manifestKeyEnd.split('/');
-            assert(dirS[0] === '', debugInfo);
-            manifestKeyEnd = '/' + dirS.slice(2).join('/');
-            assert(manifestKeyEnd.startsWith('/'), debugInfo);
+      let manifestKeyEnd = id.split('/node_modules/').slice(-1)[0]
+      assert(manifestKeyEnd, debugInfo)
+      assert(!manifestKeyEnd.startsWith('/'), debugInfo)
+      manifestKeyEnd = '/' + manifestKeyEnd
+      {
+        const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id)
+        if (manifestEntry) {
+          assert(manifestKey, debugInfo)
+          return { manifestEntry, manifestKey }
         }
-        {
-            const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id);
-            if (manifestEntry) {
-                assert(manifestKey, debugInfo);
-                return { manifestEntry, manifestKey };
-            }
+      }
+      {
+        assert(manifestKeyEnd.startsWith('/'), debugInfo)
+        const dirS = manifestKeyEnd.split('/')
+        assert(dirS[0] === '', debugInfo)
+        manifestKeyEnd = '/' + dirS.slice(2).join('/')
+        assert(manifestKeyEnd.startsWith('/'), debugInfo)
+      }
+      {
+        const { manifestEntry, manifestKey } = findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id)
+        if (manifestEntry) {
+          assert(manifestKey, debugInfo)
+          return { manifestEntry, manifestKey }
         }
-        assert(false, debugInfo);
+      }
+      assert(false, debugInfo)
     }
+    */
     assert(false, debugInfo);
 }
 function findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id) {

package/dist/esm/node/runtime/renderPage/logErrorHint.js

@@ -4,6 +4,7 @@ export { isCjsEsmError };
 export { isKnownError };
 export { getHint };
 import { assert, formatHintLog, isNotNullish, isObject, unique } from '../utils.js';
+import pc from '@brillout/picocolors';
 const knownErrors = [
     {
         errMsg: 'jsxDEV is not a function',
@@ -44,6 +45,7 @@ function getHint(error) {
 }
 function logHint(hint) {
     hint = formatHintLog(hint);
+    hint = pc.bold(hint);
     console.error(hint);
 }
 function isKnownError(error) {