vike 0.4.166 → 0.4.167

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

@@ -18,6 +18,7 @@ const path_1 = __importDefault(require("path"));
 const fixServerAssets_js_1 = require("./buildConfig/fixServerAssets.js");
 const index_js_1 = require("./importBuild/index.js");
 const prependEntriesDir_js_1 = require("../../shared/prependEntriesDir.js");
+const getFilePath_js_1 = require("../shared/getFilePath.js");
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
@@ -205,18 +206,22 @@ async function getPageFileEntries(config, includeAssetsImportedByServer) {
     return pageFileEntries;
 }
 function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
-    if ((0, utils_js_1.isNpmPackageImport)(clientEntry)) {
+    if (!clientEntry.startsWith('/')) {
+        (0, utils_js_1.assertIsNpmPackageImport)(clientEntry);
         const entryTarget = clientEntry;
         const entryName = (0, prependEntriesDir_js_1.prependEntriesDir)(clientEntry);
         return { entryName, entryTarget };
     }
-    const filePath = clientEntry;
-    (0, utils_js_1.assertPosixPath)(filePath);
-    (0, utils_js_1.assert)(filePath.startsWith('/'));
-    let entryTarget = (0, utils_js_1.getFilePathAbsoluteFilesystem)(filePath, config);
+    const filePathAbsoluteUserRootDir = clientEntry;
+    (0, utils_js_1.assert)(filePathAbsoluteUserRootDir.startsWith('/'));
+    const filePath = (0, getFilePath_js_1.getFilePathResolved)({
+        filePathAbsoluteUserRootDir,
+        userRootDir: config.root
+    });
+    let entryTarget = filePath.filePathAbsoluteFilesystem;
     if (addExtractAssetsQuery)
         entryTarget = (0, extractAssetsQuery_js_1.extractAssetsAddQuery)(entryTarget);
-    let entryName = filePath;
+    let entryName = filePathAbsoluteUserRootDir;
     if (addExtractAssetsQuery)
         entryName = (0, extractAssetsQuery_js_1.extractAssetsAddQuery)(entryName);
     entryName = (0, utils_js_1.removeFileExtention)(entryName);

package/dist/cjs/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -18,8 +18,9 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 //   - Aliases react imports
 // - @vitejs/plugin-vue2
 //   - https://github.com/vikejs/vike/issues/1329
-// TODO/v1-release: replace assertWarning() with assertUsage()
 function assertResolveAlias(config) {
+    // TODO: re-implement warning https://github.com/vikejs/vike/issues/1567
+    return;
     const aliases = getAliases(config);
     const errPrefix = config.configFile || 'Your Vite configuration';
     const errSuffix1 = 'see https://vike.dev/path-aliases#vite';

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

@@ -7,6 +7,8 @@ const getVikeConfig_js_1 = require("../importUserCode/v1-design/getVikeConfig.js
 const getConfigValueSourcesNotOverriden_js_1 = require("../../shared/getConfigValueSourcesNotOverriden.js");
 const buildConfig_js_1 = require("../buildConfig.js");
 const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
+const getFilePath_js_1 = require("../../shared/getFilePath.js");
+const debug = (0, utils_js_1.createDebugger)('vike:optimizeDeps');
 async function determineOptimizeDeps(config, isDev) {
     const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config, isDev);
     const { entries, include } = await getPageDeps(config, pageConfigs, isDev);
@@ -23,7 +25,11 @@ async function determineOptimizeDeps(config, isDev) {
     */
     config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
     config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
-    // console.log('config.optimizeDeps', { entries: config.optimizeDeps.entries, include: config.optimizeDeps.include })
+    if (debug.isActivated)
+        debug('config.optimizeDeps', {
+            'config.optimizeDeps.entries': config.optimizeDeps.entries,
+            'config.optimizeDeps.include': config.optimizeDeps.include
+        });
 }
 exports.determineOptimizeDeps = determineOptimizeDeps;
 async function getPageDeps(config, pageConfigs, isDev) {
@@ -47,24 +53,10 @@ async function getPageDeps(config, pageConfigs, isDev) {
                 else {
                     // Adding definedAt.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
                     const { importPathAbsolute } = definedAt;
-                    (0, utils_js_1.assert)(importPathAbsolute);
-                    // We need to differentiate between npm package imports and path aliases.
-                    // There are path aliases that cannot be distinguished from npm package names.
-                    // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
-                    if ((0, utils_js_1.isNpmPackageImport)(importPathAbsolute)) {
-                        // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
-                        (0, utils_js_1.assert)(!importPathAbsolute.startsWith('#'));
-                        include.push(importPathAbsolute);
-                    }
-                    else {
-                        /* Path aliases, e.g.:
-                         * ```js
-                         * // /renderer/+config.js
-                         * import onRenderClient from '#root/renderer/onRenderClient'
-                         * ```
-                         */
-                        entries.push(importPathAbsolute);
-                    }
+                    (0, utils_js_1.assert)(importPathAbsolute); // Help TS
+                    // Shouldn't be a path alias, as path aliases would need to be added to config.optimizeDeps.entries instead of config.optimizeDeps.include
+                    (0, utils_js_1.assertIsNpmPackageImport)(importPathAbsolute);
+                    include.push(importPathAbsolute);
                 }
             });
         });
@@ -72,9 +64,12 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V0.4 design
     {
         const pageFiles = await (0, findPageFiles_js_1.findPageFiles)(config, ['.page', '.page.client'], isDev);
-        pageFiles.forEach((filePath) => {
-            const entry = (0, utils_js_1.getFilePathAbsoluteFilesystem)(filePath, config);
-            entries.push(entry);
+        const userRootDir = config.root;
+        pageFiles.forEach((filePathAbsoluteUserRootDir) => {
+            const entry = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
+            const { filePathAbsoluteFilesystem } = entry;
+            (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
+            entries.push(filePathAbsoluteFilesystem);
         });
     }
     entries = (0, utils_js_1.unique)(entries);

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

@@ -4,6 +4,7 @@ exports.applyEnvVar = exports.envVarsPlugin = void 0;
 const vite_1 = require("vite");
 const utils_js_1 = require("../utils.js");
 const rollupSourceMap_js_1 = require("../shared/rollupSourceMap.js");
+const getFilePath_js_1 = require("../shared/getFilePath.js");
 function envVarsPlugin() {
     let envsAll;
     let config;
@@ -45,10 +46,10 @@ function envVarsPlugin() {
                     if (isPrivate && isClientSide) {
                         if (!code.includes(envStatement))
                             return;
-                        const filePathToShowToUser = (0, utils_js_1.getFilePathAbsoluteUserRootDir)(id, config.root);
+                        const modulePath = (0, getFilePath_js_1.getModuleFilePath)(id, config);
                         const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
                         const keyPublic = `${publicPrefix}${envName}`;
-                        const errMsg = `${envStatement} is used in client-side file ${filePathToShowToUser} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${keyPublic}, see https://vike.dev/env`;
+                        const errMsg = `${envStatement} is used in client-side file ${modulePath} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${keyPublic}, see https://vike.dev/env`;
                         if (isBuild) {
                             (0, utils_js_1.assertUsage)(false, errMsg);
                         }

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

@@ -21,9 +21,7 @@ exports.extractAssetsRE = extractAssetsRE;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
 const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
-const debugNamespace = 'vike:extractAssets';
-const debug = (0, utils_js_1.createDebugger)(debugNamespace);
-const debugEnabled = (0, utils_js_1.isDebugEnabled)(debugNamespace);
+const debug = (0, utils_js_1.createDebugger)('vike:extractAssets');
 function extractAssetsPlugin() {
     let config;
     let configVike;
@@ -120,12 +118,6 @@ function extractAssetsPlugin() {
         {
             name: 'vike:extractAssets-3',
             apply: 'build',
-            async configResolved(config_) {
-                configVike = await (0, getConfigVike_js_1.getConfigVike)(config_);
-                config = config_;
-                vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(config, false);
-                isServerAssetsFixEnabled = (0, fixServerAssets_js_1.fixServerAssets_isEnabled)() && (await (0, getVikeConfig_js_1.isV1Design)(config, false));
-            },
             load(id) {
                 if (!(0, utils_js_1.isVirtualFileId)(id))
                     return undefined;
@@ -135,16 +127,22 @@ function extractAssetsPlugin() {
                 }
             },
             config() {
-                if (debugEnabled) {
+                if (debug.isActivated) {
                     return { logLevel: 'silent' };
                 }
             }
         },
         {
             name: 'vike:extractAssets-4',
-            configResolved(config) {
-                // https://github.com/vikejs/vike/issues/1060
-                (0, utils_js_1.assertUsage)(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
+            async configResolved(config_) {
+                configVike = await (0, getConfigVike_js_1.getConfigVike)(config_);
+                config = config_;
+                vikeConfig = await (0, getVikeConfig_js_1.getVikeConfig)(config, false);
+                isServerAssetsFixEnabled = (0, fixServerAssets_js_1.fixServerAssets_isEnabled)() && (await (0, getVikeConfig_js_1.isV1Design)(config, false));
+                if (!isServerAssetsFixEnabled) {
+                    // https://github.com/vikejs/vike/issues/1060
+                    (0, utils_js_1.assertUsage)(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
+                }
             }
         }
     ];

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

@@ -6,9 +6,7 @@ const parseEsModule_js_1 = require("../shared/parseEsModule.js");
 const rollupSourceMap_js_1 = require("../shared/rollupSourceMap.js");
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 exports.extractExportNamesRE = extractExportNamesRE;
-const debugNamespace = 'vike:extractExportNames';
-const debug = (0, utils_js_1.createDebugger)(debugNamespace);
-const debugEnabled = (0, utils_js_1.isDebugEnabled)(debugNamespace);
+const debug = (0, utils_js_1.createDebugger)('vike:extractExportNames');
 const globalObject = (0, utils_js_1.getGlobalObject)('extractExportNamesPlugin.ts', {});
 function extractExportNamesPlugin() {
     let isDev = false;
@@ -27,7 +25,7 @@ function extractExportNamesPlugin() {
             isDev = true;
         },
         config() {
-            if (debugEnabled) {
+            if (debug.isActivated) {
                 return { logLevel: 'silent' };
             }
         }

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

@@ -8,6 +8,7 @@ const utils_js_1 = require("../utils.js");
 const extractAssetsPlugin_js_1 = require("./extractAssetsPlugin.js");
 const extractExportNamesPlugin_js_1 = require("./extractExportNamesPlugin.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const getFilePath_js_1 = require("../shared/getFilePath.js");
 function fileEnv() {
     let config;
     let isDev = false;
@@ -44,11 +45,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;
@@ -60,7 +63,7 @@ function fileEnv() {
                     return;
                 // Show error message
                 let errMsg;
-                let modulePathPretty = (0, utils_js_1.getFilePathAbsoluteUserRootDir)(modulePath, config.root);
+                let modulePathPretty = (0, getFilePath_js_1.getModuleFilePath)(moduleId, config);
                 modulePathPretty = modulePathPretty.replaceAll(suffix, picocolors_1.default.bold(suffix));
                 errMsg = `${(0, utils_js_1.capitalizeFirstLetter)(envExpect)}-only module ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
                 if (importer &&
@@ -68,7 +71,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 = (0, utils_js_1.getFilePathAbsoluteUserRootDir)(importer.split('?')[0], config.root);
+                    const importerPath = (0, getFilePath_js_1.getModuleFilePath)(importer, config);
                     errMsg += ` by ${importerPath}`;
                 }
                 if (isDev) {

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

@@ -14,6 +14,7 @@ const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/vi
 const getVikeConfig_js_1 = require("./v1-design/getVikeConfig.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const loggerNotProd_js_1 = require("../../shared/loggerNotProd.js");
+const getFilePath_js_1 = require("../../shared/getFilePath.js");
 function importUserCode() {
     let config;
     let configVike;
@@ -124,8 +125,11 @@ function isVikeConfigModule(filePathAbsoluteFilesystem) {
 }
 function reloadConfig(filePath, config, op) {
     {
-        const filePathToShowToUser = picocolors_1.default.dim((0, utils_js_1.getFilePathAbsoluteUserRootDir)(filePath, config.root, true));
-        const msg = `${op} ${filePathToShowToUser}`;
+        const { filePathToShowToUserResolved } = (0, getFilePath_js_1.getFilePathResolved)({
+            filePathAbsoluteFilesystem: filePath,
+            userRootDir: config.root
+        });
+        const msg = `${op} ${picocolors_1.default.dim(filePathToShowToUserResolved)}`;
         (0, loggerNotProd_js_1.logConfigInfo)(msg, 'info');
     }
     (0, getVikeConfig_js_1.reloadVikeConfig)(config.root, (0, utils_js_1.getOutDirs)(config).outDirRoot);

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getConfigFileExport.js

@@ -9,9 +9,9 @@ const assertPlusFileExport_js_1 = require("../../../../../shared/page-configs/as
 const utils_js_1 = require("../../../utils.js");
 function getConfigFileExport(fileExports, filePathToShowToUser) {
     (0, assertPlusFileExport_js_1.assertPlusFileExport)(fileExports, filePathToShowToUser, 'config');
-    const fileExport = fileExports.default || fileExports.config;
-    (0, utils_js_1.assert)('default' in fileExports !== 'config' in fileExports);
-    const exportName = picocolors_1.default.cyan('default' in fileExports ? 'export default' : 'export { config }');
+    const usesNamedExport = !!fileExports.config;
+    const fileExport = usesNamedExport ? fileExports.config : fileExports.default;
+    const exportName = picocolors_1.default.cyan(usesNamedExport ? 'export { config }' : 'export default');
     (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(fileExport), `The ${exportName} of ${filePathToShowToUser} should be an object (but it's ${picocolors_1.default.cyan(`typeof exportedValue === ${JSON.stringify(typeof fileExport)}`)} instead)`);
     return fileExport;
 }

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

@@ -82,7 +82,11 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     return { extendsConfigs, extendsFilePaths };
 }
 function warnUserLandExtension(importPath, configFilePath) {
-    (0, utils_js_1.assertWarning)((0, utils_js_1.isNpmPackageImport)(importPath), `${configFilePath.filePathToShowToUser} uses ${picocolors_1.default.cyan('extends')} to inherit from ${picocolors_1.default.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
+    (0, utils_js_1.assertWarning)((0, utils_js_1.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 ${picocolors_1.default.cyan('extends')} to inherit from ${picocolors_1.default.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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveImportPath.js

@@ -20,6 +20,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:
         // ```
@@ -27,28 +28,30 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // ```
         assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
         const filePathAbsoluteUserRootDir = resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
-        const filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null });
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        const filePath = (0, getFilePath_js_1.getFilePathUnresolved)({
-            filePathAbsoluteFilesystem,
-            filePathAbsoluteUserRootDir: null,
-            importPathAbsolute: importPath
-        });
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        if (filePathAbsoluteFilesystem) {
+            filePath = (0, getFilePath_js_1.getFilePathResolved)({
+                userRootDir,
+                filePathAbsoluteFilesystem,
+                importPathAbsolute: importPath
+            });
+        }
+        else {
+            filePath = (0, getFilePath_js_1.getFilePathUnresolved)({
+                importPathAbsolute: importPath
+            });
+        }
     }
+    return {
+        ...filePath,
+        fileExportName: exportName,
+        fileExportPathToShowToUser
+    };
 }
 exports.resolveImport = resolveImport;
 function resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
@@ -77,7 +80,8 @@ function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
     const cwd = path_1.default.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 = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
     return filePathAbsoluteFilesystem;

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

@@ -40,10 +40,10 @@ async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     getVikeConfig_js_1.vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug('transpile', filePathToShowToUserResolved);
     let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
@@ -51,12 +51,12 @@ async function transpileFile(filePath, transformImports, userRootDir) {
         if (codeMod) {
             code = codeMod;
             isImportTransformed = true;
-            if (debug.isEnabled)
+            if (debug.isActivated)
                 debug(`code, post transformImports() (${filePathToShowToUserResolved})`, code);
         }
     }
     if (!isImportTransformed) {
-        if (debug.isEnabled)
+        if (debug.isActivated)
             debug(`code, no transformImports() (${filePathToShowToUserResolved})`);
     }
     return code;
@@ -73,7 +73,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         outfile: path_1.default.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',
@@ -105,10 +105,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 = (0, utils_js_1.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');
@@ -123,14 +123,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;
+                        (0, utils_js_1.assertPosixPath)(resolved.path);
                         const isExternal = isPointerImport ||
-                            // npm package imports that aren't pointer imports (e.g. Vite plugin import)
-                            isImportAbsolute;
-                        if (debug.isEnabled)
+                            // npm package imports that aren't pointer imports (e.g. importing a Vite plugin)
+                            resolved.path.includes('/node_modules/');
+                        if (debug.isActivated)
                             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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -745,7 +745,7 @@ function getComputed(configValueSources, configDefinitions) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev) {
     const files = await (0, crawlPlusFiles_js_1.crawlPlusFiles)(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null }));
+    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
 function getConfigName(filePath) {
@@ -1013,7 +1013,11 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after whether the config value was defined by an npm package
         .sort((0, utils_js_1.makeFirst)(([, [source]]) => {
         const { importPathAbsolute } = source.definedAt;
-        return !!importPathAbsolute && (0, utils_js_1.isNpmPackageImport)(importPathAbsolute);
+        return (!!importPathAbsolute &&
+            (0, utils_js_1.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]]) => (0, utils_js_1.reverse)((0, filesystemRouting_js_1.sortAfterInheritanceOrder)(source1.locationId, source2.locationId, locationIdPage))));

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

@@ -3,29 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFilePathUnresolved = exports.getFilePathResolved = void 0;
+exports.cleanFilePathUnkown = exports.getFilePathToShowToUserFromUnkown = exports.getModuleFilePath = exports.getFilePathUnresolved = exports.getFilePathResolved = void 0;
 const path_1 = __importDefault(require("path"));
 const utils_js_1 = require("../utils.js");
-function getFilePathUnresolved(args) {
-    const { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir } = args;
-    let filePathAbsoluteVite;
-    if (args.filePathAbsoluteUserRootDir !== null) {
-        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
-    }
-    else {
-        (0, utils_js_1.assert)(args.importPathAbsolute !== null); // Help TS
-        filePathAbsoluteVite = args.importPathAbsolute;
-    }
-    return {
-        ...args,
-        filePathAbsoluteVite,
-        filePathToShowToUser: filePathAbsoluteVite,
-        filePathToShowToUserResolved: filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem
-    };
+function getFilePathUnresolved({ importPathAbsolute }) {
+    return getFilePath({ importPathAbsolute, filePathAbsoluteUserRootDir: null });
 }
 exports.getFilePathUnresolved = getFilePathUnresolved;
 function getFilePathResolved(args) {
-    const { userRootDir, importPathAbsolute } = args;
+    const { userRootDir } = args;
+    const importPathAbsolute = args.importPathAbsolute ?? null;
     let filePathAbsoluteFilesystem;
     let filePathAbsoluteUserRootDir;
     if ('filePathAbsoluteFilesystem' in args) {
@@ -36,41 +23,68 @@ function getFilePathResolved(args) {
         filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
         filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
     }
-    let filePathResolved;
+    let filePath;
     const common = {
         filePathAbsoluteUserRootDir,
-        filePathAbsoluteFilesystem,
         importPathAbsolute,
         userRootDir
     };
     if (importPathAbsolute) {
-        filePathResolved = getFilePathUnresolved({
+        filePath = getFilePath({
             ...common,
             importPathAbsolute
         });
     }
     else {
         (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
-        filePathResolved = getFilePathUnresolved({
+        filePath = getFilePath({
             ...common,
             filePathAbsoluteUserRootDir
         });
     }
     (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(filePathResolved, 'filePathAbsoluteFilesystem', 'string'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(filePathResolved, 'filePathToShowToUserResolved', 'string'));
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+    (0, utils_js_1.assert)(filePathToShowToUserResolved);
+    const filePathResolved = {
+        ...filePath,
+        filePathAbsoluteFilesystem,
+        filePathToShowToUserResolved
+    };
     return filePathResolved;
 }
 exports.getFilePathResolved = getFilePathResolved;
+function getFilePath(args) {
+    let filePathAbsoluteVite;
+    if (args.filePathAbsoluteUserRootDir !== null) {
+        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
+    }
+    else {
+        (0, utils_js_1.assert)(args.importPathAbsolute !== null); // Help TS
+        filePathAbsoluteVite = args.importPathAbsolute;
+    }
+    const filePathToShowToUser = filePathAbsoluteVite;
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return {
+        ...args,
+        filePathAbsoluteFilesystem: null,
+        filePathAbsoluteVite,
+        filePathToShowToUser
+    };
+}
 function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteUserRootDir);
     (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
     const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathAbsoluteUserRootDir);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
     return filePathAbsoluteFilesystem;
 }
 function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
     const filePathRelative = path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
     if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         (0, utils_js_1.assert)(filePathRelative.startsWith('../'));
@@ -78,11 +92,51 @@ function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDi
     }
     (0, utils_js_1.assert)(!filePathRelative.startsWith('.') && !filePathRelative.startsWith('/'));
     const filePathAbsoluteUserRootDir = `/${filePathRelative}`;
-    {
-        let check = filePathAbsoluteFilesystem.slice(userRootDir.length);
-        if (!check.startsWith('/'))
-            check = '/' + check;
-        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir === check);
+    (0, utils_js_1.assert)(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
+    return filePathAbsoluteUserRootDir;
+}
+function getModuleFilePath(moduleId, config) {
+    const userRootDir = config.root;
+    (0, utils_js_1.assertPosixPath)(moduleId);
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir });
+    return filePath.filePathToShowToUserResolved;
+}
+exports.getModuleFilePath = getModuleFilePath;
+function getFilePathToShowToUserFromUnkown(
+// We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
+filePathUnkown, userRootDir) {
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
+    filePathUnkown = cleanFilePathUnkown(filePathUnkown);
+    if (!filePathUnkown.startsWith(userRootDir)) {
+        return filePathUnkown;
     }
+    else {
+        return getFilePathAbsoluteUserRootDir2(filePathUnkown, userRootDir);
+    }
+}
+exports.getFilePathToShowToUserFromUnkown = getFilePathToShowToUserFromUnkown;
+function getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir) {
+    (0, utils_js_1.assert)(filePathAbsoluteFilesystem.startsWith(userRootDir));
+    let filePathAbsoluteUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
+    if (!filePathAbsoluteUserRootDir.startsWith('/'))
+        filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir;
     return filePathAbsoluteUserRootDir;
 }
+function cleanFilePathUnkown(filePathUnknown) {
+    filePathUnknown = (0, utils_js_1.toPosixPath)(filePathUnknown);
+    filePathUnknown = cleanModuleId(filePathUnknown);
+    return filePathUnknown;
+}
+exports.cleanFilePathUnkown = cleanFilePathUnkown;
+function cleanModuleId(moduleId) {
+    // remove query
+    const parts = moduleId.split('?');
+    if (parts.length > 1)
+        parts.pop();
+    (0, utils_js_1.assert)(parts.length >= 1);
+    return parts.join('?');
+}

package/dist/cjs/node/plugin/shared/isErrorDebug.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isErrorDebug = void 0;
 const utils_js_1 = require("../utils.js");
 function isErrorDebug() {
-    return (0, utils_js_1.isDebugEnabled)('vike:error');
+    return (0, utils_js_1.isDebugActivated)('vike:error');
 }
 exports.isErrorDebug = isErrorDebug;