vike 0.4.165-commit-8eba585 → 0.4.166-commit-6a8acaa

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

@@ -1,8 +1,9 @@
 export { fileEnv };
-import { assert, assertUsage, assertWarning, capitalizeFirstLetter, getFilePathAbsoluteUserRootDir } from '../utils.js';
+import { assert, assertUsage, assertWarning, capitalizeFirstLetter } from '../utils.js';
 import { extractAssetsRE } from './extractAssetsPlugin.js';
 import { extractExportNamesRE } from './extractExportNamesPlugin.js';
 import pc from '@brillout/picocolors';
+import { getModuleFilePath } from '../shared/getFilePath.js';
 function fileEnv() {
     let config;
     let isDev = false;
@@ -39,11 +40,13 @@ function fileEnv() {
                 // resolved is null when import path is erroneous and doesn't actually point to a file
                 if (!resolved)
                     return;
-                const modulePath = resolved.id.split('?')[0];
+                const moduleId = resolved.id;
+                const modulePath = moduleId.split('?')[0];
                 // `.server.js` and `.client.js` should only apply to user files
                 if (modulePath.includes('/node_modules/'))
                     return;
                 // TODO/v1-release: remove
+                // - I don't remember exactly, but I think I've added `TODO/v1-release: remove` because I vaguely remember that we can remove this after we remove the 0.4 design.
                 if (modulePath.endsWith('.css'))
                     return;
                 const isServerSide = options?.ssr;
@@ -55,7 +58,7 @@ function fileEnv() {
                     return;
                 // Show error message
                 let errMsg;
-                let modulePathPretty = getFilePathAbsoluteUserRootDir(modulePath, config.root);
+                let modulePathPretty = getModuleFilePath(moduleId, config);
                 modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
                 errMsg = `${capitalizeFirstLetter(envExpect)}-only module ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
                 if (importer &&
@@ -63,7 +66,7 @@ function fileEnv() {
                     !importer.includes('virtual:vike:') &&
                     // I don't know why and who sets importer to '<stdin>' (I guess Vite?)
                     importer !== '<stdin>') {
-                    const importerPath = getFilePathAbsoluteUserRootDir(importer.split('?')[0], config.root);
+                    const importerPath = getModuleFilePath(importer, config);
                     errMsg += ` by ${importerPath}`;
                 }
                 if (isDev) {

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

@@ -3,12 +3,13 @@ import { normalizePath } from 'vite';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { getVirtualFilePageConfigValuesAll } from './v1-design/getVirtualFilePageConfigValuesAll.js';
 import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
-import { assert, assertPosixPath, getFilePathAbsoluteUserRootDir, getOutDirs, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
+import { assert, assertPosixPath, getOutDirs, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo, clearLogs } from '../../shared/loggerNotProd.js';
+import { getFilePathResolved } from '../../shared/getFilePath.js';
 function importUserCode() {
     let config;
     let configVike;
@@ -118,8 +119,11 @@ function isVikeConfigModule(filePathAbsoluteFilesystem) {
 }
 function reloadConfig(filePath, config, op) {
     {
-        const filePathToShowToUser = pc.dim(getFilePathAbsoluteUserRootDir(filePath, config.root, true));
-        const msg = `${op} ${filePathToShowToUser}`;
+        const { filePathToShowToUserResolved } = getFilePathResolved({
+            filePathAbsoluteFilesystem: filePath,
+            userRootDir: config.root
+        });
+        const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }
     reloadVikeConfig(config.root, getOutDirs(config).outDirRoot);

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

@@ -9,7 +9,7 @@ import pc from '@brillout/picocolors';
 import { parseImportData } from './transformFileImports.js';
 import { getConfigFileExport } from '../getConfigFileExport.js';
 import { assertImportPath, resolveImportPath } from './resolveImportPath.js';
-import { getFilePathResolved } from './getFilePath.js';
+import { getFilePathResolved } from '../../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
 // Load fake import
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
@@ -76,7 +76,11 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     return { extendsConfigs, extendsFilePaths };
 }
 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 });
+    // We preserve this feature because we may need it for eject
+    assertWarning(isNpmPackageImport(importPath, {
+        // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
+        cannotBePathAlias: true
+    }) || importPath.includes('/node_modules/'), `${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 });
 }
 function getExtendsImportData(configFileExports, configFilePath) {
     const { filePathToShowToUser } = configFilePath;

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

@@ -6,7 +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 './getFilePath.js';
+import { getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
 const filesEnvMap = new Map();
 function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
@@ -18,6 +18,7 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
     const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
     assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
     const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
+    let filePath;
     if (importPath.startsWith('.')) {
         // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
         // ```
@@ -25,28 +26,30 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // ```
         assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
         const filePathAbsoluteUserRootDir = resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
-        const filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null });
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        const filePath = getFilePathUnresolved({
-            filePathAbsoluteFilesystem,
-            filePathAbsoluteUserRootDir: null,
-            importPathAbsolute: importPath
-        });
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        if (filePathAbsoluteFilesystem) {
+            filePath = getFilePathResolved({
+                userRootDir,
+                filePathAbsoluteFilesystem,
+                importPathAbsolute: importPath
+            });
+        }
+        else {
+            filePath = getFilePathUnresolved({
+                importPathAbsolute: importPath
+            });
+        }
     }
+    return {
+        ...filePath,
+        fileExportName: exportName,
+        fileExportPathToShowToUser
+    };
 }
 function resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
@@ -74,7 +77,8 @@ function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
     const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
+    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer)
+    // https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
     // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
     const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
     return filePathAbsoluteFilesystem;

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

@@ -70,7 +70,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         outfile: path.posix.join(
         // Needed for correct inline source map
         entryFileDir, 
-        // `write: false` => no file is actually be emitted
+        // `write: false` => no file is actually emitted
         'NEVER_EMITTED.js'),
         logLevel: 'silent',
         format: 'esm',
@@ -102,10 +102,10 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                             return;
                         if (args.pluginData?.[useEsbuildResolver])
                             return;
-                        const isImportAbsolute = !args.path.startsWith('.');
                         const { path, ...opts } = args;
                         opts.pluginData = { [useEsbuildResolver]: true };
                         const resolved = await build.resolve(path, opts);
+                        resolved.path = toPosixPath(resolved.path);
                         // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
                         //  - This is temporary, see comment below.
                         const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
@@ -120,14 +120,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                             //  - For example if esbuild cannot resolve a path alias while Vite can.
                             //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
                             resolved.errors.length > 0;
-                        pointerImports_[args.path] = isPointerImport;
+                        pointerImports_[resolved.path] = isPointerImport;
+                        assertPosixPath(resolved.path);
                         const isExternal = isPointerImport ||
-                            // npm package imports that aren't pointer imports (e.g. Vite plugin import)
-                            isImportAbsolute;
+                            // npm package imports that aren't pointer imports (e.g. importing a Vite plugin)
+                            resolved.path.includes('/node_modules/');
                         if (debug.isEnabled)
                             debug('onResolved()', { args, resolved, isPointerImport, isExternal });
                         if (isExternal) {
-                            return { external: true, path: args.path };
+                            return { external: true, path: resolved.path };
                         }
                         else {
                             return resolved;

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 { getFilePathResolved } from './getVikeConfig/getFilePath.js';
+import { getFilePathResolved } from '../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -740,7 +740,7 @@ function getComputed(configValueSources, configDefinitions) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null }));
+    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
 function getConfigName(filePath) {
@@ -1007,7 +1007,11 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after whether the config value was defined by an npm package
         .sort(makeFirst(([, [source]]) => {
         const { importPathAbsolute } = source.definedAt;
-        return !!importPathAbsolute && isNpmPackageImport(importPathAbsolute);
+        return (!!importPathAbsolute &&
+            isNpmPackageImport(importPathAbsolute, {
+                // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
+                cannotBePathAlias: true
+            }));
     }))
         // Sort after the filesystem inheritance of the config value
         .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));

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

@@ -0,0 +1,21 @@
+export { getFilePathResolved };
+export { getFilePathUnresolved };
+export { getModuleFilePath };
+export { getFilePathToShowToUserFromUnkown };
+export { cleanFilePathUnkown };
+import type { FilePath, FilePathResolved } from '../../../shared/page-configs/FilePath.js';
+import type { ResolvedConfig } from 'vite';
+declare function getFilePathUnresolved({ importPathAbsolute }: {
+    importPathAbsolute: string;
+}): FilePath;
+declare function getFilePathResolved(args: {
+    userRootDir: string;
+    importPathAbsolute?: string;
+} & ({
+    filePathAbsoluteFilesystem: string;
+} | {
+    filePathAbsoluteUserRootDir: string;
+})): FilePathResolved;
+declare function getModuleFilePath(moduleId: string, config: ResolvedConfig): string;
+declare function getFilePathToShowToUserFromUnkown(filePathUnkown: string, userRootDir: string): string;
+declare function cleanFilePathUnkown(filePathUnknown: string): string;

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

@@ -0,0 +1,136 @@
+export { getFilePathResolved };
+export { getFilePathUnresolved };
+export { getModuleFilePath };
+export { getFilePathToShowToUserFromUnkown };
+export { cleanFilePathUnkown };
+import path from 'path';
+import { assert, assertPathIsFilesystemAbsolute, assertPosixPath, toPosixPath } from '../utils.js';
+function getFilePathUnresolved({ importPathAbsolute }) {
+    return getFilePath({ importPathAbsolute, filePathAbsoluteUserRootDir: null });
+}
+function getFilePathResolved(args) {
+    const { userRootDir } = args;
+    const importPathAbsolute = args.importPathAbsolute ?? null;
+    let filePathAbsoluteFilesystem;
+    let filePathAbsoluteUserRootDir;
+    if ('filePathAbsoluteFilesystem' in args) {
+        filePathAbsoluteFilesystem = args.filePathAbsoluteFilesystem;
+        filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
+    }
+    else {
+        filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
+        filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
+    }
+    let filePath;
+    const common = {
+        filePathAbsoluteUserRootDir,
+        importPathAbsolute,
+        userRootDir
+    };
+    if (importPathAbsolute) {
+        filePath = getFilePath({
+            ...common,
+            importPathAbsolute
+        });
+    }
+    else {
+        assert(filePathAbsoluteUserRootDir);
+        filePath = getFilePath({
+            ...common,
+            filePathAbsoluteUserRootDir
+        });
+    }
+    assert(filePathAbsoluteFilesystem);
+    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+    assert(filePathToShowToUserResolved);
+    const filePathResolved = {
+        ...filePath,
+        filePathAbsoluteFilesystem,
+        filePathToShowToUserResolved
+    };
+    return filePathResolved;
+}
+function getFilePath(args) {
+    let filePathAbsoluteVite;
+    if (args.filePathAbsoluteUserRootDir !== null) {
+        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
+    }
+    else {
+        assert(args.importPathAbsolute !== null); // Help TS
+        filePathAbsoluteVite = args.importPathAbsolute;
+    }
+    const filePathToShowToUser = filePathAbsoluteVite;
+    assert(filePathToShowToUser);
+    return {
+        ...args,
+        filePathAbsoluteFilesystem: null,
+        filePathAbsoluteVite,
+        filePathToShowToUser
+    };
+}
+function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
+    assertPosixPath(filePathAbsoluteUserRootDir);
+    assertPosixPath(userRootDir);
+    assertPathIsFilesystemAbsolute(userRootDir);
+    const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathAbsoluteUserRootDir);
+    assertPathIsFilesystemAbsolute(userRootDir);
+    return filePathAbsoluteFilesystem;
+}
+function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    assertPosixPath(userRootDir);
+    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    assertPathIsFilesystemAbsolute(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}`;
+    assert(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
+    return filePathAbsoluteUserRootDir;
+}
+function getModuleFilePath(moduleId, config) {
+    const userRootDir = config.root;
+    assertPosixPath(moduleId);
+    assertPosixPath(userRootDir);
+    const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
+    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir });
+    return filePath.filePathToShowToUserResolved;
+}
+function getFilePathToShowToUserFromUnkown(
+// We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
+filePathUnkown, userRootDir) {
+    assertPosixPath(userRootDir);
+    assertPathIsFilesystemAbsolute(userRootDir);
+    filePathUnkown = cleanFilePathUnkown(filePathUnkown);
+    if (!filePathUnkown.startsWith(userRootDir)) {
+        return filePathUnkown;
+    }
+    else {
+        return getFilePathAbsoluteUserRootDir2(filePathUnkown, userRootDir);
+    }
+}
+function getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir) {
+    assert(filePathAbsoluteFilesystem.startsWith(userRootDir));
+    let filePathAbsoluteUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
+    if (!filePathAbsoluteUserRootDir.startsWith('/'))
+        filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir;
+    return filePathAbsoluteUserRootDir;
+}
+function cleanFilePathUnkown(filePathUnknown) {
+    filePathUnknown = toPosixPath(filePathUnknown);
+    filePathUnknown = cleanModuleId(filePathUnknown);
+    return filePathUnknown;
+}
+function cleanModuleId(moduleId) {
+    // remove query
+    const parts = moduleId.split('?');
+    if (parts.length > 1)
+        parts.pop();
+    assert(parts.length >= 1);
+    return parts.join('?');
+}

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

@@ -7,7 +7,8 @@ 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, getFilePathAbsoluteUserRootDir, isObject, removeEmptyLines, stripAnsi, toPosixPath } from '../../utils.js';
+import { assert, escapeRegex, isObject, removeEmptyLines, stripAnsi } from '../../utils.js';
+import { cleanFilePathUnkown, getFilePathToShowToUserFromUnkown } from '../getFilePath.js';
 function isErrorWithCodeSnippet(err) {
     if (!isObject(err)) {
         return false;
@@ -46,7 +47,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     let { id, frame } = err;
     const msgFirstLine = [
         pc.red('Failed to transpile'),
-        pc.bold(pc.red(getFilePathAbsoluteUserRootDir(normalizeId(id), userRootDir))),
+        pc.bold(pc.red(getFilePathToShowToUserFromUnkown(id, userRootDir))),
         pc.red('because:')
     ].join(' ');
     const errMsg = getPrettyErrMessage(err);
@@ -85,7 +86,7 @@ function getPrettyErrMessage(err) {
     // Remove "/home/rom/code/vike/examples/react-full/components/Counter.tsx:1:8:" (redundant since we already print the filename)
     const pos = /(?:\:\d+|)/;
     errMsg = errMsg.split(reg([id, pos, pos, trail], 'gi')).join('');
-    errMsg = errMsg.split(reg([normalizeId(id), pos, pos, trail], 'gi')).join('');
+    errMsg = errMsg.split(reg([cleanFilePathUnkown(id), pos, pos, trail], 'gi')).join('');
     // Remove "ERROR:" (useless)
     errMsg = errMsg.split(reg(['ERROR:', trail])).join('');
     // Remove "Internal server error:" (useless)
@@ -155,9 +156,3 @@ function isEquivalentErrorWithCodeSnippet(err1, err2) {
 function isDefinedAndSame(val1, val2) {
     return val1 && val1 === val2;
 }
-function normalizeId(id) {
-    id = toPosixPath(id);
-    // remove query
-    id = id.split('?')[0];
-    return id;
-}

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

@@ -14,7 +14,7 @@ export { clearLogs };
 import { isAbortError } from '../../../shared/route/abort.js';
 import { getViteConfig } from '../../runtime/globalContext.js';
 import { overwriteRuntimeProductionLogger } from '../../runtime/renderPage/loggerRuntime.js';
-import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, isUserHookError, overwriteAssertProductionLogger, stripAnsi, warnIfErrorIsNotObject } from '../utils.js';
+import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, overwriteAssertProductionLogger, stripAnsi, warnIfErrorIsNotObject } from '../utils.js';
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { isErrorDebug } from './isErrorDebug.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
@@ -24,6 +24,7 @@ import pc from '@brillout/picocolors';
 import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';
 import { isConfigInvalid } from '../../runtime/renderPage/isConfigInvalid.js';
 import { onRuntimeError } from '../../runtime/renderPage/loggerProd.js';
+import { isUserHookError } from '../../../shared/hooks/executeHook.js';
 assertIsNotProductionRuntime();
 overwriteRuntimeProductionLogger(logRuntimeError, logRuntimeInfo);
 overwriteAssertProductionLogger(assertLogger);

package/dist/esm/node/plugin/utils.d.ts

@@ -1,6 +1,5 @@
 export * from '../runtime/utils.js';
 export * from '../../utils/viteIsSSR.js';
-export * from '../../utils/getFilePathAbsolute.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
@@ -20,3 +19,4 @@ export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
+export * from '../../utils/assertPathIsFilesystemAbsolute.js';

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

@@ -6,7 +6,6 @@ onLoad();
 export * from '../runtime/utils.js';
 // Utils only needed by `plugin/*`
 export * from '../../utils/viteIsSSR.js';
-export * from '../../utils/getFilePathAbsolute.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
@@ -26,3 +25,4 @@ export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
+export * from '../../utils/assertPathIsFilesystemAbsolute.js';

package/dist/esm/node/prerender/runPrerender.js

@@ -5,8 +5,7 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, isUserHookError, handleNodeEnv_prerender } from './utils.js';
-import { pLimit } from '../../utils/pLimit.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, assertPathIsFilesystemAbsolute } from './utils.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -20,13 +19,13 @@ import { getConfigValue, getConfigValueFilePathToShowToUser } from '../../shared
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
-import { assertPathIsFilesystemAbsolute } from '../../utils/assertPathIsFilesystemAbsolute.js';
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
+import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.

package/dist/esm/node/prerender/utils.d.ts

@@ -8,6 +8,7 @@ export * from '../../utils/getOutDirs.js';
 export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertNodeEnv.js';
+export * from '../../utils/pLimit.js';
+export * from '../../utils/assertPathIsFilesystemAbsolute.js';

package/dist/esm/node/prerender/utils.js

@@ -10,6 +10,7 @@ export * from '../../utils/getOutDirs.js';
 export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertNodeEnv.js';
+export * from '../../utils/pLimit.js';
+export * from '../../utils/assertPathIsFilesystemAbsolute.js';

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

@@ -1,8 +1,8 @@
 export { executeOnBeforeRenderAndDataHooks };
 import { getHook } from '../../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
-import { executeHook } from '../utils.js';
 import { assertOnBeforeRenderHookReturn } from '../../../shared/assertOnBeforeRenderHookReturn.js';
+import { executeHook } from '../../../shared/hooks/executeHook.js';
 async function executeOnBeforeRenderAndDataHooks(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;

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

@@ -1,13 +1,14 @@
 export { executeOnRenderHtmlHook };
 import { isDocumentHtml, renderDocumentHtml, dangerouslySkipEscape } from '../html/renderHtml.js';
 import { getHook } from '../../../shared/hooks/getHook.js';
-import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, executeHook, isCallable } from '../utils.js';
+import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, isCallable } from '../utils.js';
 import { isStream } from '../html/stream.js';
 import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
 import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 import { assertHookReturnedObject } from '../../../shared/assertHookReturnedObject.js';
 import { logRuntimeError } from './loggerRuntime.js';
 import pc from '@brillout/picocolors';
+import { executeHook } from '../../../shared/hooks/executeHook.js';
 async function executeOnRenderHtmlHook(pageContext) {
     const { renderHook, hookFn } = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: renderHook });

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

@@ -1,10 +1,8 @@
 export { getManifestEntry };
-import { assert, slice, isNpmPackageImport } from '../../utils.js';
-import { assertClientEntryId } from './assertClientEntryId.js';
+import { assert, slice, assertIsNpmPackageImport } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
 function getManifestEntry(id, assetsManifest) {
-    assertClientEntryId(id);
     const debugInfo = getDebugInfo(id, assetsManifest);
     // Vike client entry
     if (id.startsWith('@@vike/')) {
@@ -42,12 +40,11 @@ function getManifestEntry(id, assetsManifest) {
         return { manifestEntry, manifestKey };
     }
     // npm package import
-    if (isNpmPackageImport(id)) {
-        const found = Object.entries(assetsManifest).find(([, e]) => e.name === prependEntriesDir(id));
-        assert(found);
-        const [manifestKey, manifestEntry] = found;
-        return { manifestEntry, manifestKey };
-    }
+    assertIsNpmPackageImport(id);
+    const found = Object.entries(assetsManifest).find(([, e]) => e.name === prependEntriesDir(id));
+    assert(found);
+    const [manifestKey, manifestEntry] = found;
+    return { manifestEntry, manifestKey };
     /* Can we remove this?
     // extensions[number].pageConfigsSrcDir
     if (id.startsWith('/node_modules/') || id.startsWith('/../')) {
@@ -79,7 +76,6 @@ function getManifestEntry(id, assetsManifest) {
       assert(false, debugInfo)
     }
     */
-    assert(false, debugInfo);
 }
 function findEntryWithKeyEnd(manifestKeyEnd, assetsManifest, id) {
     const debugInfo = getDebugInfo(id, assetsManifest, manifestKeyEnd);

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

@@ -9,15 +9,16 @@ function retrieveAssetsProd(clientDependencies, assetsManifest, includeAssetsImp
     clientDependencies.forEach(({ id, onlyAssets, eagerlyImported }) => {
         if (eagerlyImported)
             return; // Eagerly imported assets aren't imported with import() and therefore don't create a new Rollup entry and aren't listed in the manifest file
-        if (onlyAssets) {
-            if (!includeAssetsImportedByServer)
-                return;
+        // TODO/v1-release: remove
+        if (includeAssetsImportedByServer &&
+            onlyAssets &&
+            id.includes('.page.server.') &&
             // We assume that all npm packages have already built their files: bundlers (Rollup, esbuild, tsup, ...) extract the CSS out of JavaScript => we can assume JavaScript to not import any CSS/assets.
-            if (isNpmPackageImport(id))
-                return;
-            if (id.includes('.page.server.')) {
-                id = extractAssetsAddQuery(id);
-            }
+            !isNpmPackageImport(id, {
+                // I presume Vite already resolves path aliases when Vite sets the module's id
+                cannotBePathAlias: true
+            })) {
+            id = extractAssetsAddQuery(id);
         }
         const { manifestKey } = getManifestEntry(id, assetsManifest);
         collectAssets(manifestKey, assetUrls, visistedAssets, assetsManifest, onlyAssets);