vike 0.4.247 → 0.4.248

package/dist/node/vite/shared/loggerDev/errorWithCodeSnippet.js

@@ -0,0 +1,155 @@
+// Prettify transpilation errors
+//  - Doesn't work for optimize errors: https://gist.github.com/brillout/9b7bb78ae866558b292ea1b516a986ec
+export { getPrettyErrorWithCodeSnippet };
+export { isErrorWithCodeSnippet };
+export { isEquivalentErrorWithCodeSnippet };
+// For ./errorWithCodeSnippet.spec.ts
+export { getPrettyErrMessage };
+// Copied & adapted from https://github.com/vitejs/vite/blob/9c114c5c72a6af87e3330d5573362554b4511265/packages/vite/src/node/server/middlewares/error.ts
+import pc from '@brillout/picocolors';
+import { assert, escapeRegex, isObject, removeEmptyLines, stripAnsi } from '../../utils.js';
+import { cleanFilePathUnknown, getFilePathToShowToUserUnknown } from '../getFilePath.js';
+function isErrorWithCodeSnippet(err) {
+    if (!isObject(err)) {
+        return false;
+    }
+    const { id, frame, message } = err;
+    if (typeof id !== 'string' || !id.trim()) {
+        return false;
+    }
+    if (typeof frame === 'string' && frame.trim()) {
+        return true;
+    }
+    if (typeof message === 'string' && containsCodeSnippet(message)) {
+        return true;
+    }
+    return false;
+}
+function getPrettyErrorWithCodeSnippet(err, userRootDir) {
+    /* Uncomment to inspect and/or create fixture for ./errorWithCodeSnippet.spec.ts
+    console.log('userRootDir', userRootDir)
+    console.log('err.message', err.message)
+    console.log('err.stack', (err as any).stack)
+    console.log('err.pluginCode', (err as any).pluginCode)
+    console.log('Object.keys(err)', Object.keys(err))
+    console.log('err', err)
+    // For copy-pasting errors while preserving terminal ANSI colors
+    console.log(
+      'JSON.stringify(err)',
+      JSON.stringify({
+        ...err,
+        message: err.message,
+        stack: (err as any).stack
+      })
+    )
+    //*/
+    assert(isErrorWithCodeSnippet(err));
+    let { id, frame } = err;
+    const msgFirstLine = `${pc.red('Failed to transpile')} ${pc.bold(pc.red(getFilePathToShowToUserUnknown(id, userRootDir)))} ${pc.red('because:')}`;
+    const errMsg = getPrettyErrMessage(err);
+    if (errMsg && containsCodeSnippet(errMsg)) {
+        // Conditionally swallowing frame is a risky move but worth it thanks to logErrorDebugNote()
+        // We swallow frame because many tools set 'error.frame' to something rubbish, for example:
+        //  - @vitejs/plugin-vue
+        //  - @vitejs/plugin-react-swc
+        //  - @mdx-js/rollup
+        frame = undefined;
+    }
+    else {
+        assert(frame);
+        frame = frame.trim();
+        assert(frame);
+        frame = pc.yellow(frame);
+    }
+    let errMsgCodeSnippet = [errMsg, frame].filter(Boolean).join('\n');
+    errMsgCodeSnippet = removeEmptyLines(errMsgCodeSnippet);
+    const errMsgFormatted = `${msgFirstLine}\n${errMsgCodeSnippet}`;
+    /* Vite already does a fairly good job at showing a concise error in the layover
+    server.ws.send({
+      type: 'error',
+      err: msg
+    })
+    */
+    return errMsgFormatted;
+}
+function getPrettyErrMessage(err) {
+    const { id, frame } = err;
+    let errMsg = err.message;
+    if (!errMsg || !errMsg.trim())
+        return null;
+    const trail = /(?:\:|)(?:\s|$)/;
+    // Remove "Transform failed with 1 error:" (redundant since we already print an intro message)
+    errMsg = errMsg.split(reg([/Transform failed with \d* error(?:s|)/, trail], 'gi')).join('');
+    // Remove "/home/rom/code/vike/examples/react-full/components/Counter.tsx:1:8:" (redundant since we already print the filename)
+    const pos = /(?:\:\d+|)/;
+    errMsg = errMsg.split(reg([id, pos, pos, trail], 'gi')).join('');
+    errMsg = errMsg.split(reg([cleanFilePathUnknown(id), pos, pos, trail], 'gi')).join('');
+    // Remove "ERROR:" (useless)
+    errMsg = errMsg.split(reg(['ERROR:', trail])).join('');
+    // Remove "Internal server error:" (useless)
+    errMsg = errMsg.split(reg(['Internal server error', trail])).join('');
+    if (containsCodeSnippet(errMsg)) {
+        errMsg = removeStandaloneCodePosition(errMsg);
+    }
+    errMsg = errMsg.trim();
+    if (frame && frame.includes(errMsg))
+        errMsg = '';
+    return errMsg;
+}
+function containsCodeSnippet(str) {
+    str = stripAnsi(str);
+    let codeBlockSize = 0;
+    for (const line of str.split('\n')) {
+        if (!isCodeSnippetLine(line)) {
+            codeBlockSize = 0;
+        }
+        else {
+            codeBlockSize++;
+        }
+        if (codeBlockSize >= 3) {
+            return true;
+        }
+    }
+    return false;
+}
+function isCodeSnippetLine(line) {
+    // Babel
+    if (/[\s\d>]*\|/.test(line))
+        return true;
+    // SWC
+    if (/[\s\d>]*(╭─|│|·)/.test(line))
+        return true;
+    return false;
+}
+function reg(parts, flags = '') {
+    return new RegExp(parts.map((part) => (typeof part === 'string' ? escapeRegex(part) : part.source)).join(''), flags);
+}
+function removeStandaloneCodePosition(errMsg) {
+    // Remove weird standalone code position " (2:7) "
+    errMsg = errMsg
+        .split('\n')
+        .map((line) => {
+        const posRE = /(\s|^)\(\d+:\d+\)(\s|$)/;
+        assert(posRE.test(' (1:2)'));
+        assert(posRE.test('(13:42) '));
+        if (!isCodeSnippetLine(line)) {
+            line = line.split(posRE).join('');
+        }
+        return line;
+    })
+        .join('\n');
+    return errMsg;
+}
+function isEquivalentErrorWithCodeSnippet(err1, err2) {
+    if (!isObject(err1) || !isObject(err2))
+        return false;
+    if (isDefinedAndSame(err1.message, err2.message) &&
+        isDefinedAndSame(err1.frame, err2.frame) &&
+        isDefinedAndSame(err1.id, err2.id)) {
+        return true;
+    }
+    return false;
+}
+function isDefinedAndSame(val1, val2) {
+    return val1 && val1 === val2;
+}

package/dist/node/vite/shared/loggerDev.d.ts

@@ -0,0 +1,9 @@
+export { logVite };
+export { logConfigInfo };
+export { logErrorServerDev };
+export type { LogType };
+import { type PageContext_logRuntime } from '../../../server/runtime/loggerRuntime.js';
+type LogType = 'info' | 'warn' | 'error' | 'error-resolve';
+declare function logConfigInfo(msg: string, logType: LogType): void;
+declare function logVite(msg: string, logType: LogType, requestId: number | null, prependViteTag: boolean): void;
+declare function logErrorServerDev(err: unknown, pageContext: PageContext_logRuntime, errorComesFromVite?: boolean): void;

package/dist/node/vite/shared/loggerDev.js

@@ -0,0 +1,179 @@
+// TO-DO/eventually:
+// - New hook onLog(): https://github.com/vikejs/vike/issues/1438
+// - Exact same logs between prod and dev, only difference is that some log objects have:
+//   - `isDevLog: true`
+//   - `willBeLogged: false` in production
+//   - `showTimestamp: true`
+// - Never clear screen (it's complex with little benefit)
+// - Only show a one-liner init log (instead of Vite's multi-line log)
+export { logVite };
+export { logConfigInfo };
+export { logErrorServerDev };
+import { isAbortError } from '../../../shared-server-client/route/abort.js';
+import { getViteConfig } from '../../../server/runtime/globalContext.js';
+import { assertPageContext_logRuntime, setLogRuntimeDev, } from '../../../server/runtime/loggerRuntime.js';
+import { addOnBeforeAssertErr, assert, assertIsNotProductionRuntime, colorVike, colorVite, formatHintLog, hasGreen, hasProp, hasRed, hasYellow, isDebugError, stripAnsi, } from '../utils.js';
+import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerDev/errorWithCodeSnippet.js';
+import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted, } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
+import pc from '@brillout/picocolors';
+import { isUserHookError } from '../../../shared-server-client/hooks/execHook.js';
+import { getViteDevServer } from '../../../server/runtime/globalContext.js';
+import { logErrorServer } from '../../../server/runtime/logErrorServer.js';
+import { getBetterError } from '../../../utils/getBetterError.js';
+import { getHttpRequestId_withAsyncHook } from '../../../server/runtime/asyncHook.js';
+assertIsNotProductionRuntime();
+setLogRuntimeDev(logErrorServerDev, logRuntimeInfoDev);
+addOnBeforeAssertErr((err) => {
+    // We must directly apply vite.ssrFixStacktrace() to `assertWarning(..., { showStackTrace: true })` because warnings aren't caught by the try-catch of renderPageServer()
+    applyViteSourceMapToStackTrace(err);
+});
+// Note shown to user when Vike completely modifies the error message (which is somewhat risky)
+const errorDebugNote = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
+function logRuntimeInfoDev(msg, pageContext, logType) {
+    assertPageContext_logRuntime(pageContext);
+    const tagSource = getTagSource(pageContext?._requestId);
+    logDev(msg, logType, tagSource, '[vike]');
+}
+function logConfigInfo(msg, logType) {
+    const tagSource = getTagSource() ?? 'config';
+    logDev(msg, logType, tagSource, '[vike]');
+}
+function logVite(msg, logType, requestId, prependViteTag) {
+    const tagSource = getTagSource(requestId);
+    logDev(msg, logType, tagSource, '[vite]', !prependViteTag);
+}
+function logErrorServerDev(err, pageContext, errorComesFromVite = false) {
+    assertPageContext_logRuntime(pageContext);
+    applyViteSourceMapToStackTrace(err);
+    // Skip `throw render()` / `throw redirect()`
+    if (isAbortError(err) && !isDebugError()) {
+        return;
+    }
+    const tagSource = getTagSource(pageContext?._requestId);
+    const logErr = (err) => {
+        logErrorServer(err, pageContext);
+    };
+    if (isErrorWithCodeSnippet(err)) {
+        // We handle transpile errors globally because wrapping viteDevServer.ssrLoadModule() wouldn't be enough: transpile errors can be thrown not only when calling viteDevServer.ssrLoadModule() but also later when loading user code with import() (since Vite lazy-transpiles import() calls)
+        const viteConfig = getViteConfig();
+        assert(viteConfig);
+        const errMsgFormatted = getPrettyErrorWithCodeSnippet(err, viteConfig.root);
+        assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
+        const message = `${getTags(errMsgFormatted, '[vite]', tagSource, 'error')}${errMsgFormatted}\n${errorDebugNote}`;
+        const errBetter = getBetterError(err, { message, hideStack: true });
+        logErr(errBetter);
+        return;
+    }
+    {
+        const errMsgFormatted = getConfigBuildErrorFormatted(err);
+        if (errMsgFormatted) {
+            assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
+            const message = `${getTagsError(errMsgFormatted, tagSource)}${errMsgFormatted}\n${errorDebugNote}`;
+            const errBetter = getBetterError(err, { message, hideStack: true });
+            logErr(errBetter);
+            return;
+        }
+    }
+    {
+        const errIntro = getConfigExecutionErrorIntroMsg(err);
+        if (errIntro) {
+            assert(stripAnsi(errIntro).startsWith('Failed to execute'));
+            const prepend = `${getTagsError(errIntro, tagSource)}${errIntro}\n`;
+            const errBetter = getBetterError(err, { message: { prepend } });
+            logErr(errBetter);
+            return;
+        }
+    }
+    {
+        const hook = isUserHookError(err);
+        if (hook) {
+            const { hookName, hookFilePath } = hook;
+            const errIntro = pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`);
+            const prepend = `${getTagsError(errIntro, tagSource)}${errIntro}\n`;
+            const errBetter = getBetterError(err, { message: { prepend } });
+            logErr(errBetter);
+            return;
+        }
+    }
+    if (tagSource) {
+        const errIntro = pc.bold(pc.red(`[Error] ${errorComesFromVite ? 'Transpilation error' : 'An error was thrown'}:`));
+        const prepend = `${getTagsError(errIntro, tagSource)}${errIntro}\n`;
+        const errBetter = getBetterError(err, { message: { prepend } });
+        logErr(errBetter);
+        return;
+    }
+    logErr(err);
+}
+function logDev(msg, logType, tagSource, tagTool, doNotAddTags) {
+    if (!doNotAddTags) {
+        msg = getTags(msg, tagTool, tagSource, logType) + msg;
+    }
+    if (logType === 'info') {
+        console.log(msg);
+        return;
+    }
+    if (logType === 'warn') {
+        console.warn(msg);
+        return;
+    }
+    if (logType === 'error') {
+        console.error(msg);
+        return;
+    }
+    if (logType === 'error-resolve') {
+        // stderr because user will most likely want to know about error recovering
+        console.error(msg);
+        return;
+    }
+    assert(false);
+}
+function getTagSource(requestId = null) {
+    const requestIdFromStore = getHttpRequestId_withAsyncHook();
+    if (requestIdFromStore !== null) {
+        if (requestId === null) {
+            requestId = requestIdFromStore;
+        }
+        else {
+            assert(requestId === requestIdFromStore);
+        }
+    }
+    if (requestId === null)
+        return null;
+    // const tagSource = requestId % 2 === 1 ? (`request-${requestId}` as const) : (`request(${requestId})` as const)
+    const tagSource = `request-${requestId}`;
+    return tagSource;
+}
+function applyViteSourceMapToStackTrace(thing) {
+    if (isDebugError())
+        return;
+    if (!hasProp(thing, 'stack'))
+        return;
+    const viteDevServer = getViteDevServer();
+    if (!viteDevServer)
+        return;
+    // Apply Vite's source maps
+    viteDevServer.ssrFixStacktrace(thing);
+}
+function getTagsError(msg, tagSource) {
+    return getTags(msg, '[vike]', tagSource, 'error');
+}
+function getTags(msg, tagTool, tagSource, logType) {
+    const tagToolColored = (() => {
+        if (logType === 'error' && !hasRed(msg))
+            return pc.bold(pc.red(tagTool));
+        if (logType === 'error-resolve' && !hasGreen(msg))
+            return pc.bold(pc.green(tagTool));
+        if (logType === 'warn' && !hasYellow(msg))
+            return pc.yellow(tagTool);
+        if (tagTool === '[vite]')
+            return colorVite(tagTool);
+        if (tagTool === '[vike]')
+            return colorVike(tagTool);
+        assert(false);
+    })();
+    const timestamp = pc.dim(new Date().toLocaleTimeString());
+    const whitespace = (/\s|\[/.test(stripAnsi(msg)[0]) ? '' : ' ');
+    const tagSourceStr = (!tagSource ? '' : pc.dim(`[${tagSource}]`));
+    const tags = `${timestamp} ${tagToolColored}${tagSourceStr}${whitespace}`;
+    return tags;
+}

package/dist/node/vite/shared/loggerVite.d.ts

@@ -0,0 +1,16 @@
+export { interceptViteLogs };
+export { processStartupLog };
+export { swallowViteLogForceOptimization_enable };
+export { swallowViteLogForceOptimization_disable };
+export { swallowViteLogConnected };
+export { swallowViteLogConnected_clean };
+import type { ResolvedConfig } from 'vite';
+declare function interceptViteLogs(config: ResolvedConfig): void;
+declare function processStartupLog(firstLine: string, config: ResolvedConfig): {
+    firstLine: string;
+    isCompact: boolean;
+};
+declare function swallowViteLogForceOptimization_enable(): void;
+declare function swallowViteLogForceOptimization_disable(): void;
+declare function swallowViteLogConnected(): void;
+declare function swallowViteLogConnected_clean(): void;

package/dist/node/vite/shared/loggerVite.js

@@ -0,0 +1,149 @@
+export { interceptViteLogs };
+export { processStartupLog };
+export { swallowViteLogForceOptimization_enable };
+export { swallowViteLogForceOptimization_disable };
+export { swallowViteLogConnected };
+export { swallowViteLogConnected_clean };
+import { assert, getGlobalObject, isDebugError, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly, } from '../utils.js';
+import { getHttpRequestId_withAsyncHook } from '../../../server/runtime/asyncHook.js';
+import { logErrorServerDev, logVite } from './loggerDev.js';
+const globalObject = getGlobalObject('vite/shared/loggerDev.ts', {
+    processStartupLog_isCompact: null,
+    processStartupLog_hasViteLoggedStartup: null,
+    processStartupLog_hasViteLoggedHelpShortcut: null,
+    swallowViteLogForceOptimization_enabled: false,
+    swallowViteLogConnected_originalConsoleLog: null,
+});
+function interceptViteLogs(config) {
+    if (isDebugError())
+        return;
+    intercept('info', config);
+    intercept('warn', config);
+    intercept('error', config);
+}
+function intercept(loggerType, config) {
+    let isBeginning = true;
+    setTimeout(() => (isBeginning = false), 10 * 1000);
+    config.logger[loggerType] = (msg, options = {}) => {
+        assert(!isDebugError());
+        if (swallowViteLogForceOptimization(msg))
+            return;
+        if (!!options.timestamp) {
+            msg = trimWithAnsi(msg);
+        }
+        else {
+            // No timestamp => no "[vite]" tag prepended => we don't trim the beginning of the message
+            msg = trimWithAnsiTrailOnly(msg);
+        }
+        if (isBeginning) {
+            msg = processStartupLog_onViteLog(msg, config);
+        }
+        if (options.error) {
+            // Vite does a poor job of handling errors.
+            //  - It doesn't format error code snippets.
+            //  - It only shows error.message which means that crucial information such as error.id isn't shown to the user.
+            logErrorServerDev(options.error, null, true);
+            // We swallow Vite's message: we didn't see it add any value so far.
+            //  - It can even be confusing, such as the following:
+            //    ```
+            //    Error when evaluating SSR module virtual:vike:page-entry:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
+            //    ```
+            assert(!isDebugError());
+            return;
+        }
+        const requestId = getHttpRequestId_withAsyncHook();
+        // Vite's default logger preprends the "[vite]" tag if and only if options.timestamp is true
+        const prependViteTag = options.timestamp || typeof requestId === 'number';
+        // If it's an actual error => options.error is set => it's handled with logErrorServerDev() above
+        logVite(msg, loggerType, requestId, prependViteTag);
+    };
+}
+// - Clears screen if zero previous log
+// - Manages new lines
+function processStartupLog(firstLine, config) {
+    const shouldClear = processStartupLog_shouldClear(config);
+    if (shouldClear) {
+        config.logger.clearScreen('info');
+    }
+    else {
+        // Remove leading new line (for both Vite and Vike's startup log)
+        firstLine = removeEmptyLines(firstLine);
+    }
+    return { firstLine, isCompact: !shouldClear };
+}
+function processStartupLog_shouldClear(config) {
+    const hasLoggedBefore = process.stdout.bytesWritten !== 0 || process.stderr.bytesWritten !== 0;
+    const notDisabled = config.clearScreen !== false;
+    const shouldClear = notDisabled && !hasLoggedBefore;
+    return shouldClear;
+}
+function processStartupLog_onViteLog(msg, config) {
+    {
+        const isFirstVitLog = msg.includes('VITE') && msg.includes('ready');
+        if (isFirstVitLog && !globalObject.processStartupLog_hasViteLoggedStartup) {
+            globalObject.processStartupLog_hasViteLoggedStartup = true;
+            let { firstLine, isCompact } = processStartupLog(msg, config);
+            globalObject.processStartupLog_isCompact = isCompact;
+            if (!isCompact)
+                firstLine += '\n';
+            return firstLine;
+        }
+    }
+    {
+        const isViteHelpShortcutLog = msg.includes('press') && msg.includes('to show help');
+        if (isViteHelpShortcutLog && !globalObject.processStartupLog_hasViteLoggedHelpShortcut) {
+            globalObject.processStartupLog_hasViteLoggedHelpShortcut = true;
+            if (globalObject.processStartupLog_hasViteLoggedStartup && globalObject.processStartupLog_isCompact === false) {
+                return msg + '\n';
+            }
+        }
+    }
+    return msg;
+}
+function swallowViteLogForceOptimization(msg) {
+    if (!globalObject.swallowViteLogForceOptimization_enabled) {
+        return false;
+    }
+    if (msg.toLowerCase().includes('forced') && msg.toLowerCase().includes('optimization')) {
+        assert(msg === 'Forced re-optimization of dependencies', msg); // assertion fails => Vite changed its message => update this function
+        return true;
+    }
+    return false;
+}
+function swallowViteLogForceOptimization_enable() {
+    if (isDebugError())
+        return;
+    globalObject.swallowViteLogForceOptimization_enabled = true;
+}
+function swallowViteLogForceOptimization_disable() {
+    globalObject.swallowViteLogForceOptimization_enabled = false;
+}
+// Suppress "[vite] connected." message. (It doesn't go through Vite's logger thus we must monkey patch the console.log() function.)
+function swallowViteLogConnected() {
+    if (isDebugError())
+        return;
+    if (globalObject.swallowViteLogConnected_originalConsoleLog)
+        return;
+    globalObject.swallowViteLogConnected_originalConsoleLog = console.log;
+    console.log = swallowViteLogConnected_logPatch;
+    setTimeout(swallowViteLogConnected_clean, 3000);
+}
+// Remove console.log() monkey patch
+function swallowViteLogConnected_clean() {
+    // Don't remove console.log() patches from other libraries (e.g. instrumentation)
+    if (console.log === swallowViteLogConnected_logPatch)
+        return;
+    assert(globalObject.swallowViteLogConnected_originalConsoleLog);
+    console.log = globalObject.swallowViteLogConnected_originalConsoleLog;
+    globalObject.swallowViteLogConnected_originalConsoleLog = null;
+}
+function swallowViteLogConnected_logPatch(...args) {
+    const originalConsoleLog = globalObject.swallowViteLogConnected_originalConsoleLog;
+    assert(originalConsoleLog);
+    const msg = args.join(' ');
+    if (msg === '[vite] connected.') {
+        swallowViteLogConnected_clean();
+        return; // swallow
+    }
+    originalConsoleLog.apply(console, args);
+}

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.d.ts

@@ -0,0 +1,89 @@
+export { configDefinitionsBuiltIn };
+export type { ConfigDefinition };
+export type { ConfigDefinitions };
+export type { ConfigDefinitionsInternal };
+export type { ConfigDefinitionInternal };
+export type { ConfigEffect };
+import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath } from '../../../../types/PageConfig.js';
+import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../types/Config.js';
+import { type ConfigDefinedAt } from '../../../../shared-server-client/page-configs/getConfigDefinedAt.js';
+import type { PageConfigBuildTimeBeforeComputed } from '../resolveVikeConfigInternal.js';
+/** The meta definition of a config.
+ *
+ * https://vike.dev/meta
+ */
+type ConfigDefinition = ConfigDefinition_ | ConfigDefinitionDefinedByPeerDependency;
+type ConfigDefinition_ = {
+    /** In what environment(s) the config value is loaded.
+     *
+     * https://vike.dev/meta
+     */
+    env: ConfigEnv;
+    /** Disable config overriding and make config values cumulative instead.
+     *
+     * @default false
+     *
+     * https://vike.dev/meta
+     */
+    cumulative?: boolean;
+    /**
+     * Function called when the config value is defined.
+     *
+     * https://vike.dev/meta
+     */
+    effect?: ConfigEffect;
+    /**
+     * Always load the configuration value, and as soon as possible.
+     *
+     * @default false
+     *
+     * https://vike.dev/meta
+     */
+    eager?: boolean;
+    /**
+     * Whether the configuration always applies to all pages (no config inheritance).
+     *
+     * @default false
+     *
+     * https://vike.dev/extends#inheritance
+     */
+    global?: boolean | ((value: unknown, moreInfo: {
+        isGlobalLocation: boolean;
+    }) => boolean);
+};
+type ConfigDefinitionDefinedByPeerDependency = {
+    /**
+     * Omit the "unknown config" error without defining the config — useful for optional peer dependencies: for example, vike-server sets +stream.require which is defined by vike-{react,vue,solid} but some users don't use vike-{react,vue,solid}
+     */
+    isDefinedByPeerDependency: true;
+};
+/**
+ * Function called when the config value is defined.
+ *
+ * https://vike.dev/meta
+ */
+type ConfigEffect = (config: {
+    /** The config value.
+     *
+     * https://vike.dev/meta
+     */
+    configValue: unknown;
+    /** Where the config value is defined.
+     *
+     * https://vike.dev/meta
+     */
+    configDefinedAt: ConfigDefinedAt;
+}) => Config | undefined;
+/** For Vike internal use */
+type ConfigDefinitionInternal = Omit<ConfigDefinition_, 'env'> & {
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
+    _valueIsFilePath?: true;
+    _userEffectDefinedAtFilePath?: DefinedAtFilePath;
+    env: ConfigEnvInternal;
+};
+type ConfigDefinitions = Record<string, // configName
+ConfigDefinition>;
+type ConfigDefinitionsInternal = Record<string, // configName
+ConfigDefinitionInternal>;
+type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn | ConfigNameGlobal, ConfigDefinitionInternal>;
+declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;