vike 0.4.247 → 0.4.249

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

@@ -1,185 +0,0 @@
-export { pluginCommon };
-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 '../../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) {
-                    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/esm/node/vite/plugins/pluginDev/determineOptimizeDeps.d.ts

@@ -1,3 +0,0 @@
-export { determineOptimizeDeps };
-import type { ResolvedConfig } from 'vite';
-declare function determineOptimizeDeps(config: ResolvedConfig): Promise<void>;

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

@@ -1,185 +0,0 @@
-export { determineOptimizeDeps };
-import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, assertIsImportPathNpmPackage, createDebugger, 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/virtualFileId.js';
-import { getFilePathResolved } from '../../shared/getFilePath.js';
-import { getConfigValueSourcesRelevant } from '../pluginVirtualFiles/getConfigValueSourcesRelevant.js';
-const debug = createDebugger('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/esm/node/vite/plugins/pluginDev.d.ts

@@ -1,5 +0,0 @@
-export { pluginDev };
-export { logDockerHint };
-import type { Plugin, ResolvedConfig } from 'vite';
-declare function pluginDev(): Plugin[];
-declare function logDockerHint(configHost: ResolvedConfig['server']['host']): void;

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

@@ -1,89 +0,0 @@
-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 } from '../utils.js';
-import { improveViteLogs } from '../shared/loggerVite.js';
-import { isErrorDebug } from '../../shared/isErrorDebug.js';
-import { installHttpRequestAsyncStore } from '../shared/getHttpRequestAsyncStore.js';
-import pc from '@brillout/picocolors';
-if (isErrorDebug()) {
-    Error.stackTraceLimit = Infinity;
-}
-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);
-                    if (!isErrorDebug()) {
-                        await installHttpRequestAsyncStore();
-                        improveViteLogs(config);
-                    }
-                    logDockerHint(config.server.host);
-                },
-            },
-        },
-        {
-            name: 'vike:pluginDev:addSsrMiddleware',
-            apply: applyDev,
-            // The SSR middleware should be last middleware
-            enforce: 'post',
-            configureServer: {
-                order: 'post',
-                handler(server) {
-                    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 (isErrorDebug()) {
-                        return { clearScreen: false };
-                    }
-                },
-            },
-        },
-    ];
-}
-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 });
-    }
-}