vike 0.4.159 → 0.4.160-commit-30d535e

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

@@ -5,26 +5,53 @@ export { getLocationId };
 export { sortAfterInheritanceOrder };
 export { isGlobalLocation };
 export { applyFilesystemRoutingRootEffect };
+export type { LocationId };
 export { getLogicalPath };
 /**
- * getLocationId('/pages/some-page/+Page.js') => '/pages/some-page'
- * getLocationId('/pages/some-page') => '/pages/some-page'
- * getLocationId('/renderer/+config.js') => '/renderer'
+ * The `locationId` value is used for filesystem inheritance.
+ *
+ * Each config value is assigned with a `locationId` value. That's the source-of-truth for determining inheritance between config values.
+ *
+ * For Vike extensions, `locationId` is different than the config value's `definedAt`, for example the `onRenderHtml()` hook of `vike-react`:
+ *  - `locationId === '/pages'` (the directory of `/pages/+config.h.js` which extends `vike-react`)
+ *  - `definedAt.filePathAbsoluteFilesystem === '/home/rom/code/my-vike-app/node_modules/vike-react/dist/renderer/onRenderHtml.js'` (the file where the value is defined)
+ *
+ *  This is an important distinction because the Vike extension's config should only apply to where it's being extended from, for example:
+ *  ```js
+ *  // /pages/admin/+config.h.js
+ *  import vikeVue from 'vike-vue/config'
+ *  // Should only apply to /pages/admin/**
+ *  export default { extends: [vikeVue] }
+ *  ```
+ *  ```js
+ *  // /pages/marketing/+config.h.js
+ *  import vikeReact from 'vike-react/config'
+ *  // Should only apply to /pages/marketing/**
+ *  export default { extends: [vikeReact] }
+ *  ```
  */
-declare function getLocationId(filePathAbsoluteVite: string): string;
-/** Get URL determined by filesystem path */
-declare function getFilesystemRouteString(locationId: string): string;
+type LocationId = string & {
+    __brand: 'LocationId';
+};
+/**
+ * `getLocationId('/pages/some-page/+Page.js')` => `'/pages/some-page'`
+ * `getLocationId('/renderer/+config.js')` => `'/renderer'`
+ *
+ * The value `locationId` is always a user-land path, because Filesystem Routing/Inheritance only applies to the user-land (Vike never uses Filesystem Routing/Inheritance for `node_modules/**`).
+ */
+declare function getLocationId(filePathRelativeToUserRootDir: string): LocationId;
+/** Filesystem Routing: get the URL */
+declare function getFilesystemRouteString(locationId: LocationId): string;
 /**
  * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
- * getLogicalPath('some-npm-pkg/renderer', ['renderer']) => '/'
  */
-declare function getLogicalPath(someDir: string, removeDirs: string[]): string;
+declare function getLogicalPath(locationId: LocationId, removeDirs: string[]): string;
 /** Whether configs defined in `locationId` apply in every `locationIds` */
-declare function isGlobalLocation(locationId: string, locationIds: string[]): boolean;
-declare function sortAfterInheritanceOrder(locationId1: string, locationId2: string, locationIdPage: string): -1 | 1 | 0;
+declare function isGlobalLocation(locationId: LocationId, locationIds: LocationId[]): boolean;
+declare function sortAfterInheritanceOrder(locationId1: LocationId, locationId2: LocationId, locationIdPage: LocationId): -1 | 1 | 0;
 /** Whether configs defined at `locationId1` also apply at `locationId2` */
-declare function isInherited(locationId1: string, locationId2: string): boolean;
-declare function getFilesystemRouteDefinedBy(locationId: string): string;
+declare function isInherited(locationId1: LocationId, locationId2: LocationId): boolean;
+declare function getFilesystemRouteDefinedBy(locationId: LocationId): string;
 declare function applyFilesystemRoutingRootEffect(routeFilesystem: string, filesystemRoutingRootEffect: {
     before: string;
     after: string;

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

@@ -7,40 +7,47 @@ export { isGlobalLocation };
 export { applyFilesystemRoutingRootEffect };
 // For ./filesystemRouting.spec.ts
 export { getLogicalPath };
-import { assert, assertPosixPath, getNpmPackageImportPath, isNpmPackageImport, higherFirst } from '../../../../utils.js';
+import { assert, assertPosixPath, higherFirst } from '../../../../utils.js';
 /**
- * getLocationId('/pages/some-page/+Page.js') => '/pages/some-page'
- * getLocationId('/pages/some-page') => '/pages/some-page'
- * getLocationId('/renderer/+config.js') => '/renderer'
+ * `getLocationId('/pages/some-page/+Page.js')` => `'/pages/some-page'`
+ * `getLocationId('/renderer/+config.js')` => `'/renderer'`
+ *
+ * The value `locationId` is always a user-land path, because Filesystem Routing/Inheritance only applies to the user-land (Vike never uses Filesystem Routing/Inheritance for `node_modules/**`).
  */
-function getLocationId(filePathAbsoluteVite) {
-    const locationId = removeFilename(filePathAbsoluteVite, true);
+function getLocationId(
+// We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.h.js` that extends the Vike extension.
+filePathRelativeToUserRootDir) {
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assert(filePathRelativeToUserRootDir.startsWith('/'));
+    const locationId = removeFilename(filePathRelativeToUserRootDir);
     assertLocationId(locationId);
     return locationId;
 }
-/** Get URL determined by filesystem path */
+/** Filesystem Routing: get the URL */
 function getFilesystemRouteString(locationId) {
     return getLogicalPath(locationId, ['renderer', 'pages', 'src', 'index']);
 }
-/** Get apply root for config inheritance */
-function getInheritanceRoot(someDir) {
-    return getLogicalPath(someDir, ['renderer']);
+/** Filesystem Inheritance: get the apply root */
+function getInheritanceRoot(locationId) {
+    return getLogicalPath(locationId, ['renderer']);
 }
 /**
  * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
- * getLogicalPath('some-npm-pkg/renderer', ['renderer']) => '/'
  */
-function getLogicalPath(someDir, removeDirs) {
-    someDir = removeNpmPackageName(someDir);
-    someDir = removeDirectories(someDir, removeDirs);
-    assertIsPath(someDir);
-    return someDir;
+function getLogicalPath(locationId, removeDirs) {
+    let logicalPath = removeDirectories(locationId, removeDirs);
+    assertIsPath(logicalPath);
+    return logicalPath;
 }
 /** Whether configs defined in `locationId` apply in every `locationIds` */
 function isGlobalLocation(locationId, locationIds) {
     return locationIds.every((locId) => isInherited(locationId, locId) || locationIsRendererDir(locId));
 }
 function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
+    assertLocationId(locationId1);
+    assertLocationId(locationId2);
+    if (locationId1 === locationId2)
+        return 0;
     const inheritanceRoot1 = getInheritanceRoot(locationId1);
     const inheritanceRoot2 = getInheritanceRoot(locationId2);
     const inheritanceRootPage = getInheritanceRoot(locationIdPage);
@@ -56,15 +63,10 @@ function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
         assert(inheritanceRoot1.length !== inheritanceRoot2.length);
         return higherFirst((inheritanceRoot) => inheritanceRoot.length)(inheritanceRoot1, inheritanceRoot2);
     }
-    // Should be true since we aggregate interface files by locationId
-    assert(locationId1 !== locationId2);
     // locationId1 first, i.e. `indexOf(locationId1) < indexOf(locationId2)`
     const locationId1First = -1;
     // locationId2 first, i.e. `indexOf(locationId2) < indexOf(locationId1)`
     const locationId2First = 1;
-    if (locationIsNpmPackage(locationId1) !== locationIsNpmPackage(locationId2)) {
-        return locationIsNpmPackage(locationId1) ? locationId2First : locationId1First;
-    }
     if (locationIsRendererDir(locationId1) !== locationIsRendererDir(locationId2)) {
         return locationIsRendererDir(locationId1) ? locationId2First : locationId1First;
     }
@@ -75,9 +77,6 @@ function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
     }
     return locationId1 > locationId2 ? locationId1First : locationId2First;
 }
-function locationIsNpmPackage(locationId) {
-    return !locationId.startsWith('/');
-}
 function locationIsRendererDir(locationId) {
     return locationId.split('/').includes('renderer');
 }
@@ -87,19 +86,6 @@ function isInherited(locationId1, locationId2) {
     const inheritanceRoot2 = getInheritanceRoot(locationId2);
     return startsWith(inheritanceRoot2, inheritanceRoot1);
 }
-function removeNpmPackageName(somePath) {
-    if (!isNpmPackageImport(somePath)) {
-        assert(somePath.startsWith('/'));
-        return somePath;
-    }
-    const importPath = getNpmPackageImportPath(somePath);
-    if (!importPath)
-        return '/';
-    assertPosixPath(importPath);
-    assert(!importPath.startsWith('/'));
-    somePath = '/' + importPath;
-    return somePath;
-}
 function removeDirectories(somePath, removeDirs) {
     assertPosixPath(somePath);
     somePath = somePath
@@ -110,17 +96,13 @@ function removeDirectories(somePath, removeDirs) {
         somePath = '/';
     return somePath;
 }
-function removeFilename(filePathAbsoluteVite, optional) {
-    assertPosixPath(filePathAbsoluteVite);
-    assert(filePathAbsoluteVite.startsWith('/') || isNpmPackageImport(filePathAbsoluteVite));
+function removeFilename(filePathRelativeToUserRootDir) {
+    const filePathParts = filePathRelativeToUserRootDir.split('/');
     {
-        const filename = filePathAbsoluteVite.split('/').slice(-1)[0];
-        if (!filename.includes('.')) {
-            assert(optional);
-            return filePathAbsoluteVite;
-        }
+        const filename = filePathParts.slice(-1)[0];
+        assert(filename.includes('.'));
     }
-    let locationId = filePathAbsoluteVite.split('/').slice(0, -1).join('/');
+    let locationId = filePathParts.slice(0, -1).join('/');
     if (locationId === '')
         locationId = '/';
     assertLocationId(locationId);
@@ -142,7 +124,7 @@ function applyFilesystemRoutingRootEffect(routeFilesystem, filesystemRoutingRoot
     return routeFilesystem;
 }
 function assertLocationId(locationId) {
-    assert(locationId.startsWith('/') || isNpmPackageImport(locationId));
+    assert(locationId.startsWith('/'));
     assert(!locationId.endsWith('/') || locationId === '/');
 }
 function assertIsPath(logicalPath) {

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

@@ -0,0 +1,21 @@
+export { loadImportedFile };
+export { loadValueFile };
+export { loadConfigFile };
+export type { ImportedFilesLoaded };
+export type { ConfigFile };
+import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { InterfaceValueFile } from '../getVikeConfig.js';
+type ImportedFilesLoaded = Record<string, Promise<Record<string, unknown>>>;
+type ConfigFile = {
+    fileExports: Record<string, unknown>;
+    filePath: FilePathResolved;
+    extendsFilePaths: string[];
+};
+declare function loadImportedFile(import_: FilePathResolved & {
+    fileExportName: string;
+}, userRootDir: string, importedFilesLoaded: ImportedFilesLoaded): Promise<unknown>;
+declare function loadValueFile(interfaceValueFile: InterfaceValueFile, configName: string, userRootDir: string): Promise<void>;
+declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isConfigOfExtension: boolean): Promise<{
+    configFile: ConfigFile;
+    extendsConfigs: ConfigFile[];
+}>;

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

@@ -0,0 +1,123 @@
+// Files loadded at config time:
+export { loadImportedFile };
+export { loadValueFile };
+export { loadConfigFile };
+import { assertPosixPath, assert, assertUsage, assertWarning, hasProp, assertIsNotProductionRuntime, isNpmPackageImport } from '../../../../utils.js';
+import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
+import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
+import pc from '@brillout/picocolors';
+import { parseImportData } from './transformFileImports.js';
+import { getConfigFileExport } from '../getConfigFileExport.js';
+import { assertImportPath, resolveImportPath } from './resolveImportPath.js';
+assertIsNotProductionRuntime();
+// Load fake import
+async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
+    const f = import_.filePathAbsoluteFilesystem;
+    if (!importedFilesLoaded[f]) {
+        importedFilesLoaded[f] = transpileAndExecuteFile(import_, false, userRootDir).then((r) => r.fileExports);
+    }
+    const fileExports = await importedFilesLoaded[f];
+    const fileExport = fileExports[import_.fileExportName];
+    return fileExport;
+}
+// Load +{configName}.js
+async function loadValueFile(interfaceValueFile, configName, userRootDir) {
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, false, userRootDir);
+    const { filePathToShowToUser } = interfaceValueFile.filePath;
+    assertPlusFileExport(fileExports, filePathToShowToUser, configName);
+    Object.entries(fileExports).forEach(([exportName, configValue]) => {
+        const configName_ = exportName === 'default' ? configName : exportName;
+        interfaceValueFile.fileExportsByConfigName[configName_] = { configValue };
+    });
+}
+// Load +config.js, including all its extends fake imports
+async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
+    const { filePathAbsoluteFilesystem } = configFilePath;
+    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, !isConfigOfExtension, userRootDir, isConfigOfExtension);
+    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
+        ...visited,
+        filePathAbsoluteFilesystem
+    ]);
+    const configFile = {
+        fileExports,
+        filePath: configFilePath,
+        extendsFilePaths
+    };
+    return { configFile, extendsConfigs };
+}
+function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
+    const idx = visited.indexOf(filePathAbsoluteFilesystem);
+    if (idx === -1)
+        return;
+    const loop = visited.slice(idx);
+    assert(loop[0] === filePathAbsoluteFilesystem);
+    assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
+}
+async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
+    const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
+    const extendsConfigFiles = [];
+    extendsImportData.map((importData) => {
+        const { importPath: importPath } = importData;
+        const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
+        assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
+        warnUserLandExtension(importPath, configFilePath);
+        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
+        const filePathAbsoluteVite = filePathRelativeToUserRootDir ?? importPath;
+        extendsConfigFiles.push({
+            filePathAbsoluteFilesystem,
+            filePathAbsoluteVite,
+            filePathRelativeToUserRootDir,
+            filePathToShowToUser: filePathAbsoluteVite,
+            importPathAbsolute: importPath
+        });
+    });
+    const extendsConfigs = [];
+    await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
+        const result = await loadConfigFile(configFilePath, userRootDir, visited, true);
+        extendsConfigs.push(result.configFile);
+        extendsConfigs.push(...result.extendsConfigs);
+    }));
+    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
+    return { extendsConfigs, extendsFilePaths };
+}
+function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    assertPosixPath(userRootDir);
+    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        return null;
+    }
+    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
+    if (!filePathRelativeToUserRootDir.startsWith('/'))
+        filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
+    return filePathRelativeToUserRootDir;
+}
+function warnUserLandExtension(importPath, configFilePath) {
+    assertWarning(isNpmPackageImport(importPath), `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
+}
+function getExtendsImportData(configFileExports, configFilePath) {
+    const { filePathToShowToUser } = configFilePath;
+    const configFileExport = getConfigFileExport(configFileExports, filePathToShowToUser);
+    const wrongUsage = `${filePathToShowToUser} sets the config ${pc.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
+    let extendList;
+    if (!('extends' in configFileExport)) {
+        return [];
+    }
+    else if (hasProp(configFileExport, 'extends', 'string')) {
+        extendList = [configFileExport.extends];
+    }
+    else if (hasProp(configFileExport, 'extends', 'string[]')) {
+        extendList = configFileExport.extends;
+    }
+    else {
+        assertUsage(false, wrongUsage);
+    }
+    const extendsImportData = extendList.map((importDataSerialized) => {
+        const importData = parseImportData(importDataSerialized);
+        assertUsage(importData, wrongUsage);
+        return importData;
+    });
+    return extendsImportData;
+}

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

@@ -0,0 +1,5 @@
+export { resolveFilePathRelativeToUserRootDir };
+export { resolveFilePathAbsoluteFilesystem };
+import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+declare function resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir: string, userRootDir: string): FilePathResolved;
+declare function resolveFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem: string, userRootDir: string): FilePathResolved;

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

@@ -0,0 +1,27 @@
+export { resolveFilePathRelativeToUserRootDir };
+export { resolveFilePathAbsoluteFilesystem };
+import path from 'path';
+import { assert, assertPosixPath } from '../../../../utils.js';
+function resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir, userRootDir) {
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assertPosixPath(userRootDir);
+    const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathRelativeToUserRootDir);
+    return getFilePathResolved(filePathRelativeToUserRootDir, filePathAbsoluteFilesystem);
+}
+function resolveFilePathAbsoluteFilesystem(filePathAbsoluteFilesystem, userRootDir) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    assertPosixPath(userRootDir);
+    let filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    assert(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'));
+    filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
+    return getFilePathResolved(filePathRelativeToUserRootDir, filePathAbsoluteFilesystem);
+}
+function getFilePathResolved(filePathRelativeToUserRootDir, filePathAbsoluteFilesystem) {
+    return {
+        filePathRelativeToUserRootDir,
+        filePathAbsoluteVite: filePathRelativeToUserRootDir,
+        filePathAbsoluteFilesystem,
+        filePathToShowToUser: filePathRelativeToUserRootDir,
+        importPathAbsolute: null
+    };
+}

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

@@ -0,0 +1,12 @@
+export { resolveImport };
+export { resolveImportPath };
+export { assertImportPath };
+export { clearFilesEnvMap };
+import type { ConfigEnvInternal, DefinedAtFileFullInfo, FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import { type ImportData } from './transformFileImports.js';
+declare function resolveImport(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | (DefinedAtFileFullInfo & {
+    fileExportName: string;
+});
+declare function resolveImportPath(importData: ImportData, importerFilePath: FilePathResolved): string | null;
+declare function assertImportPath(filePathAbsoluteFilesystem: string | null, importData: ImportData, importerFilePath: FilePathResolved): asserts filePathAbsoluteFilesystem is string;
+declare function clearFilesEnvMap(): void;

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

@@ -0,0 +1,133 @@
+export { resolveImport };
+export { resolveImportPath };
+export { assertImportPath };
+export { clearFilesEnvMap };
+import pc from '@brillout/picocolors';
+import { assert, assertPosixPath, assertUsage, deepEqual, requireResolve } from '../../../../utils.js';
+import { parseImportData } from './transformFileImports.js';
+import path from 'path';
+const filesEnvMap = new Map();
+function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
+    if (typeof configValue !== 'string')
+        return null;
+    const importData = parseImportData(configValue);
+    if (!importData)
+        return null;
+    const { importPath, exportName } = importData;
+    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
+    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
+    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
+    if (importPath.startsWith('.')) {
+        // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
+        // ```
+        // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
+        // ```
+        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
+        const filePath = {
+            filePathAbsoluteFilesystem,
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteVite: filePathRelativeToUserRootDir,
+            filePathToShowToUser: filePathRelativeToUserRootDir,
+            importPathAbsolute: null
+        };
+        return {
+            ...filePath,
+            fileExportName: exportName,
+            fileExportPathToShowToUser
+        };
+    }
+    else {
+        // importPath can be:
+        //  - an npm package import
+        //  - a path alias
+        const filePath = {
+            filePathAbsoluteFilesystem,
+            filePathRelativeToUserRootDir: null,
+            filePathAbsoluteVite: importPath,
+            filePathToShowToUser: importPath,
+            importPathAbsolute: importPath
+        };
+        return {
+            ...filePath,
+            fileExportName: exportName,
+            fileExportPathToShowToUser
+        };
+    }
+}
+function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
+    assertPosixPath(userRootDir);
+    let filePathRelativeToUserRootDir;
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
+    }
+    else {
+        assertUsage(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
+        // None of the following works. Seems to be a Vite bug?
+        // /*
+        // assert(filePathAbsoluteFilesystem.startsWith('/'))
+        // filePath = `/@fs${filePathAbsoluteFilesystem}`
+        // /*/
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
+        // assert(filePathRelativeToUserRootDir.startsWith('../'))
+        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
+        // //*/
+    }
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assert(filePathRelativeToUserRootDir.startsWith('/'));
+    return filePathRelativeToUserRootDir;
+}
+function resolveImportPath(importData, importerFilePath) {
+    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
+    assertPosixPath(importerFilePathAbsolute);
+    const cwd = path.posix.dirname(importerFilePathAbsolute);
+    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
+    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
+    return filePathAbsoluteFilesystem;
+}
+function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
+    const { importPath: importPath, importStringWasGenerated, importString } = importData;
+    const { filePathToShowToUser } = importerFilePath;
+    if (!filePathAbsoluteFilesystem) {
+        const importPathString = pc.cyan(`'${importPath}'`);
+        const errIntro = importStringWasGenerated
+            ? `The import path ${importPathString} in ${filePathToShowToUser}`
+            : `The import ${pc.cyan(importString)} defined in ${filePathToShowToUser}`;
+        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
+        if (importPath.startsWith('.')) {
+            assertUsage(false, `${errIntro2} point to an existing file?`);
+        }
+        else {
+            assertUsage(false, `${errIntro2} exist?`);
+        }
+    }
+}
+function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
+    assertPosixPath(filePathForEnvCheck);
+    if (!filesEnvMap.has(filePathForEnvCheck)) {
+        filesEnvMap.set(filePathForEnvCheck, []);
+    }
+    const fileEnv = filesEnvMap.get(filePathForEnvCheck);
+    fileEnv.push({ configEnv, configName });
+    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
+    if (configDifferentEnv) {
+        assertUsage(false, [
+            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
+            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.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/header-file'
+        ].join('\n'));
+    }
+}
+function clearFilesEnvMap() {
+    filesEnvMap.clear();
+}
+function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    assertPosixPath(root);
+    assert(filePathAbsoluteFilesystem.startsWith(root));
+    let vitePath = path.posix.relative(root, filePathAbsoluteFilesystem);
+    assert(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
+    vitePath = '/' + vitePath;
+    return vitePath;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{replaceImportStatements.d.ts → getVikeConfig/transformFileImports.d.ts}

@@ -1,4 +1,4 @@
-export { replaceImportStatements };
+export { transformFileImports };
 export { parseImportData };
 export { isImportData };
 export type { FileImport };
@@ -8,12 +8,12 @@ type FileImport = {
     importString: string;
     importLocalName: string;
 };
-declare function replaceImportStatements(code: string, filePathToShowToUser: string): {
-    noImportStatement: true;
+declare function transformFileImports(code: string, filePathToShowToUser2: string, skipWarnings?: true): {
+    noTransformation: true;
 } | {
-    noImportStatement: false;
+    noTransformation: false;
     code: string;
-    fileImports: FileImport[];
+    fileImportsTransformed: FileImport[];
 };
 /**
  * Data Structure holding info about import statement: