vike 0.4.220-commit-af5c91f → 0.4.221-commit-8577456

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

@@ -4,7 +4,7 @@ import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/vir
 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';
 import { getOutDirs } from '../../shared/getOutDirs.js';
 import { viteIsSSR_options } from '../../shared/viteIsSSR.js';

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

@@ -1,15 +1,17 @@
 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 vikeConfig;
@@ -118,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())
@@ -129,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,51 +1,51 @@
 export { assertExtensionsConventions };
 export { assertExtensionsRequire };
 import pc from '@brillout/picocolors';
-import { isObjectOfStrings } from '../../../../../utils/isObjectOfStrings.js';
-import { PROJECT_VERSION, assert, assertUsage, assertWarning, findPackageJson } from '../../../utils.js';
-import { getConfVal } 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 = getNameValue(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 = getNameValue(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 assertExtensionsRequire(pageConfig) {
-    const interfaceFilesRelevantList = Object.values(pageConfig.interfaceFiles).flat(1);
+    const plusFilesRelevantList = Object.values(pageConfig.plusFiles).flat(1);
     // Collect extensions
     const extensions = {};
-    interfaceFilesRelevantList.forEach((interfaceFile) => {
-        const name = getNameValue(interfaceFile);
+    plusFilesRelevantList.forEach((plusFile) => {
+        const name = getNameValue(plusFile);
         if (name) {
-            const version = getExtensionVersion(name, interfaceFile);
+            const version = getExtensionVersion(name, plusFile);
             extensions[name] = version;
         }
     });
     // Enforce `require`
-    interfaceFilesRelevantList.forEach((interfaceFile) => {
-        const require = getConfigRequireValue(interfaceFile);
+    plusFilesRelevantList.forEach((plusFile) => {
+        const require = getConfigRequireValue(plusFile);
         if (!require)
             return;
-        const name = getNameValue(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)}`;
@@ -59,36 +59,36 @@ function assertExtensionsRequire(pageConfig) {
         });
     });
 }
-function getConfigRequireValue(interfaceFile) {
-    const confVal = getConfVal(interfaceFile, 'require');
+function getConfigRequireValue(plusFile) {
+    const confVal = getConfVal(plusFile, 'require');
     if (!confVal)
         return null;
     assert(confVal.configValueLoaded);
     const require = confVal.configValue;
-    const { filePathToShowToUserResolved } = interfaceFile.filePath;
+    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 getNameValue(interfaceFile) {
-    const confVal = getConfVal(interfaceFile, 'name');
+function getNameValue(plusFile) {
+    const confVal = getConfVal(plusFile, 'name');
     if (!confVal)
         return null;
     assert(confVal.configValueLoaded);
     const name = confVal.configValue;
-    const filePathToShowToUser = getFilePathToShowToUser(interfaceFile);
+    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;
@@ -97,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,
@@ -155,12 +157,42 @@ const configDefinitionsBuiltInAll = {
             'string'
         ]
     },
-    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' }
+    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);
@@ -175,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

@@ -5,7 +5,7 @@ export type { ConfigFile };
 export type { PointerImportLoaded };
 import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 import { type EsbuildCache } from './transpileAndExecuteFile.js';
-import { type InterfaceValueFile } from '../getVikeConfig.js';
+import type { PlusFileValue } from './getPlusFilesAll.js';
 import { PointerImport } from './resolvePointerImport.js';
 import type { ConfigDefinitions } from './configDefinitionsBuiltIn.js';
 type ConfigFile = {
@@ -20,7 +20,7 @@ type PointerImportLoaded = PointerImport & ({
 } | {
     fileExportValueLoaded: false;
 });
-declare function loadValueFile(interfaceValueFile: InterfaceValueFile, configDefinitions: ConfigDefinitions, userRootDir: string, esbuildCache: EsbuildCache): Promise<void>;
+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[];

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

@@ -8,7 +8,7 @@ import { getConfigDefinitionOptional } from '../getVikeConfig.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
 import { parsePointerImportData } from './transformPointerImports.js';
-import { getConfigFileExport } from '../getConfigFileExport.js';
+import { getConfigFileExport } from './getConfigFileExport.js';
 import { resolvePointerImportData } from './resolvePointerImport.js';
 import { getConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
 assertIsNotProductionRuntime();
@@ -36,8 +36,8 @@ async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir,
     // Only load value files with `env.config===true`
     if (!configDef || !shouldBeLoadableAtBuildTime(configDef))
         return;
-    interfaceValueFile.isValueFileLoaded = true;
-    assert(interfaceValueFile.isValueFileLoaded);
+    interfaceValueFile.isNotLoaded = false;
+    assert(!interfaceValueFile.isNotLoaded);
     interfaceValueFile.fileExportsByConfigName = {};
     const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false, esbuildCache);
     const { filePathToShowToUser } = interfaceValueFile.filePath;

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

@@ -2,50 +2,15 @@ export { getVikeConfig };
 export { getVikeConfig2 };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
-export { isVikeConfigFile };
 export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export type { VikeConfigObject };
-export type { InterfaceValueFile };
-export type { InterfaceFile };
-export type { InterfaceFilesByLocationId };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type ConfigDefinitions, type ConfigDefinitionInternal } from './getVikeConfig/configDefinitionsBuiltIn.js';
-import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
-import { type PointerImportLoaded } from './getVikeConfig/loadFileAtConfigTime.js';
-import type { FilePathResolved } from '../../../../../shared/page-configs/FilePath.js';
 import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
-type InterfaceFile = InterfaceConfigFile | InterfaceValueFile;
-type InterfaceFileCommons = {
-    locationId: LocationId;
-    filePath: FilePathResolved;
-};
-type InterfaceConfigFile = InterfaceFileCommons & {
-    isConfigFile: true;
-    isValueFile: false;
-    extendsFilePaths: string[];
-    isConfigExtension: boolean;
-    isValueFileLoaded: true;
-    fileExportsByConfigName: Record<string, // configName
-    unknown>;
-    pointerImportsByConfigName: Record<string, // configValue
-    PointerImportLoaded>;
-};
-type InterfaceValueFile = InterfaceFileCommons & {
-    isConfigFile: false;
-    isValueFile: true;
-    isConfigExtension?: undefined;
-    configName: string;
-} & ({
-    isValueFileLoaded: true;
-    fileExportsByConfigName: Record<string, // configName
-    unknown>;
-} | {
-    isValueFileLoaded: false;
-});
-type InterfaceFilesByLocationId = Record<LocationId, InterfaceFile[]>;
+import { type PlusFile } from './getVikeConfig/getPlusFilesAll.js';
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
@@ -58,9 +23,8 @@ declare function getVikeConfig(config: ResolvedConfig, { doNotRestartViteOnError
 }): Promise<VikeConfigObject>;
 declare function getVikeConfig2(userRootDir: string, isDev: boolean, vikeVitePluginOptions: unknown): Promise<VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig): Promise<boolean>;
-declare function isVikeConfigFile(filePath: string): boolean;
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitions, configName: string): ConfigDefinitionInternal | null;
-declare function getConfVal(interfaceFile: InterfaceFile, configName: string): null | {
+declare function getConfVal(plusFile: PlusFile, configName: string): null | {
     configValue: unknown;
     configValueLoaded: true;
 } | {