vike 0.4.168-commit-7678a7d → 0.4.168-commit-42406a9

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;
         }

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

@@ -171,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/importUserCode/index.js

@@ -128,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/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/{resolveImportPath.js → resolvePointerImport.js}

@@ -3,79 +3,86 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearFilesEnvMap = exports.assertImportPath = exports.resolveImportPath = exports.resolveImport = void 0;
+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 resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
+function resolvePointerImportOfConfig(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
         return null;
-    const importData = (0, transformFileImports_js_1.parseImportData)(configValue);
-    if (!importData)
+    const pointerImportData = (0, transformFileImports_js_1.parsePointerImportData)(configValue);
+    if (!pointerImportData)
         return null;
-    const { importPath, exportName } = importData;
-    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
-    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
+    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;
-    if (importPath.startsWith('.')) {
-        (0, utils_js_1.assert)(importPath.startsWith('./') || importPath.startsWith('../'));
-        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
-        filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteFilesystem, userRootDir });
+    // - 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?
         // ```
-        (0, utils_js_1.assertUsage)(filePath.filePathAbsoluteUserRootDir, `${importerFilePath.filePathToShowToUser} imports a relative path ${picocolors_1.default.cyan(importPath)} resolving outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
-        // Alternativey, we can try one of the following but last time we tried none of the following worked.
-        // /*
-        // assert(filePathAbsoluteFilesystem.startsWith('/'))
-        // filePath = `/@fs${filePathAbsoluteFilesystem}`
-        // /*/
-        // assert(filePathAbsoluteUserRootDir.startsWith('../'))
-        // filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir
-        // //*/
+        filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
-        // importPath can be:
-        //  - an npm package import
-        //  - a path alias
+        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: importPath
+                importPathAbsolute
             });
         }
         else {
             filePath = (0, getFilePath_js_1.getFilePathUnresolved)({
-                importPathAbsolute: importPath
+                importPathAbsolute
             });
         }
     }
-    return {
-        ...filePath,
-        fileExportName: exportName,
-        fileExportPathToShowToUser
-    };
+    return filePath;
 }
-exports.resolveImport = resolveImport;
-function resolveImportPath(importData, importerFilePath) {
+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 importData.importPath is a Vite path alias
-    const filePathAbsoluteFilesystem = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
+    // 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;
 }
-exports.resolveImportPath = resolveImportPath;
-function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
-    const { importPath: importPath, importStringWasGenerated, importString } = importData;
+function assertImportPath(filePathAbsoluteFilesystem, pointerImportData, importerFilePath) {
+    const { importPath: importPath, importStringWasGenerated, importString } = pointerImportData;
     const { filePathToShowToUser } = importerFilePath;
     if (!filePathAbsoluteFilesystem) {
         const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
@@ -92,18 +99,25 @@ function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePa
         }
     }
 }
-exports.assertImportPath = assertImportPath;
-function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
-    (0, utils_js_1.assertPosixPath)(filePathForEnvCheck);
-    if (!filesEnvMap.has(filePathForEnvCheck)) {
-        filesEnvMap.set(filePathForEnvCheck, []);
+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(filePathForEnvCheck);
+    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, [
-            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
+            `${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'));

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;
                     }
                 });