vike 0.4.168 → 0.4.169

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

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.manifestTempFile = exports.analyzeClientEntries = exports.assertRollupInput = exports.buildConfig = void 0;
 const utils_js_1 = require("../utils.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
-const helpers_js_1 = require("../../../shared/page-configs/helpers.js");
+const getConfigValue_js_1 = require("../../../shared/page-configs/getConfigValue.js");
 const findPageFiles_js_1 = require("../shared/findPageFiles.js");
 const getConfigVike_js_1 = require("../../shared/getConfigVike.js");
 const virtualFilePageConfigValuesAll_js_1 = require("../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
@@ -156,7 +156,7 @@ function analyzeClientEntries(pageConfigs, config) {
     let clientEntries = {};
     let clientEntryList = [];
     pageConfigs.forEach((pageConfig) => {
-        const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean');
+        const configValue = (0, getConfigValue_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean');
         if (configValue?.value) {
             hasClientRouting = true;
         }
@@ -232,7 +232,15 @@ function getEntryFromPageConfig(pageConfig, isForClientSide) {
     let { pageId } = pageConfig;
     const entryTarget = (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, isForClientSide);
     let entryName = pageId;
+    // Avoid:
+    // ```
+    // dist/client/assets/entries/.Dp9wM6PK.js
+    // dist/server/entries/.mjs
+    // ```
+    if (entryName === '/')
+        entryName = 'root';
     entryName = (0, prependEntriesDir_js_1.prependEntriesDir)(entryName);
+    (0, utils_js_1.assert)(!entryName.endsWith('/'));
     return { entryName, entryTarget };
 }
 function resolve(filePath) {

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

@@ -80,7 +80,7 @@ function assertResolveAlias(config) {
 exports.assertResolveAlias = assertResolveAlias;
 function getAliases(config) {
     const { alias } = config.resolve;
-    if (!Array.isArray(alias)) {
+    if (!(0, utils_js_1.isArray)(alias)) {
         return [alias];
     }
     else {

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

@@ -35,28 +35,32 @@ exports.determineOptimizeDeps = determineOptimizeDeps;
 async function getPageDeps(config, pageConfigs, isDev) {
     let entries = [];
     let include = [];
+    const addEntry = (e) => {
+        (0, utils_js_1.assert)(e);
+        entries.push(e);
+    };
+    const addInclude = (e) => {
+        (0, utils_js_1.assert)(e);
+        // 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)(e);
+        include.push(e);
+    };
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
             (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
-                const { definedAt, configEnv } = configValueSource;
+                const { definedAtFilePath, configEnv } = configValueSource;
                 if (!configEnv.client)
                     return;
-                if (definedAt.filePathAbsoluteUserRootDir !== null) {
-                    const { filePathAbsoluteFilesystem } = definedAt;
-                    (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
-                    // Surprisingly Vite expects entries to be absolute paths
-                    entries.push(filePathAbsoluteFilesystem);
+                if (definedAtFilePath.filePathAbsoluteUserRootDir !== null) {
+                    // Vite expects entries to be filesystem absolute paths (surprisingly so).
+                    addEntry(definedAtFilePath.filePathAbsoluteFilesystem);
                 }
                 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); // 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);
+                    // Adding definedAtFilePath.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
+                    addInclude(definedAtFilePath.importPathAbsolute);
                 }
             });
         });
@@ -68,8 +72,7 @@ async function getPageDeps(config, pageConfigs, isDev) {
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
             const { filePathAbsoluteFilesystem } = entry;
-            (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
-            entries.push(filePathAbsoluteFilesystem);
+            addEntry(filePathAbsoluteFilesystem);
         });
     }
     entries = (0, utils_js_1.unique)(entries);
@@ -86,7 +89,7 @@ function getVirtualFiles(config, pageConfigs) {
     return entriesVirtualFiles;
 }
 function normalizeEntries(entries) {
-    if (Array.isArray(entries))
+    if ((0, utils_js_1.isArray)(entries))
         return entries;
     if (typeof entries === 'string')
         return [entries];
@@ -95,7 +98,7 @@ function normalizeEntries(entries) {
     (0, utils_js_1.assert)(false);
 }
 function normalizeInclude(include) {
-    if (Array.isArray(include))
+    if ((0, utils_js_1.isArray)(include))
         return include;
     if (include === undefined)
         return [];

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

@@ -116,6 +116,12 @@ function clean(name, removePathSep, fixGlob) {
     }
     name = removeLeadingUnderscoreInFilename(name);
     name = removeUnderscoreDoublets(name);
+    // Avoid:
+    // ```
+    // dist/client/assets/entries/.Dp9wM6PK.js
+    // dist/server/entries/.mjs
+    // ```
+    (0, utils_js_1.assert)(!name.endsWith('/'));
     return name;
 }
 function fixExtractAssetsQuery(name) {
@@ -165,7 +171,7 @@ function getRollupOutputs(config) {
     (_a = config.build).rollupOptions ?? (_a.rollupOptions = {});
     (_b = config.build.rollupOptions).output ?? (_b.output = {});
     const { output } = config.build.rollupOptions;
-    if (!Array.isArray(output)) {
+    if (!(0, utils_js_1.isArray)(output)) {
         return [output];
     }
     return output;

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

@@ -30,11 +30,7 @@ function envVarsPlugin() {
             Object.entries(envsAll)
                 .filter(([key]) => {
                 // Already handled by Vite
-                const envPrefix = !config.envPrefix
-                    ? []
-                    : Array.isArray(config.envPrefix)
-                        ? config.envPrefix
-                        : [config.envPrefix];
+                const envPrefix = !config.envPrefix ? [] : (0, utils_js_1.isArray)(config.envPrefix) ? config.envPrefix : [config.envPrefix];
                 return !envPrefix.some((prefix) => key.startsWith(prefix));
             })
                 .forEach(([envName, envVal]) => {

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

@@ -189,7 +189,7 @@ function analyzeImport(importStatement) {
     if (rawRE.test(moduleName)) {
         return { moduleName, skip: true };
     }
-    /* We should not do this because of aliased imports
+    /* We shouldn't do this because of aliased imports
     if (!moduleName.startsWith('.')) {
       return { moduleName, skip: true }
     }

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

@@ -18,9 +18,11 @@ const getFilePath_js_1 = require("../../shared/getFilePath.js");
 function importUserCode() {
     let config;
     let configVike;
+    let isDev_;
     return {
         name: 'vike:importUserCode',
-        config() {
+        config(_, env) {
+            isDev_ = (0, utils_js_1.isDev3)(env);
             return {
                 experimental: {
                     // TODO/v1-release: remove
@@ -48,7 +50,7 @@ function importUserCode() {
             }
         },
         async load(id, options) {
-            const isDev = (0, utils_js_1.isDev1)();
+            const isDev = isDev_ !== null ? isDev_ : (0, utils_js_1.isDev1)();
             if (!(0, utils_js_1.isVirtualFileId)(id))
                 return undefined;
             id = (0, utils_js_1.getVirtualFileId)(id);
@@ -62,7 +64,8 @@ function importUserCode() {
             }
         },
         configureServer(server) {
-            (0, utils_js_1.isDev1_onConfigureServer)();
+            if (isDev_ === null)
+                (0, utils_js_1.isDev1_onConfigureServer)();
             handleFileAddRemove(server, config);
         }
     };
@@ -125,10 +128,7 @@ function isVikeConfigModule(filePathAbsoluteFilesystem) {
 }
 function reloadConfig(filePath, config, op) {
     {
-        const { filePathToShowToUserResolved } = (0, getFilePath_js_1.getFilePathResolved)({
-            filePathAbsoluteFilesystem: filePath,
-            userRootDir: config.root
-        });
+        const filePathToShowToUserResolved = (0, getFilePath_js_1.getModuleFilePath)(filePath, config);
         const msg = `${op} ${picocolors_1.default.dim(filePathToShowToUserResolved)}`;
         (0, loggerNotProd_js_1.logConfigInfo)(msg, 'info');
     }

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

@@ -13,7 +13,7 @@ const getConfigValueSourcesNotOverriden_js_1 = require("../../../shared/getConfi
 function getConfigValuesSerialized(pageConfig, isEnvMatch) {
     const lines = [];
     Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
-        const { value, configEnv } = configValuesComputed;
+        const { configEnv } = configValuesComputed;
         if (!isEnvMatch(configEnv))
             return;
         // configValeSources has higher precedence
@@ -21,9 +21,11 @@ function getConfigValuesSerialized(pageConfig, isEnvMatch) {
             return;
         const configValue = pageConfig.configValues[configName];
         (0, utils_js_1.assert)(configValue);
-        const { definedAt } = configValue;
-        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
-        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
+        const { value, ...common } = configValue;
+        (0, utils_js_1.assert)(value === configValuesComputed.value);
+        const valueSerialized = getConfigValueSerialized(value, configName, configValue.definedAtData);
+        const configValueSerialized = { valueSerialized, ...common };
+        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, configValueSerialized);
     });
     (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
         const { configName, configEnv } = configValueSource;
@@ -33,20 +35,21 @@ function getConfigValuesSerialized(pageConfig, isEnvMatch) {
         if (!isEnvMatch(configEnv, configValueSource)) {
             return;
         }
-        const { value, definedAt } = configValue;
-        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
-        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
+        const { value, ...common } = configValue;
+        const valueSerialized = getConfigValueSerialized(value, configName, configValue.definedAtData);
+        const configValueSerialized = { valueSerialized, ...common };
+        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, configValueSerialized);
     });
     const code = lines.join('\n');
     return code;
 }
 exports.getConfigValuesSerialized = getConfigValuesSerialized;
-function assertConfigValueIsSerializable(value, configName, definedAt) {
+function assertConfigValueIsSerializable(value, configName, definedAtData) {
     // Contains asserts
-    getConfigValueSerialized(value, configName, definedAt);
+    getConfigValueSerialized(value, configName, definedAtData);
 }
 exports.assertConfigValueIsSerializable = assertConfigValueIsSerializable;
-function getConfigValueSerialized(value, configName, definedAt) {
+function getConfigValueSerialized(value, configName, definedAtData) {
     const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
     let configValueSerialized;
     try {
@@ -64,7 +67,7 @@ function getConfigValueSerialized(value, configName, definedAt) {
           serializationErrMsg = 'see serialization error printed above'
         }
         */
-        const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)({ definedAt });
+        const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(definedAtData);
         (0, utils_js_1.assert)(configValueFilePathToShowToUser);
         (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
     }

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

@@ -23,7 +23,13 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
         // config.outDir is outside of config.root => it's going to be ignored anyways
         outDirRelativeFromUserRootDir = null;
     }
-    (0, utils_js_1.assert)(outDirRelativeFromUserRootDir === null || !outDirRelativeFromUserRootDir.startsWith('.'));
+    (0, utils_js_1.assert)(outDirRelativeFromUserRootDir === null ||
+        /* Not true if outDirRelativeFromUserRootDir starts with a hidden directory (i.e. a directory with a name that starts with `.`)
+        !outDirRelativeFromUserRootDir.startsWith('.') &&
+        */
+        (!outDirRelativeFromUserRootDir.startsWith('./') &&
+            //
+            !outDirRelativeFromUserRootDir.startsWith('../')));
     const timeBefore = new Date().getTime();
     let files = [];
     const res = await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir);

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

@@ -11,8 +11,7 @@ const assertPlusFileExport_js_1 = require("../../../../../../shared/page-configs
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const transformFileImports_js_1 = require("./transformFileImports.js");
 const getConfigFileExport_js_1 = require("../getConfigFileExport.js");
-const resolveImportPath_js_1 = require("./resolveImportPath.js");
-const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
+const resolvePointerImport_js_1 = require("./resolvePointerImport.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 // Load fake import
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
@@ -62,13 +61,11 @@ function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
     (0, utils_js_1.assertUsage)(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
 }
 async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
-    const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
+    const extendsPointerImportData = getExtendsPointerImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
-    extendsImportData.map((importData) => {
-        const { importPath: importPathAbsolute } = importData;
-        const filePathAbsoluteFilesystem = (0, resolveImportPath_js_1.resolveImportPath)(importData, configFilePath);
-        (0, resolveImportPath_js_1.assertImportPath)(filePathAbsoluteFilesystem, importData, configFilePath);
-        const filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteFilesystem, userRootDir, importPathAbsolute });
+    extendsPointerImportData.map((pointerImportData) => {
+        const filePath = (0, resolvePointerImport_js_1.resolvePointerImport)(pointerImportData, configFilePath, userRootDir);
+        (0, utils_js_1.assert)(filePath.filePathAbsoluteFilesystem);
         extendsConfigFiles.push(filePath);
     });
     const extendsConfigs = [];
@@ -80,7 +77,7 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function getExtendsImportData(configFileExports, configFilePath) {
+function getExtendsPointerImportData(configFileExports, configFilePath) {
     const { filePathToShowToUser } = configFilePath;
     const configFileExport = (0, getConfigFileExport_js_1.getConfigFileExport)(configFileExports, filePathToShowToUser);
     const wrongUsage = `${filePathToShowToUser} sets the config ${picocolors_1.default.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
@@ -97,10 +94,10 @@ function getExtendsImportData(configFileExports, configFilePath) {
     else {
         (0, utils_js_1.assertUsage)(false, wrongUsage);
     }
-    const extendsImportData = extendList.map((importDataSerialized) => {
-        const importData = (0, transformFileImports_js_1.parseImportData)(importDataSerialized);
-        (0, utils_js_1.assertUsage)(importData, wrongUsage);
-        return importData;
+    const extendsPointerImportData = extendList.map((importString) => {
+        const pointerImportData = (0, transformFileImports_js_1.parsePointerImportData)(importString);
+        (0, utils_js_1.assertUsage)(pointerImportData, wrongUsage);
+        return pointerImportData;
     });
-    return extendsImportData;
+    return extendsPointerImportData;
 }

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

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearFilesEnvMap = exports.resolvePointerImport = exports.resolvePointerImportOfConfig = void 0;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const utils_js_1 = require("../../../../utils.js");
+const transformFileImports_js_1 = require("./transformFileImports.js");
+const path_1 = __importDefault(require("path"));
+const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
+const filesEnvMap = new Map();
+function resolvePointerImportOfConfig(configValue, importerFilePath, userRootDir, configEnv, configName) {
+    if (typeof configValue !== 'string')
+        return null;
+    const pointerImportData = (0, transformFileImports_js_1.parsePointerImportData)(configValue);
+    if (!pointerImportData)
+        return null;
+    const { importPath, exportName } = pointerImportData;
+    const filePath = resolvePointerImport(pointerImportData, importerFilePath, userRootDir);
+    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
+    assertFileEnv(filePath.filePathAbsoluteFilesystem, importPath, configEnv, configName);
+    return {
+        ...filePath,
+        fileExportName: exportName,
+        fileExportPathToShowToUser
+    };
+}
+exports.resolvePointerImportOfConfig = resolvePointerImportOfConfig;
+function resolvePointerImport(pointerImportData, importerFilePath, userRootDir) {
+    const { importPath } = pointerImportData;
+    const filePathAbsoluteFilesystem = resolveImportPathWithNode(pointerImportData, importerFilePath);
+    let filePath;
+    // - importPath is one of the following. (See `transpileAndExecuteFile()`.)
+    //   - A relative import path
+    //   - A filesystem absolute path
+    //   - An npm package import
+    // - importPath cannot be a path alias (since esbuild resolves path aliases, see transpileAndExecuteFile.ts)
+    (0, utils_js_1.assertPosixPath)(importPath);
+    if (importPath.startsWith('.') || (0, utils_js_1.isPathFilesystemAbsolute)(importPath)) {
+        if (importPath.startsWith('.')) {
+            (0, utils_js_1.assert)(importPath.startsWith('./') || importPath.startsWith('../'));
+        }
+        assertImportPath(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
+        const filePathAbsoluteUserRootDir = (0, getFilePath_js_1.getFilePathAbsoluteUserRootDir)({ filePathAbsoluteFilesystem, userRootDir });
+        // This assert() is guarenteed, see assertUsage() in the onResolve() esbuild hook in transpileAndExecuteFile.ts
+        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
+        // Imports are included in virtual files, thus the relative path of imports need to resolved.
+        // ```
+        // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
+        // ```
+        filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
+    }
+    else {
+        const importPathAbsolute = importPath;
+        // importPath cannot be a path alias (since esbuild resolves path aliases, see transpileAndExecuteFile.ts)
+        (0, utils_js_1.assertIsNpmPackageImport)(importPathAbsolute);
+        if (filePathAbsoluteFilesystem) {
+            filePath = (0, getFilePath_js_1.getFilePathResolved)({
+                userRootDir,
+                filePathAbsoluteFilesystem,
+                importPathAbsolute
+            });
+        }
+        else {
+            filePath = (0, getFilePath_js_1.getFilePathUnresolved)({
+                importPathAbsolute
+            });
+        }
+    }
+    return filePath;
+}
+exports.resolvePointerImport = resolvePointerImport;
+function resolveImportPathWithNode(pointerImportData, 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
+    // filePathAbsoluteFilesystem is expected to be null when pointerImportData.importPath is a Vite path alias
+    const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolve)(pointerImportData.importPath, cwd);
+    return filePathAbsoluteFilesystem;
+}
+function assertImportPath(filePathAbsoluteFilesystem, pointerImportData, importerFilePath) {
+    const { importPath: importPath, importStringWasGenerated, importString } = pointerImportData;
+    const { filePathToShowToUser } = importerFilePath;
+    if (!filePathAbsoluteFilesystem) {
+        const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
+        const errIntro = importStringWasGenerated
+            ? `The import path ${importPathString} in ${filePathToShowToUser}`
+            : `The import ${picocolors_1.default.cyan(importString)} defined in ${filePathToShowToUser}`;
+        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
+        if (importPath.startsWith('.')) {
+            (0, utils_js_1.assert)(importPath.startsWith('./') || importPath.startsWith('../'));
+            (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
+        }
+        else {
+            (0, utils_js_1.assertUsage)(false, `${errIntro2} exist?`);
+        }
+    }
+}
+function assertFileEnv(filePathAbsoluteFilesystem, importPath, configEnv, configName) {
+    let key;
+    if (filePathAbsoluteFilesystem) {
+        key = filePathAbsoluteFilesystem;
+    }
+    else {
+        (0, utils_js_1.assertIsNpmPackageImport)(importPath);
+        key = importPath;
+    }
+    (0, utils_js_1.assertPosixPath)(key);
+    if (!filesEnvMap.has(key)) {
+        filesEnvMap.set(key, []);
+    }
+    const fileEnv = filesEnvMap.get(key);
+    fileEnv.push({ configEnv, configName });
+    const configDifferentEnv = fileEnv.filter((c) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
+    if (configDifferentEnv) {
+        (0, utils_js_1.assertUsage)(false, [
+            `${key} defines the value of configs living in different environments:`,
+            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(JSON.stringify(c.configEnv))}`),
+            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports'
+        ].join('\n'));
+    }
+}
+function clearFilesEnvMap() {
+    filesEnvMap.clear();
+}
+exports.clearFilesEnvMap = clearFilesEnvMap;

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImportData = exports.parseImportData = exports.transformFileImports = void 0;
+exports.isPointerImportData = exports.parsePointerImportData = exports.transformFileImports = void 0;
 // Playground: https://github.com/brillout/acorn-playground
 // Notes about `with { type: 'pointer' }`
 // - It works well with TypeScript: it doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-3.html#import-attributes
@@ -93,7 +93,7 @@ skipWarnings) {
                 }
                 return importLocalName;
             })();
-            const importString = serializeImportData({ importPath, exportName, importStringWasGenerated: true });
+            const importString = serializePointerImportData({ importPath, exportName, importStringWasGenerated: true });
             replacement += `const ${importLocalName} = '${importString}';`;
         });
         spliceOperations.push({
@@ -122,17 +122,17 @@ function getImports(code) {
 const import_ = 'import';
 const SEP = ':';
 const zeroWidthSpace = '\u200b';
-function serializeImportData({ importPath, exportName, importStringWasGenerated }) {
+function serializePointerImportData({ importPath, exportName, importStringWasGenerated }) {
     const tag = importStringWasGenerated ? zeroWidthSpace : '';
     // `import:${importPath}:${importPath}`
     return `${tag}${import_}${SEP}${importPath}${SEP}${exportName}`;
 }
-function isImportData(str) {
+function isPointerImportData(str) {
     return str.startsWith(import_ + SEP) || str.startsWith(zeroWidthSpace + import_ + SEP);
 }
-exports.isImportData = isImportData;
-function parseImportData(importString) {
-    if (!isImportData(importString)) {
+exports.isPointerImportData = isPointerImportData;
+function parsePointerImportData(importString) {
+    if (!isPointerImportData(importString)) {
         return null;
     }
     let importStringWasGenerated = false;
@@ -152,7 +152,7 @@ function parseImportData(importString) {
     const importPath = parts.slice(0, -1).join(SEP);
     return { importPath, exportName, importStringWasGenerated, importString };
 }
-exports.parseImportData = parseImportData;
+exports.parsePointerImportData = parsePointerImportData;
 function spliceMany(str, operations) {
     let strMod = '';
     let endPrev;

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

@@ -13,6 +13,7 @@ const utils_js_1 = require("../../../../utils.js");
 const transformFileImports_js_1 = require("./transformFileImports.js");
 const getVikeConfig_js_1 = require("../getVikeConfig.js");
 require("source-map-support/register.js");
+const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 const debug = (0, utils_js_1.createDebugger)('vike:pointer-imports');
 async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
@@ -114,13 +115,21 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                         return resolved;
                     }
                     (0, utils_js_1.assert)(resolved.path);
-                    resolved.path = (0, utils_js_1.toPosixPath)(resolved.path);
+                    const importPathResolved = (0, utils_js_1.toPosixPath)(resolved.path);
+                    const importPathOriginal = args.path;
+                    // Esbuild resolves path aliases.
+                    // - Enabling us to use:
+                    //   ```js
+                    //   isNpmPackageImport(str, { cannotBePathAlias: true })
+                    //   assertIsNpmPackageImport()
+                    //   ```
+                    (0, utils_js_1.assertPathFilesystemAbsolute)(importPathResolved);
                     // 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');
+                    const isVikeExtensionConfigImport = importPathResolved.endsWith('+config.js');
                     const isPointerImport = transformImports === 'all' ||
                         // .jsx, .vue, .svg, ... => obviously not config code
-                        !(0, utils_js_1.isJavaScriptFile)(resolved.path) ||
+                        !(0, utils_js_1.isJavaScriptFile)(importPathResolved) ||
                         // Import of a Vike extension config => make it a pointer import because we want to show nice error messages (that can display whether a configas been set by the user or by a Vike extension).
                         //  - We should have Node.js directly load vike-{react,vue,solid} while enforcing Vike extensions to set 'name' in their +config.js file.
                         //    - vike@0.4.162 already started soft-requiring Vike extensions to set the name config
@@ -129,21 +138,52 @@ 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[resolved.path] = isPointerImport;
-                    (0, utils_js_1.assertPosixPath)(resolved.path);
+                    (0, utils_js_1.assertPosixPath)(importPathResolved);
                     const isExternal = isPointerImport ||
                         // Performance: npm package imports that aren't pointer imports can be externalized. For example, if Vike eventually adds support for setting Vite configs in the vike.config.js file, then the user may import a Vite plugin in his vike.config.js file. (We could as well let esbuild always transpile /node_modules/ code but it would be useless and would unnecessarily slow down transpilation.)
-                        resolved.path.includes('/node_modules/');
+                        importPathResolved.includes('/node_modules/');
+                    const filePathAbsoluteUserRootDir = (0, getFilePath_js_1.getFilePathAbsoluteUserRootDir)({
+                        filePathAbsoluteFilesystem: importPathResolved,
+                        userRootDir
+                    });
+                    let importPathTranspiled;
+                    (0, utils_js_1.assertPosixPath)(importPathOriginal);
+                    if (importPathOriginal.startsWith('./') || importPathOriginal.startsWith('../')) {
+                        // - We need this assertUsage() because we didn't find a way (yet?) to use filesystem absolute import paths in virtual files.
+                        // - Alternatively, we can again try one of the following for generating the imports of virtual files. (Last time we tried none of it worked.)
+                        //   - ~~~js
+                        //     assert(filePathAbsoluteFilesystem.startsWith('/'))
+                        //     filePath = `/@fs${filePathAbsoluteFilesystem}`
+                        //     ~~~
+                        //   - ~~~js
+                        //     assert(filePathAbsoluteUserRootDir.startsWith('../'))
+                        //     filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir
+                        //     ~~~
+                        (0, utils_js_1.assertUsage)(filePathAbsoluteUserRootDir, `Import ${picocolors_1.default.cyan(importPathOriginal)} resolves to ${importPathResolved} outside of ${userRootDir} which is forbidden: make sure your relative import paths resolve inside ${userRootDir}, or import from an npm package.`);
+                        importPathTranspiled = importPathResolved;
+                    }
+                    else {
+                        // importPathOriginal is either:
+                        //  - Npm package import
+                        //  - Path alias
+                        if (filePathAbsoluteUserRootDir) {
+                            // importPathOriginal is most likely a path alias. (Is it even possible for an npm package import to resolved inside `userRootDir`?)
+                            importPathTranspiled = importPathResolved;
+                        }
+                        else {
+                            // importPathOriginal is an npm package import. (Assuming path aliases always resolve inside `userRootDir`.)
+                            (0, utils_js_1.assertIsNpmPackageImport)(importPathOriginal);
+                            importPathTranspiled = importPathOriginal;
+                        }
+                    }
                     if (debug.isActivated)
-                        debug('onResolved()', { args, resolved, isPointerImport, isExternal });
-                    // We need esbuild to resolve path aliases so that we can use:
-                    //   isNpmPackageImport(str, { cannotBePathAlias: true })
-                    //   assertIsNpmPackageImport()
-                    (0, utils_js_1.assertPathIsFilesystemAbsolute)(resolved.path);
+                        debug('onResolved()', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
+                    pointerImports[importPathTranspiled] = isPointerImport;
                     if (isExternal) {
-                        return { external: true, path: resolved.path };
+                        return { external: true, path: importPathTranspiled };
                     }
                     else {
+                        resolved.path = importPathTranspiled;
                         return resolved;
                     }
                 });