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

package/dist/node/vite/plugins/pluginCommon.js

@@ -0,0 +1,187 @@
+export { pluginCommon };
+export let viteVersionUser = null;
+import { assert, assertUsage, assertWarning, hasProp, isDevCheck, isDocker, isExactlyOneTruthy, isObject, isVitest, } from '../utils.js';
+import { assertRollupInput } from './build/pluginBuildConfig.js';
+import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
+import pc from '@brillout/picocolors';
+import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
+import { isViteCli } from '../shared/isViteCli.js';
+import { isVikeCliOrApi } from '../../../shared-server-node/api-context.js';
+import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigFromUser.js';
+import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
+const pluginName = 'vike:pluginCommon';
+globalThis.__VIKE__IS_PROCESS_SHARED_WITH_VITE = true;
+function pluginCommon(vikeVitePluginOptions) {
+    return [
+        {
+            name: `${pluginName}:pre`,
+            enforce: 'pre',
+            config: {
+                order: 'pre',
+                async handler(configFromUser, env) {
+                    viteVersionUser = this?.meta?.viteVersion; // is `undefined` on old Vite versions
+                    const isDev = isDevCheck(env);
+                    const isBuild = env.command === 'build';
+                    const isPreview = env.isPreview;
+                    assert(isExactlyOneTruthy(isDev, isBuild, isPreview));
+                    const viteContext = isBuild ? 'build' : isPreview ? 'preview' : 'dev';
+                    const rootResolvedEarly = configFromUser.root
+                        ? normalizeViteRoot(configFromUser.root)
+                        : await getViteRoot(viteContext);
+                    assert(rootResolvedEarly);
+                    setVikeConfigContext({ userRootDir: rootResolvedEarly, isDev, vikeVitePluginOptions });
+                    const vikeConfig = await getVikeConfigInternal();
+                    return {
+                        _isDev: isDev,
+                        _rootResolvedEarly: rootResolvedEarly,
+                        // TO-DO/next-major-release: remove https://github.com/vikejs/vike/issues/2122
+                        configVikePromise: Promise.resolve({
+                            prerender: vikeConfig.prerenderContext.isPrerenderingEnabled,
+                        }),
+                    };
+                },
+            },
+        },
+        {
+            name: pluginName,
+            configResolved: {
+                handler(config) {
+                    assertViteRoot(config._rootResolvedEarly, config);
+                    assertSingleInstance(config);
+                    installRequireShim_setUserRootDir(config.root);
+                },
+            },
+        },
+        {
+            name: `${pluginName}:post`,
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                async handler(config) {
+                    /* Also externalize linked dependencies by default?
+                     * - Can this be done while the user sets ssr.external to `string[]`? I guess not?
+                     *   - If not then it's a problem: it makes the default inconsistent.
+                     * - https://vite.dev/config/ssr-options.html#ssr-external
+                     * - New setting +transpileLinkedDependencies ?
+                    overrideViteDefaultSsrExternal(config)
+                    //*/
+                    workaroundCI(config);
+                    assertRollupInput(config);
+                    assertResolveAlias(config);
+                    assertVikeCliOrApi(config);
+                    temp_supportOldInterface(config);
+                    await emitServerEntryOnlyIfNeeded(config);
+                },
+            },
+            config: {
+                order: 'post',
+                async handler(configFromUser) {
+                    let configFromVike = { server: {}, preview: {} };
+                    const vikeConfig = await getVikeConfigInternal();
+                    if (vikeConfig.config.port !== undefined) {
+                        // https://vike.dev/port
+                        setDefault('port', vikeConfig.config.port, configFromUser, configFromVike);
+                    }
+                    else {
+                        // Change Vite's default port
+                        setDefault('port', 3000, configFromUser, configFromVike);
+                    }
+                    if (vikeConfig.config.host) {
+                        // https://vike.dev/host
+                        setDefault('host', vikeConfig.config.host, configFromUser, configFromVike);
+                    }
+                    else if (isDocker()) {
+                        // Set `--host` for Docker/Podman
+                        setDefault('host', true, configFromUser, configFromVike);
+                    }
+                    // https://vike.dev/force
+                    if (vikeConfig.config.force !== undefined && configFromUser.optimizeDeps?.force === undefined) {
+                        configFromVike.optimizeDeps ?? (configFromVike.optimizeDeps = {});
+                        configFromVike.optimizeDeps.force = vikeConfig.config.force;
+                    }
+                    return configFromVike;
+                },
+            },
+        },
+    ];
+}
+// Override Vite's default value without overriding user settings
+function setDefault(setting, value, configFromUser, configFromVike) {
+    if (configFromUser.server?.[setting] === undefined)
+        configFromVike.server[setting] = value;
+    if (configFromUser.preview?.[setting] === undefined)
+        configFromVike.preview[setting] = value;
+}
+/*
+import { version } from 'vite'
+function overrideViteDefaultSsrExternal(config: ResolvedConfig) {
+  if (!isVersionMatch(version, ['5.0.12'])) return
+  // @ts-ignore Not released yet: https://github.com/vitejs/vite/pull/10939/files#diff-5a3d42620df2c6b17e25f440ffdb67683dee7ef57317674d19f41d5f30502310L5
+  config.ssr.external ??= true
+}
+//*/
+// Workaround GitHub Action failing to access the server
+function workaroundCI(config) {
+    var _a, _b;
+    if (process.env.CI) {
+        (_a = config.server).host ?? (_a.host = true);
+        (_b = config.preview).host ?? (_b.host = true);
+    }
+}
+function assertSingleInstance(config) {
+    const numberOfInstances = config.plugins.filter((o) => o.name === pluginName).length;
+    assertUsage(numberOfInstances === 1, `Vike's Vite plugin (${pc.cyan("import vike from 'vike/plugin'")}) is being added ${numberOfInstances} times to the list of Vite plugins. Make sure to add it only once instead.`);
+}
+function assertVikeCliOrApi(config) {
+    if (isVikeCliOrApi())
+        return;
+    if (isViteCli()) {
+        assert(!isVitest());
+        return;
+    }
+    /* This warning is always shown: Vitest loads Vite *before* any Vike JavaScript API can be invoked.
+    if (isVitest()) {
+      assertWarning(
+        false,
+        `Unexpected Vitest setup: you seem to be using Vitest together with Vike's Vite plugin but without using Vike's JavaScript API which is unexpected, see ${pc.underline('https://vike.dev/vitest')}`,
+        { onlyOnce: true },
+      )
+      return
+    }
+    */
+    if (config.server.middlewareMode) {
+        assertWarning(false, `${pc.cyan('vite.createServer()')} is deprecated ${pc.underline('https://vike.dev/migration/cli#api')}`, {
+            onlyOnce: true,
+        });
+        return;
+    }
+}
+// TO-DO/next-major-release: remove https://github.com/vikejs/vike/issues/2122
+function temp_supportOldInterface(config) {
+    if (!('vitePluginSsr' in config))
+        return;
+    assert(isObject(config.vitePluginSsr));
+    if (hasProp(config.vitePluginSsr, 'prerender', 'object')) {
+        assert(hasProp(config.vitePluginSsr.prerender, 'disableAutoRun', 'boolean'));
+        if (config.vitePluginSsr.prerender.disableAutoRun) {
+            temp_disablePrerenderAutoRun();
+        }
+        return;
+    }
+    if (hasProp(config.vitePluginSsr, 'disableAutoFullBuild')) {
+        if (config.vitePluginSsr.disableAutoFullBuild) {
+            assert(config.vitePluginSsr.disableAutoFullBuild === 'prerender');
+            temp_disablePrerenderAutoRun();
+        }
+        return;
+    }
+    assert(false);
+}
+// Only emit dist/server/entry.mjs if necessary
+async function emitServerEntryOnlyIfNeeded(config) {
+    const vikeConfig = await getVikeConfigInternal();
+    if (config.vitePluginServerEntry?.inject && !vikeConfig.prerenderContext.isPrerenderingEnabled) {
+        config.vitePluginServerEntry.disableServerEntryEmit = true;
+    }
+}

package/dist/node/vite/plugins/pluginDev/determineOptimizeDeps.js

@@ -0,0 +1,185 @@
+export { determineOptimizeDeps };
+import { findPageFiles } from '../../shared/findPageFiles.js';
+import { assert, assertIsImportPathNpmPackage, createDebug, getNpmPackageName, isArray, isFilePathAbsoluteFilesystem, isVirtualFileId, requireResolveOptional, } from '../../utils.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { analyzeClientEntries } from '../build/pluginBuildConfig.js';
+import { virtualFileIdGlobalEntryClientCR, virtualFileIdGlobalEntryClientSR, } from '../../../../shared-server-node/virtualFileId.js';
+import { getFilePathResolved } from '../../shared/getFilePath.js';
+import { getConfigValueSourcesRelevant } from '../pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+const debug = createDebug('vike:optimizeDeps');
+const WORKAROUND_LATE_DISCOVERY = [
+    // Workaround for https://github.com/vitejs/vite-plugin-react/issues/650
+    // - The issue was closed as completed with https://github.com/vitejs/vite/pull/20495 but it doesn't fix the issue and the workaround is still needed.
+    // - TO-DO/eventually: try removing the workaround and see if the CI fails (at test/@cloudflare_vite-plugin/) — maybe the issue will get fixed at some point.
+    'react/jsx-dev-runtime',
+    // Workaround for https://github.com/vikejs/vike/issues/2823#issuecomment-3514325487
+    '@compiled/react/runtime',
+];
+async function determineOptimizeDeps(config) {
+    const vikeConfig = await getVikeConfigInternal();
+    const { _pageConfigs: pageConfigs } = vikeConfig;
+    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
+    WORKAROUND_LATE_DISCOVERY.forEach((dep) => {
+        const userRootDir = config.root;
+        const resolved = requireResolveOptional({ importPath: dep, userRootDir, importerFilePath: null });
+        const resolvedInsideRepo = resolved && resolved.startsWith(userRootDir);
+        if (resolvedInsideRepo) {
+            // We add `dep` only if `resolvedInsideRepo === true` otherwise Vite logs a warning like the following.
+            // - ```console
+            //   [11:22:42.464][/examples/vue-full][npm run dev][stderr] Failed to resolve dependency: react/jsx-dev-runtime, present in client 'optimizeDeps.include'
+            //   ```
+            // - ```console
+            //   [12:24:53.225][/test/@cloudflare_vite-plugin/test-dev.test.ts][npm run dev][stderr] Failed to resolve dependency: @compiled/react/runtime, present in ssr 'optimizeDeps.include'
+            //   ```
+            includeClient.push(dep);
+            includeServer.push(dep);
+        }
+        else if (config.optimizeDeps.include?.includes(dep)) {
+            // Monorepo => always `resolvedInsideRepo === false` — we use this other approach to workaround missing 'react/jsx-dev-runtime'
+            includeServer.push(dep);
+        }
+    });
+    config.optimizeDeps.include = add(config.optimizeDeps.include, includeClient);
+    config.optimizeDeps.entries = add(config.optimizeDeps.entries, entriesClient);
+    for (const envName in config.environments) {
+        const env = config.environments[envName];
+        if (env.consumer === 'server' && env.optimizeDeps.noDiscovery === false) {
+            env.optimizeDeps.include = add(env.optimizeDeps.include, includeServer);
+            env.optimizeDeps.entries = add(env.optimizeDeps.entries, entriesServer);
+        }
+    }
+    if (debug.isActivated)
+        debug('optimizeDeps', {
+            'config.optimizeDeps.entries': config.optimizeDeps.entries,
+            'config.optimizeDeps.include': config.optimizeDeps.include,
+            'config.optimizeDeps.exclude': config.optimizeDeps.exclude,
+            // @ts-ignore Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
+            'config.ssr.optimizeDeps.entries': config.ssr.optimizeDeps.entries,
+            'config.ssr.optimizeDeps.include': config.ssr.optimizeDeps.include,
+            'config.ssr.optimizeDeps.exclude': config.ssr.optimizeDeps.exclude,
+        });
+}
+async function getPageDeps(config, pageConfigs) {
+    let entriesClient = [];
+    let entriesServer = [];
+    let includeClient = [];
+    let includeServer = [];
+    const addEntry = (e, isForClientSide, definedAt) => {
+        assert(e);
+        // optimizeDeps.entries expects filesystem absolute paths
+        assert(isVirtualFileId(e) || isFilePathAbsoluteFilesystem(e));
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
+            entriesClient.push(e);
+        }
+        else {
+            entriesServer.push(e);
+        }
+    };
+    const addInclude = (e, isForClientSide, definedAt) => {
+        assert(e);
+        // optimizeDeps.include expects npm packages
+        assert(!e.startsWith('/'));
+        // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
+        assertIsImportPathNpmPackage(e);
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
+            includeClient.push(e);
+        }
+        else {
+            includeServer.push(e);
+        }
+    };
+    const isExcluded = (e, isForClientSide, definedAt) => {
+        const exclude = isForClientSide ? config.optimizeDeps.exclude : config.ssr.optimizeDeps.exclude;
+        if (!exclude)
+            return false;
+        if (definedAt?.importPathAbsolute) {
+            const npmPackageName = getNpmPackageName(definedAt.importPathAbsolute);
+            if (npmPackageName && exclude.includes(npmPackageName))
+                return true;
+        }
+        return exclude.includes(e);
+    };
+    // V1 design
+    {
+        ;
+        [true, false].forEach((isForClientSide) => {
+            pageConfigs.forEach((pageConfig) => {
+                Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
+                    const runtimeEnv = {
+                        isForClientSide,
+                        isDev: true,
+                        // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                        isClientRouting: true,
+                    };
+                    const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
+                    sourcesRelevant.forEach((configValueSource) => {
+                        if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
+                            return;
+                        const { definedAt } = configValueSource;
+                        if (definedAt.definedBy)
+                            return;
+                        if (definedAt.filePathAbsoluteUserRootDir !== null) {
+                            addEntry(
+                            // optimizeDeps.entries expects filesystem absolute paths
+                            definedAt.filePathAbsoluteFilesystem, isForClientSide, definedAt);
+                        }
+                        else {
+                            addInclude(
+                            // optimizeDeps.include expects npm packages
+                            definedAt.importPathAbsolute, isForClientSide, definedAt);
+                        }
+                    });
+                });
+            });
+        });
+    }
+    // V0.4 design
+    {
+        const pageFiles = await findPageFiles(config, ['.page', '.page.client'], true);
+        const userRootDir = config.root;
+        pageFiles.forEach((filePathAbsoluteUserRootDir) => {
+            const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
+            const { filePathAbsoluteFilesystem } = entry;
+            addEntry(filePathAbsoluteFilesystem, true);
+        });
+    }
+    // Add virtual files.
+    // - This doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
+    //   - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
+    //   - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
+    //     - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
+    {
+        const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
+        Object.values(clientEntries).forEach((e) => addEntry(e, true));
+        if (hasClientRouting)
+            addEntry(virtualFileIdGlobalEntryClientCR, true);
+        if (hasServerRouting)
+            addEntry(virtualFileIdGlobalEntryClientSR, true);
+    }
+    entriesClient = entriesClient;
+    entriesServer = entriesServer;
+    includeClient = includeClient;
+    includeServer = includeServer;
+    return {
+        entriesClient,
+        entriesServer,
+        includeClient,
+        includeServer,
+    };
+}
+function add(input, listAddendum) {
+    const list = !input ? [] : isArray(input) ? unique(input) : [input];
+    listAddendum.forEach((e) => {
+        if (!list.includes(e))
+            list.push(e);
+    });
+    return list;
+}
+function unique(arr) {
+    const arrUnique = Array.from(new Set(arr));
+    return arr.length !== arrUnique.length ? arrUnique : arr;
+}

package/dist/node/vite/plugins/pluginDev.js

@@ -0,0 +1,89 @@
+export { pluginDev };
+export { logDockerHint };
+import { determineOptimizeDeps } from './pluginDev/determineOptimizeDeps.js';
+import { determineFsAllowList } from './pluginDev/determineFsAllowList.js';
+import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
+import { applyDev, assertWarning, isDocker, isDebugError } from '../utils.js';
+import { interceptViteLogs } from '../shared/loggerVite.js';
+import pc from '@brillout/picocolors';
+import { swallowViteLogConnected, swallowViteLogConnected_clean } from '../shared/loggerVite.js';
+function pluginDev() {
+    let config;
+    return [
+        {
+            name: 'vike:pluginDev',
+            apply: applyDev,
+            config: {
+                handler() {
+                    return {
+                        appType: 'custom',
+                        optimizeDeps: {
+                            exclude: [
+                                // We must exclude Vike's client runtime so it can import virtual modules
+                                'vike/client',
+                                'vike/client/router',
+                            ],
+                            include: [
+                                // Avoid:
+                                // ```
+                                // 9:28:58 AM [vite] ✨ new dependencies optimized: @brillout/json-serializer/parse
+                                // 9:28:58 AM [vite] ✨ optimized dependencies changed. reloading
+                                // ```
+                                'vike > @brillout/json-serializer/parse',
+                                'vike > @brillout/json-serializer/stringify',
+                                'vike > @brillout/picocolors',
+                            ],
+                        },
+                    };
+                },
+            },
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    await determineOptimizeDeps(config);
+                    await determineFsAllowList(config);
+                    interceptViteLogs(config);
+                    logDockerHint(config.server.host);
+                },
+            },
+        },
+        {
+            name: 'vike:pluginDev:post',
+            apply: applyDev,
+            // The SSR middleware should be last middleware
+            enforce: 'post',
+            configureServer: {
+                order: 'post',
+                handler(server) {
+                    swallowViteLogConnected_clean(); // If inside a configureServer() `pre` hook => too early
+                    const hasHonoViteDevServer = !!config.plugins.find((p) => p.name === '@hono/vite-dev-server');
+                    if (config.server.middlewareMode || hasHonoViteDevServer)
+                        return;
+                    return () => {
+                        addSsrMiddleware(server.middlewares, config, false, null);
+                    };
+                },
+            },
+            // Setting `configResolved.clearScreen = false` doesn't work
+            config: {
+                order: 'post',
+                handler() {
+                    if (isDebugError()) {
+                        return { clearScreen: false };
+                    }
+                },
+            },
+            configResolved: {
+                order: 'post',
+                handler() {
+                    swallowViteLogConnected();
+                },
+            },
+        },
+    ];
+}
+function logDockerHint(configHost) {
+    if (isDocker()) {
+        assertWarning(configHost, `Your app seems to be running inside a Docker or Podman container but ${pc.cyan('--host')} isn't set which means that your Vike app won't be accessible from outside the container, see https://vike.dev/docker`, { onlyOnce: true });
+    }
+}