vike 0.4.220 → 0.4.221-commit-8577456

package/dist/esm/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -1,21 +1,22 @@
 export { getVirtualFileImportUserCode };
-import { assert, assertPosixPath, viteIsSSR_options, scriptFileExtensions, debugGlob, getOutDirs, isVersionOrAbove, assertWarning } from '../../utils.js';
+import { assert, assertPosixPath, scriptFileExtensions, debugGlob, isVersionOrAbove, assertWarning } from '../../utils.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { version as viteVersion } from 'vite';
 import { fileTypes } from '../../../../shared/getPageFiles/fileTypes.js';
 import path from 'path';
-import { getVirtualFilePageConfigs } from './v1-design/getVirtualFilePageConfigs.js';
+import { getVirtualFilePageConfigs } from './v1-design/virtual-files/getVirtualFilePageConfigs.js';
 import { isV1Design as isV1Design_ } from './v1-design/getVikeConfig.js';
-async function getVirtualFileImportUserCode(id, options, vikeConfigGlobal, config, isDev) {
+import { getOutDirs } from '../../shared/getOutDirs.js';
+import { viteIsSSR_options } from '../../shared/viteIsSSR.js';
+async function getVirtualFileImportUserCode(id, options, vikeConfig, config, isDev) {
     const idParsed = isVirtualFileIdImportUserCode(id);
     assert(idParsed);
     const { isForClientSide, isClientRouting } = idParsed;
     assert(isForClientSide === !viteIsSSR_options(options));
-    const isPrerendering = !!vikeConfigGlobal.prerender;
-    const code = await getCode(config, vikeConfigGlobal, isForClientSide, isClientRouting, isPrerendering, isDev, id);
+    const code = await getCode(config, vikeConfig, isForClientSide, isClientRouting, isDev, id);
     return code;
 }
-async function getCode(config, vikeConfigGlobal, isForClientSide, isClientRouting, isPrerendering, isDev, id) {
+async function getCode(config, vikeConfig, isForClientSide, isClientRouting, isDev, id) {
     const { command } = config;
     assert(command === 'serve' || command === 'build');
     const isBuild = command === 'build';
@@ -24,7 +25,7 @@ async function getCode(config, vikeConfigGlobal, isForClientSide, isClientRoutin
     {
         const globRoots = getGlobRoots(config);
         debugGlob('Glob roots: ', globRoots);
-        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfigGlobal, isPrerendering, config, isDev, id);
+        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfig, config, isDev, id);
     }
     debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
     return content;
@@ -54,7 +55,7 @@ function determineInjection({ fileType, isForClientSide, isClientRouting, isPrer
         }
     }
 }
-async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfigGlobal, isPrerendering, config, isDev, id) {
+async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, vikeConfig, config, isDev, id) {
     let fileContent = `// Generated by https://github.com/vikejs/vike/blob/main/vike/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.ts
 
 export const pageFilesLazy = {};
@@ -69,6 +70,8 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
 `;
     // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
     const isV1Design = await isV1Design_(config);
+    // Old design => no + files => only to enable pre-rendering is setting `vike({prerender})` in vite.config.js
+    const isPrerendering = !!vikeConfig.global.config.prerender;
     fileTypes
         .filter((fileType) => fileType !== '.css')
         .forEach((fileType) => {
@@ -86,7 +89,9 @@ ${await getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, c
             fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames', isV1Design);
         }
     });
-    if (vikeConfigGlobal.includeAssetsImportedByServer && isForClientSide) {
+    // TODO/now: add meta.default
+    const includeAssetsImportedByServer = vikeConfig.global.config.includeAssetsImportedByServer ?? true;
+    if (includeAssetsImportedByServer && isForClientSide) {
         fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets', isV1Design);
     }
     return fileContent;

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

@@ -1,23 +1,24 @@
 export { importUserCode };
 import { normalizePath } from 'vite';
-import { getVirtualFilePageConfigValuesAll } from './v1-design/getVirtualFilePageConfigValuesAll.js';
+import { getVirtualFilePageConfigValuesAll } from './v1-design/virtual-files/getVirtualFilePageConfigValuesAll.js';
 import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
 import { assert, assertPosixPath } from '../../utils.js';
 import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../../shared/virtual-files.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile, isV1Design, getVikeConfig } from './v1-design/getVikeConfig.js';
+import { vikeConfigDependencies, reloadVikeConfig, isV1Design, getVikeConfig } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../../shared/loggerNotProd.js';
 import { getModuleFilePathAbsolute } from '../../shared/getFilePath.js';
+import { getPlusFileValueConfigName } from './v1-design/getVikeConfig/getPlusFilesAll.js';
+import { updateUserFiles } from '../../../runtime/globalContext.js';
 function importUserCode() {
     let config;
-    let vikeConfigGlobal;
+    let vikeConfig;
     return {
         name: 'vike:importUserCode',
         async configResolved(config_) {
-            const vikeConfig = await getVikeConfig(config_);
-            vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
+            vikeConfig = await getVikeConfig(config_);
             config = config_;
             // TODO/v1-release: remove
             {
@@ -52,7 +53,7 @@ function importUserCode() {
                 return code;
             }
             if (isVirtualFileIdImportUserCode(id)) {
-                const code = await getVirtualFileImportUserCode(id, options, vikeConfigGlobal, config, isDev);
+                const code = await getVirtualFileImportUserCode(id, options, vikeConfig, config, isDev);
                 return code;
             }
         },
@@ -119,6 +120,7 @@ function reloadConfig(filePath, config, op) {
         logConfigInfo(msg, 'info');
     }
     reloadVikeConfig(config);
+    updateUserFiles();
 }
 function getVirtualModules(server) {
     const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())
@@ -130,3 +132,6 @@ function getVirtualModules(server) {
     });
     return virtualModules;
 }
+function isVikeConfigFile(filePath) {
+    return !!getPlusFileValueConfigName(filePath);
+}

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

@@ -0,0 +1,6 @@
+export { assertExtensionsConventions };
+export { assertExtensionsRequire };
+import type { PlusFile } from './getPlusFilesAll.js';
+import { PageConfigBuildTime } from '../../../../../../shared/page-configs/PageConfig.js';
+declare function assertExtensionsConventions(plusFile: PlusFile): void;
+declare function assertExtensionsRequire(pageConfig: PageConfigBuildTime): void;

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

@@ -1,50 +1,51 @@
 export { assertExtensionsConventions };
-export { assertExtensionsPeerDependencies };
+export { assertExtensionsRequire };
 import pc from '@brillout/picocolors';
-import { isObjectOfStrings } from '../../../../../utils/isObjectOfStrings.js';
-import { PROJECT_VERSION, assert, assertUsage, assertWarning, findPackageJson } from '../../../utils.js';
-import { getConfigValueInterfaceFile } from './getVikeConfig.js';
+import { isObjectOfStrings } from '../../../../../../utils/isObjectOfStrings.js';
+import { PROJECT_VERSION, assert, assertUsage, assertWarning, findPackageJson } from '../../../../utils.js';
+import { getConfVal } from '../getVikeConfig.js';
 import path from 'path';
 import semver from 'semver';
-function assertExtensionsConventions(interfaceFile) {
-    assertExtensionName(interfaceFile);
-    assertConfigExportPath(interfaceFile);
+function assertExtensionsConventions(plusFile) {
+    assertExtensionName(plusFile);
+    assertConfigExportPath(plusFile);
 }
-function assertConfigExportPath(interfaceFile) {
-    const { importPathAbsolute, filePathAbsoluteFilesystem } = interfaceFile.filePath;
+function assertConfigExportPath(plusFile) {
+    const { importPathAbsolute, filePathAbsoluteFilesystem } = plusFile.filePath;
     // Ejected Vike extension
     if (!importPathAbsolute) {
         const p = filePathAbsoluteFilesystem;
         assert(!p.includes('node_modules'));
         return;
     }
-    const name = getConfigNameValue(interfaceFile);
+    const name = getNameValue(plusFile);
     assert(name); // already asserted in assertExtensionName()
     const importPathAbsoluteExpected = `${name}/config`;
     assertWarning(importPathAbsolute === importPathAbsoluteExpected, `The Vike configuration of ${pc.bold(name)} is exported at ${pc.bold(importPathAbsolute)}, but it should be exported at ${pc.bold(importPathAbsoluteExpected)} instead.`, { onlyOnce: true });
 }
-function assertExtensionName(interfaceFile) {
-    const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
-    const name = getConfigNameValue(interfaceFile);
+function assertExtensionName(plusFile) {
+    const filePathToShowToUser = getFilePathToShowToUser(plusFile);
+    const name = getNameValue(plusFile);
     assertUsage(name, `Vike extension name missing: the config ${filePathToShowToUser} must define the setting ${pc.cyan('name')}`);
 }
-function assertExtensionsPeerDependencies(interfaceFilesRelevantList) {
-    // Get installed extensions
+function assertExtensionsRequire(pageConfig) {
+    const plusFilesRelevantList = Object.values(pageConfig.plusFiles).flat(1);
+    // Collect extensions
     const extensions = {};
-    interfaceFilesRelevantList.forEach((interfaceFile) => {
-        const name = getConfigNameValue(interfaceFile);
+    plusFilesRelevantList.forEach((plusFile) => {
+        const name = getNameValue(plusFile);
         if (name) {
-            const version = getExtensionVersion(name, interfaceFile);
+            const version = getExtensionVersion(name, plusFile);
             extensions[name] = version;
         }
     });
-    // Enforce peer dependencies
-    interfaceFilesRelevantList.forEach((interfaceFile) => {
-        const require = getConfigRequireValue(interfaceFile);
+    // Enforce `require`
+    plusFilesRelevantList.forEach((plusFile) => {
+        const require = getConfigRequireValue(plusFile);
         if (!require)
             return;
-        const name = getConfigNameValue(interfaceFile);
-        const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
+        const name = getNameValue(plusFile);
+        const filePathToShowToUser = getFilePathToShowToUser(plusFile);
         assertUsage(name, `Setting ${pc.bold('name')} is required for being able to use setting ${pc.bold('require')} in ${filePathToShowToUser}.`);
         Object.entries(require).forEach(([reqName, reqVersion]) => {
             const errBase = `${pc.bold(name)} requires ${pc.bold(reqName)}`;
@@ -58,32 +59,36 @@ function assertExtensionsPeerDependencies(interfaceFilesRelevantList) {
         });
     });
 }
-function getConfigRequireValue(interfaceFile) {
-    const require = getConfigValueInterfaceFile(interfaceFile, 'require');
-    if (!require)
+function getConfigRequireValue(plusFile) {
+    const confVal = getConfVal(plusFile, 'require');
+    if (!confVal)
         return null;
-    const { filePathToShowToUserResolved } = interfaceFile.filePath;
+    assert(confVal.configValueLoaded);
+    const require = confVal.configValue;
+    const { filePathToShowToUserResolved } = plusFile.filePath;
     assert(filePathToShowToUserResolved);
     assertUsage(isObjectOfStrings(require), `The setting ${pc.bold('require')} defined at ${filePathToShowToUserResolved} should be an object with string values (${pc.bold('Record<string, string>')}).`);
     return require;
 }
-function getConfigNameValue(interfaceFile) {
-    const name = getConfigValueInterfaceFile(interfaceFile, 'name');
-    if (!name)
+function getNameValue(plusFile) {
+    const confVal = getConfVal(plusFile, 'name');
+    if (!confVal)
         return null;
-    const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
+    assert(confVal.configValueLoaded);
+    const name = confVal.configValue;
+    const filePathToShowToUser = getFilePathToShowToUser(plusFile);
     assertUsage(typeof name === 'string', `The setting ${pc.bold('name')} defined at ${filePathToShowToUser} should be a string.`);
     return name;
 }
 // We use a forever cache: users need to restart the dev server anyways when touching node_modules/**/* (I presume Vite doesn't pick up node_modules/**/* changes).
 const extensionsVersion = {};
-function getExtensionVersion(name, interfaceFile) {
+function getExtensionVersion(name, plusFile) {
     if (!extensionsVersion[name]) {
-        const extensionConfigFilePath = interfaceFile.filePath.filePathAbsoluteFilesystem;
+        const extensionConfigFilePath = plusFile.filePath.filePathAbsoluteFilesystem;
         const found = findPackageJson(path.posix.dirname(extensionConfigFilePath));
         assert(found);
         const { packageJson, packageJsonPath } = found;
-        const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
+        const filePathToShowToUser = getFilePathToShowToUser(plusFile);
         const nameExpected = packageJson.name;
         assertWarning(name === nameExpected, `The setting ${pc.bold('name')} defined at ${filePathToShowToUser} is ${pc.bold(JSON.stringify(name))}, but it should be equal to ${pc.bold(JSON.stringify(nameExpected))} (the value of ${packageJsonPath}${pc.dim('#')}${pc.bold('name')})`, { onlyOnce: true });
         const { version } = packageJson;
@@ -92,8 +97,8 @@ function getExtensionVersion(name, interfaceFile) {
     }
     return extensionsVersion[name];
 }
-function getFilePathToShowToUser(interfaceFile) {
-    const { filePathToShowToUserResolved } = interfaceFile.filePath;
+function getFilePathToShowToUser(plusFile) {
+    const { filePathToShowToUserResolved } = plusFile.filePath;
     assert(filePathToShowToUserResolved);
     return filePathToShowToUserResolved;
 }

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

@@ -1,4 +1,4 @@
-export { configDefinitionsBuiltInAll };
+export { configDefinitionsBuiltIn };
 export type { ConfigDefinition };
 export type { ConfigDefinitions };
 export type { ConfigDefinitionInternal };
@@ -74,4 +74,4 @@ type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
 type ConfigDefinitions = Record<string, // configName
 ConfigDefinitionInternal>;
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn | ConfigNameGlobal, ConfigDefinitionInternal>;
-declare const configDefinitionsBuiltInAll: ConfigDefinitionsBuiltIn;
+declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;

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

@@ -1,7 +1,7 @@
-export { configDefinitionsBuiltInAll };
+export { configDefinitionsBuiltIn };
 import { assert, assertUsage } from '../../../../utils.js';
 import { getConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
-const configDefinitionsBuiltInAll = {
+const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true }
     },
@@ -87,11 +87,14 @@ const configDefinitionsBuiltInAll = {
         _computed: (configValueSources) => {
             {
                 const source = getConfigValueSource(configValueSources, 'clientHooks');
-                if (source && source.value !== null) {
-                    const { value } = source;
-                    const definedAt = getConfigDefinedAt('Config', 'clientHooks', source.definedAtFilePath);
-                    assertUsage(typeof value === 'boolean', `${definedAt} should be a boolean`);
-                    return value;
+                if (source) {
+                    assert(source.valueIsLoaded);
+                    if (source.value !== null) {
+                        const { value } = source;
+                        const definedAt = getConfigDefinedAt('Config', 'clientHooks', source.definedAtFilePath);
+                        assertUsage(typeof value === 'boolean', `${definedAt} should be a boolean`);
+                        return value;
+                    }
                 }
             }
             return (isConfigSet(configValueSources, 'onRenderClient') &&
@@ -127,8 +130,7 @@ const configDefinitionsBuiltInAll = {
     keepScrollPosition: {
         env: { client: true }
     },
-    // TODO/eventually: define it as a global config.
-    middleware: { env: { server: true }, cumulative: true, eager: true },
+    middleware: { env: { server: true }, cumulative: true, eager: true, global: true },
     onPrerenderStart: {
         env: { server: true, production: true },
         eager: true,
@@ -139,7 +141,12 @@ const configDefinitionsBuiltInAll = {
         eager: true,
         global: true
     },
-    prerender: { env: { config: true }, global: (value) => typeof value !== 'object', type: ['boolean', 'object'] },
+    prerender: {
+        env: { config: true },
+        global: (value) => typeof value === 'object',
+        type: ['boolean', 'object'],
+        cumulative: true
+    },
     vite: { env: { config: true }, global: true, cumulative: true, type: 'object' },
     disableAutoFullBuild: {
         env: { config: true },
@@ -150,12 +157,42 @@ const configDefinitionsBuiltInAll = {
             'string'
         ]
     },
-    includeAssetsImportedByServer: { env: { config: true }, global: true, type: 'boolean' },
-    baseAssets: { env: { config: true }, global: true, type: 'string' },
-    baseServer: { env: { config: true }, global: true, type: 'string' },
-    redirects: { env: { server: true }, global: true, type: 'string{}', cumulative: true },
-    trailingSlash: { env: { server: true }, global: true, type: 'boolean' },
-    disableUrlNormalization: { env: { server: true }, global: true, type: 'boolean' }
+    viteEnvironmentAPI: {
+        env: { config: true },
+        global: true,
+        type: 'boolean'
+    },
+    includeAssetsImportedByServer: {
+        env: { config: true },
+        global: true,
+        type: 'boolean'
+    },
+    baseAssets: {
+        env: { config: true, server: true },
+        global: true,
+        type: 'string'
+    },
+    baseServer: {
+        env: { config: true, server: true },
+        global: true,
+        type: 'string'
+    },
+    redirects: {
+        env: { server: true },
+        global: true,
+        type: 'string{}',
+        cumulative: true
+    },
+    trailingSlash: {
+        env: { server: true },
+        global: true,
+        type: 'boolean'
+    },
+    disableUrlNormalization: {
+        env: { server: true },
+        global: true,
+        type: 'boolean'
+    }
 };
 function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);
@@ -170,11 +207,11 @@ function getConfigEnv(configValueSources, configName) {
     return env;
 }
 function isConfigSet(configValueSources, configName) {
-    const configValueSource = getConfigValueSource(configValueSources, configName);
-    // Enable users to suppress global config values by overriding the config's value to null
-    if (configValueSource?.value === null)
-        return false;
-    return !!configValueSource;
+    const source = getConfigValueSource(configValueSources, configName);
+    return (!!source &&
+        !(source.valueIsLoaded &&
+            // Enable users to suppress inherited config by overriding it with `null`
+            source.value === null));
 }
 function getConfigValueSource(configValueSources, configName) {
     const sources = configValueSources[configName];

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

@@ -1,7 +1,7 @@
 export { getConfigFileExport };
 import pc from '@brillout/picocolors';
-import { assertPlusFileExport } from '../../../../../shared/page-configs/assertPlusFileExport.js';
-import { assertUsage, isObject } from '../../../utils.js';
+import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
+import { assertUsage, isObject } from '../../../../utils.js';
 function getConfigFileExport(fileExports, filePathToShowToUser) {
     assertPlusFileExport(fileExports, filePathToShowToUser, 'config');
     const usesNamedExport = !!fileExports.config;

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

@@ -0,0 +1,39 @@
+export { getPlusFilesAll };
+export { getPlusFileValueConfigName };
+export type { PlusFileValue };
+export type { PlusFile };
+export type { PlusFilesByLocationId };
+import { type LocationId } from './filesystemRouting.js';
+import { type EsbuildCache } from './transpileAndExecuteFile.js';
+import { PointerImportLoaded } from './loadFileAtConfigTime.js';
+import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
+type PlusFile = PlusFileConfig | PlusFileValue;
+type PlusFileCommons = {
+    locationId: LocationId;
+    filePath: FilePathResolved;
+};
+type PlusFileConfig = PlusFileCommons & {
+    isConfigFile: true;
+    fileExportsByConfigName: Record<string, // configName
+    unknown>;
+    pointerImportsByConfigName: Record<string, // configName
+    PointerImportLoaded>;
+    isExtensionConfig: boolean;
+    extendsFilePaths: string[];
+    isNotLoaded?: undefined;
+};
+type PlusFileValue = PlusFileCommons & {
+    isConfigFile: false;
+    configName: string;
+} & ({
+    isNotLoaded: false;
+    fileExportsByConfigName: Record<string, // configName
+    unknown>;
+} | {
+    isNotLoaded: true;
+}) & {
+    isExtensionConfig?: undefined;
+};
+type PlusFilesByLocationId = Record<LocationId, PlusFile[]>;
+declare function getPlusFilesAll(userRootDir: string, esbuildCache: EsbuildCache): Promise<PlusFilesByLocationId>;
+declare function getPlusFileValueConfigName(filePath: string): string | null;

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

@@ -0,0 +1,154 @@
+export { getPlusFilesAll };
+export { getPlusFileValueConfigName };
+import { assert, assertPosixPath, assertUsage } from '../../../../utils.js';
+import { configDefinitionsBuiltIn } from './configDefinitionsBuiltIn.js';
+import { getLocationId } from './filesystemRouting.js';
+import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
+import { crawlPlusFiles } from './crawlPlusFiles.js';
+import { getConfigFileExport } from './getConfigFileExport.js';
+import { loadConfigFile, loadValueFile } from './loadFileAtConfigTime.js';
+import { resolvePointerImport } from './resolvePointerImport.js';
+import { getFilePathResolved } from '../../../../shared/getFilePath.js';
+import { assertExtensionsConventions } from './assertExtensions.js';
+import path from 'node:path';
+async function getPlusFilesAll(userRootDir, esbuildCache) {
+    const plusFiles = await findPlusFiles(userRootDir, null);
+    const configFiles = [];
+    const valueFiles = [];
+    plusFiles.forEach((f) => {
+        if (getPlusFileValueConfigName(f.filePathAbsoluteFilesystem) === 'config') {
+            configFiles.push(f);
+        }
+        else {
+            valueFiles.push(f);
+        }
+    });
+    let plusFilesAll = {};
+    await Promise.all([
+        // Config files
+        ...configFiles.map(async (filePath) => {
+            const { filePathAbsoluteUserRootDir } = filePath;
+            assert(filePathAbsoluteUserRootDir);
+            const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false, esbuildCache);
+            assert(filePath.filePathAbsoluteUserRootDir);
+            const locationId = getLocationId(filePathAbsoluteUserRootDir);
+            const plusFile = getPlusFileFromConfigFile(configFile, false, locationId, userRootDir);
+            plusFilesAll[locationId] = plusFilesAll[locationId] ?? [];
+            plusFilesAll[locationId].push(plusFile);
+            extendsConfigs.forEach((extendsConfig) => {
+                /* We purposely use the same locationId because the Vike extension's config should only apply to where it's being extended from, for example:
+                ```js
+                // /pages/admin/+config.js
+        
+                import vikeVue from 'vike-vue/config'
+                // Should only apply to /pages/admin/**
+                export default { extends: [vikeVue] }
+                ```
+                ```js
+                // /pages/marketing/+config.js
+        
+                import vikeReact from 'vike-react/config'
+                // Should only apply to /pages/marketing/**
+                export default { extends: [vikeReact] }
+                ```
+                */
+                const plusFile = getPlusFileFromConfigFile(extendsConfig, true, locationId, userRootDir);
+                assertExtensionsConventions(plusFile);
+                plusFilesAll[locationId].push(plusFile);
+            });
+        }),
+        // Value files
+        ...valueFiles.map(async (filePath) => {
+            const { filePathAbsoluteUserRootDir } = filePath;
+            assert(filePathAbsoluteUserRootDir);
+            const configName = getPlusFileValueConfigName(filePathAbsoluteUserRootDir);
+            assert(configName);
+            const locationId = getLocationId(filePathAbsoluteUserRootDir);
+            const plusFile = {
+                locationId,
+                filePath,
+                isConfigFile: false,
+                isNotLoaded: true,
+                configName
+            };
+            plusFilesAll[locationId] = plusFilesAll[locationId] ?? [];
+            plusFilesAll[locationId].push(plusFile);
+            // We don't have access to the custom config definitions defined by the user yet.
+            //  - If `configDef` is `undefined` => we load the file +{configName}.js later.
+            //  - We already need to load +meta.js here (to get the custom config definitions defined by the user)
+            await loadValueFile(plusFile, configDefinitionsBuiltIn, userRootDir, esbuildCache);
+        })
+    ]);
+    // Make lists element order deterministic
+    Object.entries(plusFilesAll).forEach(([_locationId, plusFiles]) => {
+        plusFiles.sort(sortMakeDeterministic);
+    });
+    return plusFilesAll;
+}
+function getPlusFileFromConfigFile(configFile, isExtensionConfig, locationId, userRootDir) {
+    const { fileExports, filePath, extendsFilePaths } = configFile;
+    const fileExportsByConfigName = {};
+    const pointerImportsByConfigName = {};
+    const fileExport = getConfigFileExport(fileExports, filePath.filePathToShowToUser);
+    Object.entries(fileExport).forEach(([configName, configValue]) => {
+        fileExportsByConfigName[configName] = configValue;
+        const pointerImport = resolvePointerImport(configValue, configFile.filePath, userRootDir, configName);
+        if (pointerImport) {
+            pointerImportsByConfigName[configName] = {
+                ...pointerImport,
+                fileExportValueLoaded: false
+            };
+        }
+    });
+    const plusFile = {
+        locationId,
+        filePath,
+        fileExportsByConfigName,
+        pointerImportsByConfigName,
+        isConfigFile: true,
+        isExtensionConfig,
+        extendsFilePaths
+    };
+    return plusFile;
+}
+// Make order deterministic (no other purpose)
+function sortMakeDeterministic(plusFile1, plusFile2) {
+    return plusFile1.filePath.filePathAbsoluteVite < plusFile2.filePath.filePathAbsoluteVite ? -1 : 1;
+}
+async function findPlusFiles(userRootDir, outDirRoot) {
+    const files = await crawlPlusFiles(userRootDir, outDirRoot);
+    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
+    return plusFiles;
+}
+function getPlusFileValueConfigName(filePath) {
+    assertPosixPath(filePath);
+    if (isTemporaryBuildFile(filePath))
+        return null;
+    const fileName = path.posix.basename(filePath);
+    // assertNoUnexpectedPlusSign(filePath, fileName)
+    const basename = fileName.split('.')[0];
+    if (!basename.startsWith('+')) {
+        return null;
+    }
+    else {
+        const configName = basename.slice(1);
+        assertUsage(configName !== '', `${filePath} Invalid filename ${fileName}`);
+        return configName;
+    }
+}
+/* https://github.com/vikejs/vike/issues/1407
+function assertNoUnexpectedPlusSign(filePath: string, fileName: string) {
+  const dirs = path.posix.dirname(filePath).split('/')
+  dirs.forEach((dir, i) => {
+    const dirPath = dirs.slice(0, i + 1).join('/')
+    assertUsage(
+      !dir.includes('+'),
+      `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`
+    )
+  })
+  assertUsage(
+    !fileName.slice(1).includes('+'),
+    `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`
+  )
+}
+*/

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

@@ -1,21 +1,27 @@
-export { loadImportedFile };
+export { loadPointerImport };
 export { loadValueFile };
 export { loadConfigFile };
-export type { ImportedFilesLoaded };
 export type { ConfigFile };
+export type { PointerImportLoaded };
 import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
-import type { InterfaceValueFile } from '../getVikeConfig.js';
-type ImportedFilesLoaded = Record<string, Promise<Record<string, unknown>>>;
+import { type EsbuildCache } from './transpileAndExecuteFile.js';
+import type { PlusFileValue } from './getPlusFilesAll.js';
+import { PointerImport } from './resolvePointerImport.js';
+import type { ConfigDefinitions } from './configDefinitionsBuiltIn.js';
 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[], isExtensionConfig: boolean): Promise<{
+declare function loadPointerImport(pointerImport: PointerImportLoaded, userRootDir: string, configName: string, configDefinitions: ConfigDefinitions, esbuildCache: EsbuildCache): Promise<unknown>;
+type PointerImportLoaded = PointerImport & ({
+    fileExportValueLoaded: true;
+    fileExportValue: unknown;
+} | {
+    fileExportValueLoaded: false;
+});
+declare function loadValueFile(interfaceValueFile: PlusFileValue, configDefinitions: ConfigDefinitions, userRootDir: string, esbuildCache: EsbuildCache): Promise<void>;
+declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isExtensionConfig: boolean, esbuildCache: EsbuildCache): Promise<{
     configFile: ConfigFile;
     extendsConfigs: ConfigFile[];
 }>;