vike 0.4.247-commit-903de25 → 0.4.247-commit-c3d567b

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;

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -0,0 +1,281 @@
+export { configDefinitionsBuiltIn };
+import { assert, assertUsage } from '../../utils.js';
+import { getConfigDefinedAt, } from '../../../../shared-server-client/page-configs/getConfigDefinedAt.js';
+import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+const configDefinitionsBuiltIn = {
+    onRenderHtml: {
+        env: { server: true },
+    },
+    onRenderClient: {
+        env: { client: true },
+    },
+    onHydrationEnd: {
+        env: { client: true },
+    },
+    onPageTransitionStart: {
+        env: { client: true },
+    },
+    onPageTransitionEnd: {
+        env: { client: true },
+    },
+    onCreatePageContext: {
+        env: { server: true, client: true },
+        cumulative: true,
+    },
+    onCreateGlobalContext: {
+        env: { server: true, client: true },
+        global: true,
+        cumulative: true,
+    },
+    onError: {
+        env: { server: true },
+        global: true,
+        cumulative: true,
+    },
+    onBeforeRender: {
+        env: { server: true },
+    },
+    onBeforePrerenderStart: {
+        env: { server: true, production: true },
+    },
+    Page: {
+        env: { server: true, client: true },
+    },
+    passToClient: {
+        env: { server: true },
+        cumulative: true,
+    },
+    route: {
+        env: {
+            server: true,
+            client: 'if-client-routing',
+            // For vite-plugin-vercel
+            config: true,
+        },
+        eager: true,
+    },
+    guard: {
+        env: { server: true, client: 'if-client-routing' },
+    },
+    data: {
+        env: { server: true },
+    },
+    onData: {
+        env: { server: true, client: true },
+        cumulative: true,
+    },
+    iKnowThePerformanceRisksOfAsyncRouteFunctions: {
+        env: { server: true, client: 'if-client-routing' },
+        eager: true,
+    },
+    filesystemRoutingRoot: {
+        env: { config: true },
+    },
+    client: {
+        // The value of the client config is merely the file path to the client entry file, which is only needed on the sever-side
+        env: { server: true, config: true },
+        _valueIsFilePath: true,
+    },
+    clientRouting: {
+        // We could make it { client: false } but we don't yet because of some legacy V0.4 design code
+        env: { server: true, client: true, config: true },
+        eager: true,
+    },
+    clientHooks: {
+        env: { config: true },
+    },
+    hydrationCanBeAborted: {
+        env: { client: true },
+    },
+    prefetch: {
+        env: { client: true },
+        eager: true,
+    },
+    // TO-DO/next-major-release: remove
+    prefetchStaticAssets: {
+        env: { client: true },
+    },
+    extends: {
+        env: { config: true },
+    },
+    meta: {
+        env: { config: true },
+    },
+    hasServerOnlyHook: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            const sources = ['data', 'onBeforeRender', 'onCreatePageContext', 'guard']
+                .map((hookName) => getConfigValueSourcesRelevant(hookName, {
+                isForClientSide: false,
+                // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                isClientRouting: true,
+            }, pageConfig))
+                .flat(1)
+                // Server-only
+                .filter((source) => !source.configEnv.client)
+                // Config value isn't `null`
+                .filter((source) => !isConfigSourceValueNull(source));
+            return sources.length > 0;
+        },
+    },
+    // Whether the page loads:
+    //  - Vike's client runtime
+    //  - User's client hooks
+    // In other words, whether the page is "HTML-only" (https://vike.dev/render-modes). HTML-only pages shouldn't load the client runtime nor client hooks.
+    isClientRuntimeLoaded: {
+        env: { server: true, client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            {
+                const source = getConfigValueSourceRelevantAnyEnv('clientHooks', pageConfig);
+                if (source) {
+                    assert(source.valueIsLoaded);
+                    const { value, definedAt } = source;
+                    const configDefinedAt = getConfigDefinedAt('Config', 'clientHooks', definedAt);
+                    assertUsage(typeof value === 'boolean', `${configDefinedAt} should be a boolean`);
+                    return value;
+                }
+            }
+            return (isConfigSet(pageConfig, 'onRenderClient') &&
+                isConfigSet(pageConfig, 'Page') &&
+                !!getConfigEnv(pageConfig, 'Page')?.client);
+        },
+    },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks comments)
+    onBeforeRenderEnv: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            return !isConfigSet(pageConfig, 'onBeforeRender') ? null : getConfigEnv(pageConfig, 'onBeforeRender');
+        },
+    },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks comments)
+    dataEnv: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            return !isConfigSet(pageConfig, 'data') ? null : getConfigEnv(pageConfig, 'data');
+        },
+    },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks comments)
+    guardEnv: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            return !isConfigSet(pageConfig, 'guard') ? null : getConfigEnv(pageConfig, 'guard');
+        },
+    },
+    hooksTimeout: {
+        env: { server: true, client: true },
+    },
+    cacheControl: {
+        env: { server: true },
+    },
+    host: {
+        env: { config: true },
+        global: true,
+    },
+    port: {
+        env: { config: true },
+        global: true,
+    },
+    mode: {
+        env: { config: true },
+        global: true,
+    },
+    force: {
+        env: { config: true },
+        global: true,
+    },
+    csp: {
+        env: { server: true },
+    },
+    injectScriptsAt: {
+        env: { server: true },
+    },
+    name: {
+        env: { config: true },
+    },
+    require: {
+        env: { config: true },
+    },
+    keepScrollPosition: {
+        env: { client: true },
+    },
+    middleware: { env: { server: true }, cumulative: true, eager: true, global: true },
+    cli: {
+        env: { config: true },
+        global: true,
+    },
+    onPrerenderStart: {
+        env: { server: true, production: true },
+        eager: true,
+        global: true,
+    },
+    onBeforeRoute: {
+        env: { server: true, client: 'if-client-routing' },
+        eager: true,
+        global: true,
+    },
+    prerender: {
+        env: { config: true },
+        global: (value, { isGlobalLocation }) => typeof value === 'object' || isGlobalLocation,
+        cumulative: true,
+    },
+    vite: { env: { config: true }, global: true, cumulative: true },
+    disableAutoFullBuild: {
+        env: { config: true },
+        global: true,
+    },
+    // This is deprecated (since Summer 2025). But don't remove this (yet) — otherwise it will break older Vike extensions that still use it.
+    vite6BuilderApp: {
+        env: { config: true },
+        global: true,
+    },
+    includeAssetsImportedByServer: {
+        env: { config: true },
+        global: true,
+    },
+    baseAssets: {
+        env: { config: true, server: true },
+        global: true,
+    },
+    baseServer: {
+        env: { config: true, server: true },
+        global: true,
+    },
+    redirects: {
+        env: { server: true },
+        global: true,
+        cumulative: true,
+    },
+    trailingSlash: {
+        env: { server: true },
+        global: true,
+    },
+    disableUrlNormalization: {
+        env: { server: true },
+        global: true,
+    },
+    headersResponse: {
+        env: { server: true },
+        cumulative: true,
+    },
+};
+function getConfigEnv(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    if (!source)
+        return null;
+    const { configEnv } = source;
+    const env = {};
+    if (configEnv.client)
+        env.client = true;
+    if (configEnv.server)
+        env.server = true;
+    return env;
+}
+function isConfigSet(pageConfig, configName) {
+    const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);
+    return !!source;
+}