vike 0.4.159-commit-0424983 → 0.4.159-commit-d73533a

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/loadFileConfigEnv.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 './transformImports.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_, true, 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, true, 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, false, 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/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 './transformImports.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 './transformImports.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/{transformImports.js → getVikeConfig/transformImports.js}

@@ -5,7 +5,7 @@ export { isImportData };
 // Import attributes support: https://github.com/acornjs/acorn/issues/983
 //  - Isn't stage 4 yet: https://github.com/tc39/proposal-import-attributes
 import { parse } from 'acorn';
-import { assert, assertUsage, assertWarning, styleFileRE } from '../../../utils.js';
+import { assert, assertUsage, assertWarning, styleFileRE } from '../../../../utils.js';
 import pc from '@brillout/picocolors';
 function transformImports(code, filePathToShowToUser2, 
 // For ./transformImports.spec.ts
@@ -23,13 +23,13 @@ skipWarnings) {
             return;
         const importPath = node.source.value;
         assert(typeof importPath === 'string');
-        // - This doesn't work, to make it work we would need to run esbuild twice: esbuild for TypeScript to JavaScript => transformImports() => esbuild for bundling.
+        // - This doesn't work. To make it work we would need to run esbuild twice: esbuild for TypeScript to JavaScript => transformImports() => esbuild for bundling.
         //   - Or we use an esbuild plugin to apply transformImports(). Maybe we can completely skip the need for acorn?
         // - ?real breaks TypeScript, and TypeScript isn't working on supporting query params: https://github.com/microsoft/TypeScript/issues/10988#issuecomment-867135453
         // - Import attributes would be the best.
         //   - But it only works with Node.js >=21: https://nodejs.org/api/esm.html#import-attributes
         //     - But it's probably ok to tell users "to use real imports you need Node.js 21 or above".
-        //   - It seems to work well with the latest TypeScript versions: TypeScript doesn't complain upon `with { type: 'unknown-to-typescript' }` and go-to-definition & types are preserved.
+        //   - 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
         //   - Esbuid seems to support it: https://esbuild.github.io/plugins/#on-load-arguments:~:text=This%20contains%20a%20map%20of%20the%20import%20attributes%20that
         //   - acorn supports it over an acorn plugin: https://github.com/acornjs/acorn/issues/983
         //     - Maybe we can use an esbuild plugin instead of acorn to apply transformImports()?

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

@@ -1,9 +1,9 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
-export { getConfigExecutionErrorIntroMsg as getConfigExecutionErrorIntroMsg };
+export { getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import 'source-map-support/register.js';
-import type { FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
+import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
 declare function transpileAndExecuteFile(filePath: FilePathResolved, isValueFile: boolean, userRootDir: string, isConfigOfExtension?: boolean): Promise<{
     fileExports: Record<string, unknown>;
 }>;

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

@@ -1,29 +1,39 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
-export { getConfigExecutionErrorIntroMsg as getConfigExecutionErrorIntroMsg };
+export { getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import { build, formatMessages } from 'esbuild';
 import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath } from '../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, unique, assertWarning, isObject, toPosixPath } from '../../../../utils.js';
 import { isImportData, transformImports } from './transformImports.js';
-import { vikeConfigDependencies } from './getVikeConfig.js';
+import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
-import { getConfigFileExport } from './getConfigFileExport.js';
+import { getConfigFileExport } from '../getConfigFileExport.js';
 assertIsNotProductionRuntime();
 async function transpileAndExecuteFile(filePath, isValueFile, userRootDir, isConfigOfExtension = false) {
-    const { code, fileImportsTransformed } = await transpileFile(filePath, isValueFile, userRootDir, isConfigOfExtension);
-    const { fileExports } = await executeFile(filePath, code, fileImportsTransformed, isValueFile);
-    return { fileExports };
+    if (isConfigOfExtension) {
+        const fileExports = await executeFile(filePath.filePathAbsoluteFilesystem, filePath);
+        if (isHeaderFile(filePath.filePathAbsoluteFilesystem)) {
+            const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+            assertWarning(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files don't apply to the config files of extensions`, { onlyOnce: true });
+        }
+        return { fileExports };
+    }
+    else {
+        const { code, fileImportsTransformed } = await transpileFile(filePath, isValueFile, userRootDir);
+        const fileExports = await executeTranspiledFile(filePath, code, fileImportsTransformed, isValueFile);
+        return { fileExports };
+    }
 }
-async function transpileFile(filePath, isValueFile, userRootDir, isConfigOfExtension) {
+async function transpileFile(filePath, isValueFile, userRootDir) {
     const { filePathAbsoluteFilesystem } = filePath;
     const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    const importsAreTransformed = !isConfigOfExtension && !isValueFile;
+    const importsAreTransformed = !isValueFile;
     let code = await transpileWithEsbuild(filePath, userRootDir, importsAreTransformed, isValueFile);
     let fileImportsTransformed = null;
     if (importsAreTransformed) {
@@ -38,9 +48,6 @@ async function transpileFile(filePath, isValueFile, userRootDir, isConfigOfExten
             if (isValueFile) {
                 assertWarning(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files only apply to +config.h.js, see https://vike.dev/header-file`, { onlyOnce: true });
             }
-            else if (isConfigOfExtension) {
-                assertWarning(false, `${filePathToShowToUser2} is a JavaScript header file (.h.js), but JavaScript header files don't apply to the config files of extensions`, { onlyOnce: true });
-            }
             else {
                 assert(false);
             }
@@ -140,7 +147,7 @@ async function transpileWithEsbuild(filePath, userRootDir, importsAreTransformed
     assert(typeof code === 'string');
     return code;
 }
-async function executeFile(filePath, code, fileImportsTransformed, isValueFile) {
+async function executeTranspiledFile(filePath, code, fileImportsTransformed, isValueFile) {
     const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
@@ -149,28 +156,35 @@ async function executeFile(filePath, code, fileImportsTransformed, isValueFile)
     const clean = () => fs.unlinkSync(filePathTmp);
     let fileExports = {};
     try {
-        fileExports = await import_(filePathTmp);
-    }
-    catch (err) {
-        triggerPrepareStackTrace(err);
-        const errIntroMsg = getErrIntroMsg('execute', filePath);
-        assert(isObject(err));
-        execErrIntroMsg.set(err, errIntroMsg);
-        throw err;
+        fileExports = await executeFile(filePathTmp, filePath);
     }
     finally {
         clean();
     }
-    // Return a plain JavaScript object
-    //  - import() returns `[Module: null prototype] { default: { onRenderClient: '...' }}`
-    //  - We don't need this special object
-    fileExports = { ...fileExports };
     if (fileImportsTransformed && !isValueFile) {
         assert(filePathRelativeToUserRootDir !== undefined);
         const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
         assertImportsAreReExported(fileImportsTransformed, fileExports, filePathToShowToUser2);
     }
-    return { fileExports };
+    return fileExports;
+}
+async function executeFile(filePathToExecuteAbsoluteFilesystem, filePathSourceFile) {
+    let fileExports = {};
+    try {
+        fileExports = await import_(filePathToExecuteAbsoluteFilesystem);
+    }
+    catch (err) {
+        triggerPrepareStackTrace(err);
+        const errIntroMsg = getErrIntroMsg('execute', filePathSourceFile);
+        assert(isObject(err));
+        execErrIntroMsg.set(err, errIntroMsg);
+        throw err;
+    }
+    // Return a plain JavaScript object:
+    //  - import() returns `[Module: null prototype] { default: { onRenderClient: '...' }}`
+    //  - We don't need this special object.
+    fileExports = { ...fileExports };
+    return fileExports;
 }
 const formatted = '_formatted';
 function getConfigBuildErrorFormatted(err) {
@@ -200,10 +214,10 @@ function getConfigExecutionErrorIntroMsg(err) {
     return errIntroMsg ?? null;
 }
 const tmpPrefix = `[build-`;
-function getFilePathTmp(filePath) {
-    assertPosixPath(filePath);
-    const dirname = path.posix.dirname(filePath);
-    const filename = path.posix.basename(filePath);
+function getFilePathTmp(filePathAbsoluteFilesystem) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    const dirname = path.posix.dirname(filePathAbsoluteFilesystem);
+    const filename = path.posix.basename(filePathAbsoluteFilesystem);
     // Syntax with semicolon `[build:${/*...*/}]` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
     const tag = `${tmpPrefix}${getRandomId(12)}]`;
     const filePathTmp = path.posix.join(dirname, `${tag}${filename}.mjs`);

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

@@ -2,9 +2,22 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
+export type { InterfaceValueFile };
+import type { PageConfigGlobalBuildTime, PageConfigBuildTime, FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ExtensionResolved } from '../../../../../shared/ConfigVike.js';
 import type { ResolvedConfig } from 'vite';
+type InterfaceFileCommons = {
+    filePath: FilePathResolved;
+    fileExportsByConfigName: Record<ConfigName, {
+        configValue?: unknown;
+    }>;
+};
+type InterfaceValueFile = InterfaceFileCommons & {
+    isConfigFile: false;
+    isValueFile: true;
+    configName: string;
+};
+type ConfigName = string;
 type VikeConfig = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;