vike 0.4.220 → 0.4.221-commit-8577456

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

@@ -1,44 +1,58 @@
-// Files loadded at config time:
-export { loadImportedFile };
+// Files loaded at config time:
+export { loadPointerImport };
 export { loadValueFile };
 export { loadConfigFile };
 import { assert, assertUsage, assertIsNotProductionRuntime, isArrayOfStrings, isObject } from '../../../../utils.js';
 import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
+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 { resolvePointerImport } from './resolvePointerImport.js';
+import { getConfigFileExport } from './getConfigFileExport.js';
+import { resolvePointerImportData } from './resolvePointerImport.js';
+import { getConfigDefinedAt } from '../../../../../../shared/page-configs/getConfigDefinedAt.js';
 assertIsNotProductionRuntime();
 // Load pointer import
-async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
-    const f = import_.filePathAbsoluteFilesystem;
-    if (!importedFilesLoaded[f]) {
-        importedFilesLoaded[f] = transpileAndExecuteFile(import_, userRootDir, false).then((r) => r.fileExports);
-    }
-    const fileExports = await importedFilesLoaded[f];
-    const fileExport = fileExports[import_.fileExportName];
-    return fileExport;
+async function loadPointerImport(pointerImport, userRootDir, configName, configDefinitions, esbuildCache) {
+    // The value of `extends` was already loaded and already used: we don't need the value of `extends` anymore
+    if (configName === 'extends')
+        return;
+    const configDef = getConfigDefinitionOptional(configDefinitions, configName);
+    // Only load pointer import if `env.config===true`
+    if (!configDef || !shouldBeLoadableAtBuildTime(configDef))
+        return;
+    const configDefinedAt = getConfigDefinedAt('Config', configName, pointerImport.fileExportPath);
+    assertUsage(pointerImport.fileExportPath.filePathAbsoluteFilesystem, `${configDefinedAt} cannot be defined over an aliased import`);
+    const { fileExports } = await transpileAndExecuteFile(pointerImport.fileExportPath, userRootDir, false, esbuildCache);
+    const fileExportValue = fileExports[pointerImport.fileExportPath.fileExportName];
+    pointerImport.fileExportValueLoaded = true;
+    assert(pointerImport.fileExportValueLoaded);
+    pointerImport.fileExportValue = fileExportValue;
 }
 // Load +{configName}.js
-async function loadValueFile(interfaceValueFile, configName, userRootDir) {
-    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false);
+async function loadValueFile(interfaceValueFile, configDefinitions, userRootDir, esbuildCache) {
+    const { configName } = interfaceValueFile;
+    const configDef = getConfigDefinitionOptional(configDefinitions, configName);
+    // Only load value files with `env.config===true`
+    if (!configDef || !shouldBeLoadableAtBuildTime(configDef))
+        return;
+    interfaceValueFile.isNotLoaded = false;
+    assert(!interfaceValueFile.isNotLoaded);
+    interfaceValueFile.fileExportsByConfigName = {};
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, userRootDir, false, esbuildCache);
     const { filePathToShowToUser } = interfaceValueFile.filePath;
     assertPlusFileExport(fileExports, filePathToShowToUser, configName);
     Object.entries(fileExports).forEach(([exportName, configValue]) => {
         const configName_ = exportName === 'default' ? configName : exportName;
-        interfaceValueFile.fileExportsByConfigName[configName_] = { configValue };
+        interfaceValueFile.fileExportsByConfigName[configName_] = configValue;
     });
 }
 // Load +config.js, including all its extends pointer imports
-async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig) {
+async function loadConfigFile(configFilePath, userRootDir, visited, isExtensionConfig, esbuildCache) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
-    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true);
-    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
-        ...visited,
-        filePathAbsoluteFilesystem
-    ]);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, userRootDir, isExtensionConfig ? 'is-extension-config' : true, esbuildCache);
+    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [...visited, filePathAbsoluteFilesystem], esbuildCache);
     const configFile = {
         fileExports,
         filePath: configFilePath,
@@ -54,15 +68,15 @@ function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
     assert(loop[0] === filePathAbsoluteFilesystem);
     assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
 }
-async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
+async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited, esbuildCache) {
     const { extendsPointerImportData, extendsConfigs } = getExtendsPointerImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsPointerImportData.map((pointerImportData) => {
-        const filePath = resolvePointerImport(pointerImportData, configFilePath, userRootDir);
+        const filePath = resolvePointerImportData(pointerImportData, configFilePath, userRootDir);
         assert(filePath.filePathAbsoluteFilesystem);
         extendsConfigFiles.push(filePath);
     });
-    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true)));
+    const results = await Promise.all(extendsConfigFiles.map(async (configFilePath) => await loadConfigFile(configFilePath, userRootDir, visited, true, esbuildCache)));
     results.forEach((result) => {
         extendsConfigs.push(result.configFile);
         extendsConfigs.push(...result.extendsConfigs);
@@ -105,3 +119,6 @@ function getExtendsPointerImportData(configFileExports, configFilePath) {
     }
     return { extendsPointerImportData, extendsConfigs };
 }
+function shouldBeLoadableAtBuildTime(configDef) {
+    return !!configDef.env.config && !configDef._valueIsFilePath;
+}

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

@@ -1,22 +1,12 @@
-export { resolvePointerImportOfConfig };
 export { resolvePointerImport };
-export { clearFilesEnvMap };
-export { resolveConfigEnvWithFileName };
-import type { ConfigEnvInternal, DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
+export { resolvePointerImportData };
+export type { PointerImport };
+import type { DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
 import { type PointerImportData } from './transformPointerImports.js';
 import type { FilePath, FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
-type PointerImportResolved = DefinedAtFilePath & {
-    fileExportName: string;
-};
-declare function resolvePointerImportOfConfig(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | {
-    pointerImport: PointerImportResolved;
-    configEnvResolved: ConfigEnvInternal;
-};
-declare function resolvePointerImport(pointerImportData: PointerImportData, importerFilePath: FilePathResolved, userRootDir: string): FilePath;
-declare function clearFilesEnvMap(): void;
-declare function resolveConfigEnvWithFileName(configEnv: ConfigEnvInternal, filePath: FilePathResolved): {
-    server?: boolean | undefined;
-    config?: boolean | undefined;
-    client?: boolean | "if-client-routing";
-    production?: boolean;
+type PointerImport = {
+    fileExportPath: FileExportPath;
 };
+type FileExportPath = DefinedAtFilePath & Required<Pick<DefinedAtFilePath, 'fileExportName'>>;
+declare function resolvePointerImport(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configName: string): null | PointerImport;
+declare function resolvePointerImportData(pointerImportData: PointerImportData, importerFilePath: FilePathResolved, userRootDir: string): FilePath;

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

@@ -1,34 +1,27 @@
-export { resolvePointerImportOfConfig };
 export { resolvePointerImport };
-export { clearFilesEnvMap };
-export { resolveConfigEnvWithFileName };
+export { resolvePointerImportData };
 import pc from '@brillout/picocolors';
-import { assert, assertPosixPath, assertUsage, deepEqual, isFilePathAbsolute, requireResolve } from '../../../../utils.js';
+import { assert, assertPosixPath, assertUsage, isFilePathAbsolute, pathIsRelative, requireResolve } from '../../../../utils.js';
 import { parsePointerImportData } from './transformPointerImports.js';
 import path from 'path';
 import { getFilePathAbsoluteUserRootDir, getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
-const filesEnvMap = new Map();
-function resolvePointerImportOfConfig(configValue, importerFilePath, userRootDir, configEnv, configName) {
+function resolvePointerImport(configValue, importerFilePath, userRootDir, configName) {
     if (typeof configValue !== 'string')
         return null;
     const pointerImportData = parsePointerImportData(configValue);
     if (!pointerImportData)
         return null;
-    const { importPath, exportName } = pointerImportData;
-    const filePath = resolvePointerImport(pointerImportData, importerFilePath, userRootDir);
+    const { exportName } = pointerImportData;
+    const filePath = resolvePointerImportData(pointerImportData, importerFilePath, userRootDir);
     const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
-    let configEnvResolved = configEnv;
-    if (filePath.filePathAbsoluteFilesystem)
-        configEnvResolved = resolveConfigEnvWithFileName(configEnv, filePath);
-    assertUsageFileEnv(filePath, importPath, configEnvResolved, configName);
-    const pointerImport = {
+    const fileExportPath = {
         ...filePath,
         fileExportName: exportName,
         fileExportPathToShowToUser
     };
-    return { pointerImport, configEnvResolved };
+    return { fileExportPath };
 }
-function resolvePointerImport(pointerImportData, importerFilePath, userRootDir) {
+function resolvePointerImportData(pointerImportData, importerFilePath, userRootDir) {
     // `importPath` should be one of the following:
     // - A relative import path
     // - A filesystem absolute path
@@ -39,7 +32,7 @@ function resolvePointerImport(pointerImportData, importerFilePath, userRootDir)
     assertPosixPath(importPath);
     if (importPath.startsWith('.') || isFilePathAbsolute(importPath)) {
         if (importPath.startsWith('.')) {
-            assertUsage(isRelativeImportPath(importPath), `Invalid relative import path ${pc.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);
+            assertUsage(pathIsRelative(importPath), `Invalid relative import path ${pc.code(importPath)} defined by ${importerFilePath.filePathToShowToUser} because it should start with ${pc.code('./')} or ${pc.code('../')}, or use an npm package import instead.`);
         }
         // Pointer imports are included in virtual files, thus relative imports need to be resolved. (Virtual modules cannot contain relative imports.)
         assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportData, importerFilePath);
@@ -95,7 +88,7 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
             : `The import ${pc.code(importString)} defined by ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
-            assert(isRelativeImportPath(importPath));
+            assert(pathIsRelative(importPath));
             assertUsage(false, `${errIntro2} point to an existing file?`);
         }
         else {
@@ -103,51 +96,3 @@ function assertUsageResolutionSuccess(filePathAbsoluteFilesystem, pointerImportD
         }
     }
 }
-function assertUsageFileEnv(filePath, importPath, configEnvResolved, configName) {
-    let key;
-    if (filePath.filePathAbsoluteFilesystem) {
-        key = filePath.filePathAbsoluteFilesystem;
-    }
-    else {
-        // Path alias
-        assert(!isRelativeImportPath(importPath));
-        key = importPath;
-    }
-    assertPosixPath(key);
-    if (!filesEnvMap.has(key)) {
-        filesEnvMap.set(key, []);
-    }
-    const fileEnv = filesEnvMap.get(key);
-    fileEnv.push({ configEnvResolved, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnvResolved, configEnvResolved))[0];
-    if (configDifferentEnv) {
-        assertUsage(false, [
-            `${key} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnvResolved }].map((c) => `  - config ${pc.code(c.configName)} which value lives in environment ${pc.code(JSON.stringify(c.configEnvResolved))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports'
-        ].join('\n'));
-    }
-}
-function clearFilesEnvMap() {
-    filesEnvMap.clear();
-}
-function resolveConfigEnvWithFileName(configEnv, filePath) {
-    const { fileName } = filePath;
-    const configEnvResolved = { ...configEnv };
-    if (fileName.includes('.server.')) {
-        configEnvResolved.server = true;
-        configEnvResolved.client = false;
-    }
-    else if (fileName.includes('.client.')) {
-        configEnvResolved.client = true;
-        configEnvResolved.server = false;
-    }
-    else if (fileName.includes('.shared.')) {
-        configEnvResolved.server = true;
-        configEnvResolved.client = true;
-    }
-    return configEnvResolved;
-}
-function isRelativeImportPath(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
-}

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

@@ -2,11 +2,15 @@ export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
 export { isTemporaryBuildFile };
+export type { EsbuildCache };
 import 'source-map-support/register.js';
 import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
-declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isConfigFile: boolean | 'is-extension-config'): Promise<{
+type FileExports = {
     fileExports: Record<string, unknown>;
-}>;
+};
+type EsbuildCache = Record<string, // filePathAbsoluteFilesystem
+Promise<FileExports>>;
+declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isConfigFile: boolean | 'is-extension-config', esbuildCache: EsbuildCache): Promise<FileExports>;
 declare function getConfigBuildErrorFormatted(err: unknown): null | string;
 declare function getConfigExecutionErrorIntroMsg(err: unknown): string | null;
 declare function isTemporaryBuildFile(filePath: string): boolean;

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

@@ -7,7 +7,7 @@ import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport } from '../../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertWarning, isObject, toPosixPath, assertUsage, isPlainJavaScriptFile, createDebugger, assertFilePathAbsoluteFilesystem, assertIsNpmPackageImport, genPromise } from '../../../../utils.js';
 import { transformPointerImports } from './transformPointerImports.js';
 import { vikeConfigDependencies } from '../getVikeConfig.js';
 import 'source-map-support/register.js';
@@ -21,25 +21,31 @@ const debug = createDebugger('vike:pointer-imports');
 const debugEsbuildResolve = createDebugger('vike:esbuild-resolve');
 if (debugEsbuildResolve.isActivated)
     debugEsbuildResolve('esbuild version', version);
-async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
+async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile, esbuildCache) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
+    if (esbuildCache[filePathAbsoluteFilesystem]) {
+        return await esbuildCache[filePathAbsoluteFilesystem];
+    }
+    const { promise, resolve } = genPromise();
+    esbuildCache[filePathAbsoluteFilesystem] = promise;
     assertUsage(isPlainJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
         assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
     }
+    let fileExports;
     if (isConfigFile === 'is-extension-config' && !isHeader && fileExtension.endsWith('js')) {
         // This doesn't track dependencies => we should never use this for user land configs
-        const fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
-        return { fileExports };
+        fileExports = await executeFile(filePathAbsoluteFilesystem, filePath);
     }
     else {
         const transformImports = isConfigFile && (isHeader ? 'all' : true);
         const code = await transpileFile(filePath, transformImports, userRootDir);
-        const fileExports = await executeTranspiledFile(filePath, code);
-        return { fileExports };
+        fileExports = await executeTranspiledFile(filePath, code);
     }
+    resolve({ fileExports });
+    return { fileExports };
 }
 async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;

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

@@ -2,43 +2,18 @@ export { getVikeConfig };
 export { getVikeConfig2 };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
-export { isVikeConfigFile };
 export { isV1Design };
-export { getConfigValueInterfaceFile };
+export { getConfVal };
+export { getConfigDefinitionOptional };
 export type { VikeConfigObject };
-export type { InterfaceValueFile };
-export type { InterfaceFile };
-export type { VikeConfigGlobal };
-export type { VikeVitePluginOptions };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
-import { type LocationId } from './getVikeConfig/filesystemRouting.js';
+import { type ConfigDefinitions, type ConfigDefinitionInternal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import type { ResolvedConfig } from 'vite';
-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;
-    fileExportsByConfigName: Record<ConfigName, {
-        configValue?: unknown;
-    }>;
-};
-type InterfaceConfigFile = InterfaceFileCommons & {
-    isConfigFile: true;
-    isValueFile: false;
-    extendsFilePaths: string[];
-    isConfigExtend: boolean;
-};
-type InterfaceValueFile = InterfaceFileCommons & {
-    isConfigFile: false;
-    isValueFile: true;
-    configName: string;
-};
-type ConfigName = string;
+import { type PlusFile } from './getVikeConfig/getPlusFilesAll.js';
 type VikeConfigObject = {
     pageConfigs: PageConfigBuildTime[];
     pageConfigGlobal: PageConfigGlobalBuildTime;
-    vikeConfigGlobal: VikeConfigGlobal;
     global: ReturnType<typeof getPageConfigUserFriendlyNew>;
 };
 declare const vikeConfigDependencies: Set<string>;
@@ -48,97 +23,10 @@ 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 getConfigValueInterfaceFile(interfaceFile: InterfaceFile, configName: string): unknown;
-type VikeConfigGlobal = {
-    prerender: false | {
-        noExtraDir: boolean;
-        parallel: boolean | number;
-        partial: boolean;
-        disableAutoRun: boolean;
-    };
-    disableAutoFullBuild: boolean | 'prerender' | null;
-    includeAssetsImportedByServer: boolean;
-    baseAssets: string | null;
-    baseServer: string | null;
-    trailingSlash: boolean;
-    disableUrlNormalization: boolean;
-};
-type VikeVitePluginOptions = {
-    /**
-     * Enable pre-rendering.
-     *
-     * https://vike.dev/pre-rendering
-     *
-     * @default false
-     */
-    prerender?: boolean | {
-        /**
-         * Don't create a new directory for each HTML file.
-         *
-         * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
-         *
-         * @default false
-         */
-        noExtraDir?: boolean;
-        /**
-         * Number of concurrent pre-render jobs.
-         *
-         * Set to `false` to disable concurrency.
-         *
-         * @default os.cpus().length
-         */
-        parallel?: boolean | number;
-        /**
-     * Allow only some of your pages to be pre-rendered.
-     *
-     * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
- 
-     * @default false
-     */
-        partial?: boolean;
-        /**
-         * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.
-         *
-         * Use this if you want to programmatically initiate the pre-rendering process instead.
-         *
-         * https://vike.dev/api#prerender
-         *
-         * @default false
-         */
-        disableAutoRun?: boolean;
-    };
-    /** @deprecated See https://vike.dev/disableAutoFullBuild */
-    disableAutoFullBuild?: boolean | 'prerender';
-    /** The Base URL of your server.
-     *
-     * https://vike.dev/base-url
-     */
-    baseServer?: string;
-    /** The Base URL of your static assets.
-     *
-     * https://vike.dev/base-url
-     */
-    baseAssets?: string;
-    /** @deprecated It's now `true` by default. You can remove this option. */
-    includeAssetsImportedByServer?: boolean;
-    /** Permanent redirections (HTTP status code 301)
-     *
-     * https://vike.dev/redirects
-     */
-    redirects?: Record<string, string>;
-    /** Whether URLs should end with a trailing slash.
-     *
-     * https://vike.dev/url-normalization
-     *
-     * @default false
-     */
-    trailingSlash?: boolean;
-    /** Disable automatic URL normalization.
-     *
-     * https://vike.dev/url-normalization
-     *
-     * @default false
-     */
-    disableUrlNormalization?: boolean;
+declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitions, configName: string): ConfigDefinitionInternal | null;
+declare function getConfVal(plusFile: PlusFile, configName: string): null | {
+    configValue: unknown;
+    configValueLoaded: true;
+} | {
+    configValueLoaded: false;
 };