vike 0.4.247 → 0.4.249-commit-775a43e

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

@@ -0,0 +1,177 @@
+export { pluginAssertFileEnv };
+import { assert, assertUsage, assertWarning, capitalizeFirstLetter, isFilePathAbsolute, joinEnglish, rollupSourceMapRemove, } from '../utils.js';
+import { extractAssetsRE } from './pluginExtractAssets.js';
+import { extractExportNamesRE } from './pluginExtractExportNames.js';
+import pc from '@brillout/picocolors';
+import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
+import { getExportNames } from '../shared/parseEsModule.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
+import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { suffixesAssertFileEnv } from '../../../shared-server-node/getFileSuffixes.js';
+const envS = suffixesAssertFileEnv;
+const skipNodeModules = '/node_modules/'; // Only assert `.server.js`, `.client.js` and `.ssr.js` for user files
+const filterRolldown = {
+    id: {
+        include: envS.map((env) => `**/*${getSuffix(env)}*`),
+        exclude: [`**${skipNodeModules}**`],
+    },
+};
+const filterFunction = (id) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    return envS.some((suffix) => id.includes(getSuffix(suffix)));
+};
+function pluginAssertFileEnv() {
+    let config;
+    let viteDevServer;
+    return [
+        {
+            name: 'vike:pluginAssertFileEnv',
+            load: {
+                filter: filterRolldown,
+                handler(id, options) {
+                    // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
+                    if (!viteDevServer)
+                        return;
+                    if (!isV1Design())
+                        return;
+                    if (skip(id, config.root))
+                        return;
+                    // For `.vue` files: https://github.com/vikejs/vike/issues/1912#issuecomment-2394981475
+                    if (id.endsWith('?direct'))
+                        id = id.slice(0, -1 * '?direct'.length);
+                    const moduleInfo = viteDevServer.moduleGraph.getModuleById(id);
+                    /* It can fail, no clue why — https://github.com/vikejs/vike/issues/2740
+                    assert(moduleInfo, { moduleId })
+                    */
+                    const importers = (!moduleInfo ? [] : Array.from(moduleInfo.importers))
+                        .map((m) => m.id)
+                        .filter((id) => id !== null);
+                    assertFileEnv(id, isViteServerSide_extraSafe(config, this.environment, options), importers, 
+                    // In dev, we only show a warning because we don't want to disrupt when the user plays with settings such as [ssr](https://vike.dev/ssr).
+                    true);
+                },
+            },
+            // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
+            transform: {
+                filter: filterRolldown,
+                async handler(code, id, options) {
+                    id = normalizeId(id);
+                    // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
+                    if (viteDevServer)
+                        return;
+                    if (skip(id, config.root))
+                        return;
+                    const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
+                    if (!isWrongEnv(id, isServerSide))
+                        return;
+                    const { importers } = this.getModuleInfo(id);
+                    // Throwing a verbose error doesn't waste client-side KBs as dynamic imports are code split.
+                    const errMsg = getErrMsg(id, isServerSide, importers, false, config, true);
+                    // We have to inject empty exports to avoid Rollup complaining about missing exports, see https://gist.github.com/brillout/5ea45776e65bd65100a52ecd7bfda3ff
+                    const { exportNames } = await getExportNames(code);
+                    return rollupSourceMapRemove([
+                        `throw new Error(${JSON.stringify(errMsg)});`,
+                        ...exportNames.map((name) => name === 'default' ? 'export default undefined;' : `export const ${name} = undefined;`),
+                    ].join('\n'));
+                },
+            },
+            generateBundle: {
+                handler() {
+                    Array.from(this.getModuleIds())
+                        .filter(filterFunction)
+                        .filter((id) => !skip(id, config.root))
+                        .forEach((moduleId) => {
+                        const mod = this.getModuleInfo(moduleId);
+                        const { importers } = mod;
+                        if (importers.length === 0) {
+                            // Dynamic imports can only be verified at runtime
+                            /* This assertion can fail: https://github.com/vikejs/vike/issues/2227
+                        assert(dynamicImporters.length > 0)
+                        */
+                            return;
+                        }
+                        assertFileEnv(moduleId, isViteServerSide(config, this.environment), importers, false);
+                    });
+                },
+            },
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            configureServer: {
+                handler(viteDevServer_) {
+                    viteDevServer = viteDevServer_;
+                },
+            },
+        },
+    ];
+    function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {
+        if (!isWrongEnv(moduleId, isServerSide))
+            return;
+        const errMsg = getErrMsg(moduleId, isServerSide, importers, onlyWarn, config, false);
+        if (onlyWarn) {
+            assertWarning(false, errMsg, { onlyOnce: true });
+        }
+        else {
+            assertUsage(false, errMsg);
+        }
+    }
+}
+function isWrongEnv(moduleId, isServerSide) {
+    const modulePath = getModulePath(moduleId);
+    if (isServerSide) {
+        // On server-side, .client. is wrong
+        return modulePath.includes(getSuffix('client'));
+    }
+    else {
+        // On client-side, both .server. and .ssr. are wrong
+        return modulePath.includes(getSuffix('server')) || modulePath.includes(getSuffix('ssr'));
+    }
+}
+function getErrMsg(moduleId, isServerSide, importers, onlyWarn, config, noColor) {
+    const envActual = isServerSide ? 'server' : 'client';
+    const envExpect = isServerSide ? 'client' : 'server';
+    const modulePath = getModulePath(moduleId);
+    let modulePathPretty = getFilePathToShowToUserModule(modulePath, config);
+    if (!noColor) {
+        const suffix = modulePath.includes(getSuffix('ssr')) ? getSuffix('ssr') : getSuffix(envExpect);
+        modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
+    }
+    let errMsg = `${capitalizeFirstLetter(envExpect)}-only file ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
+    {
+        const importPaths = importers
+            .filter((importer) => 
+        // Can be Vike's virtual module: https://github.com/vikejs/vike/issues/2483
+        isFilePathAbsolute(importer))
+            .map((importer) => getFilePathToShowToUserModule(importer, config))
+            .map((importPath) => pc.cyan(importPath));
+        if (importPaths.length > 0) {
+            errMsg += ` by ${joinEnglish(importPaths, 'and')}`;
+        }
+    }
+    if (onlyWarn) {
+        errMsg += ". This is potentially a security issue and Vike won't allow you to build your app for production.";
+    }
+    return errMsg;
+}
+function skip(id, userRootDir) {
+    assert(filterFunction(id));
+    // TO-DO/next-major-release: remove
+    if (extractAssetsRE.test(id) || extractExportNamesRE.test(id))
+        return true;
+    if (getModulePath(id).endsWith('.css'))
+        return true;
+    // Skip linked dependencies
+    if (!id.startsWith(userRootDir))
+        return true;
+    return false;
+}
+function getSuffix(env) {
+    return `.${env}.`;
+}
+function getModulePath(moduleId) {
+    return moduleId.split('?')[0];
+}

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

@@ -0,0 +1,52 @@
+export { pluginBaseUrls };
+import { resolveBase } from '../../../shared-server-node/resolveBase.js';
+import { assert } from '../utils.js';
+import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+function pluginBaseUrls() {
+    let basesResolved;
+    return [
+        {
+            name: 'vike:pluginBaseUrls',
+            enforce: 'post',
+            config: {
+                async handler(config) {
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
+                    const vikeConfig = await getVikeConfigInternal();
+                    basesResolved = resolveBase(baseViteOriginal, vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null);
+                    // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
+                    process.env.BASE_SERVER = basesResolved.baseServer;
+                    process.env.BASE_ASSETS = basesResolved.baseAssets;
+                    return {
+                        envPrefix: [
+                            'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
+                            'BASE_SERVER',
+                            'BASE_ASSETS',
+                        ],
+                        base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
+                        _baseViteOriginal: baseViteOriginal,
+                    };
+                },
+            },
+            configResolved: {
+                async handler(config) {
+                    const vikeConfig = await getVikeConfigInternal();
+                    const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null, config);
+                    assert(basesResolved2.baseServer === basesResolved.baseServer);
+                    assert(basesResolved2.baseAssets === basesResolved.baseAssets);
+                    /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
+                 *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
+                 *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
+                assert(config.base === baseAssets)
+                */
+                },
+            },
+        },
+    ];
+}
+function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
+    let baseViteOriginal = config._baseViteOriginal;
+    assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
+    return resolveBase(baseViteOriginal, baseServer, baseAssets);
+}

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

@@ -0,0 +1,83 @@
+export { assertResolveAlias };
+import { assert, assertUsage, assertWarning, isArray, isPathAliasRecommended } from '../../utils.js';
+import pc from '@brillout/picocolors';
+// Recommend users to avoid un-distinguishable path aliases.
+// There are a lot of libraries that don't or cannot follow that recommendation, for example:
+// - Nx
+//   - Not sure why, but Nx seems to add a path alias for each monorepo package
+//   - https://github.com/vikejs/vike/discussions/1134
+// - MUI
+//   - https://mui.com/material-ui/guides/minimizing-bundle-size/#how-to-use-custom-bundles
+//   - https://github.com/vikejs/vike/discussions/1549#discussioncomment-8789002
+// - @preact/preset-vite
+//   - Aliases react imports
+// - @vitejs/plugin-vue2
+//   - https://github.com/vikejs/vike/issues/1329
+function assertResolveAlias(config) {
+    // TO-DO/eventually: re-implement warning https://github.com/vikejs/vike/issues/1567
+    return;
+    const aliases = getAliases(config);
+    const errPrefix = config.configFile || 'Your Vite configuration';
+    const errSuffix1 = 'see https://vike.dev/path-aliases#vite';
+    const deprecation = 'which will be deprecated in the next major release';
+    const errSuffix2 = `${deprecation}, use a string instead and ${errSuffix1}`;
+    aliases.forEach((alias) => {
+        const { customResolver, find } = alias;
+        {
+            const msg = `${errPrefix} defines resolve.alias with customResolver() ${errSuffix2}`;
+            assertWarning(customResolver === undefined, msg, { onlyOnce: true });
+        }
+        if (typeof find !== 'string') {
+            assert(find instanceof RegExp);
+            // Skip aliases set by Vite:
+            //   /^\/?@vite\/env/
+            //   /^\/?@vite\/client/
+            if (find.toString().includes('@vite'))
+                return;
+            // Skip alias /^solid-refresh$/ set by vite-plugin-solid
+            if (find.toString().includes('solid-refresh'))
+                return;
+            {
+                const msg = `${errPrefix} defines resolve.alias with a regular expression ${errSuffix2}`;
+                assertWarning(false, msg, {
+                    onlyOnce: true,
+                });
+            }
+        }
+        else {
+            // Allow un-distinguishable aliases set by @preact/preset-vite
+            if (find.startsWith('react'))
+                return;
+            // Allow un-distinguishable aliases set by @vitejs/plugin-vue2 https://github.com/vikejs/vike/issues/1329
+            if (find === 'vue')
+                return;
+            {
+                const msg = `${errPrefix} defines an invalid ${pc.cyan('resolve.alias')}: a path alias cannot be the empty string ${pc.cyan("''")}`;
+                assertUsage(find !== '', msg);
+            }
+            // Ensure path alias are distinguishable from npm package names, which is needed by:
+            //  - resolveOptimizeDeps()
+            //  - extractAssets
+            //  - in general: using un-distinguishable path aliases is asking for trouble
+            if (!isPathAliasRecommended(find)) {
+                if (find.startsWith('@')) {
+                    const msg = `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias cannot start with ${pc.cyan('@')}, ${errSuffix1}`;
+                    assertWarning(false, msg, { onlyOnce: true });
+                }
+                else {
+                    const msg = `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias needs to start with a special character, ${errSuffix1}`;
+                    assertWarning(false, msg, { onlyOnce: true });
+                }
+            }
+        }
+    });
+}
+function getAliases(config) {
+    const { alias } = config.resolve;
+    if (!isArray(alias)) {
+        return [alias];
+    }
+    else {
+        return alias;
+    }
+}

package/dist/node/vite/plugins/pluginCommon.d.ts

@@ -0,0 +1,17 @@
+export { pluginCommon };
+import { type InlineConfig, type Plugin } from 'vite';
+import type { VitePluginServerEntryOptions } from '@brillout/vite-plugin-server-entry/plugin';
+declare module 'vite' {
+    interface UserConfig {
+        vitePluginServerEntry?: VitePluginServerEntryOptions;
+        _isDev?: boolean;
+        _rootResolvedEarly?: string;
+        _baseViteOriginal?: string;
+        _viteConfigFromUserResolved?: InlineConfig;
+        _viteVersionResolved?: string;
+    }
+}
+declare global {
+    var __VIKE__IS_PROCESS_SHARED_WITH_VITE: undefined | true;
+}
+declare function pluginCommon(vikeVitePluginOptions: unknown): Plugin[];

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

@@ -0,0 +1,188 @@
+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 '../../../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';
+import { version as viteVersionVike } from 'vite';
+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 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,
+                        _viteVersionResolved: viteVersionUser || viteVersionVike,
+                        _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/optimizeDeps.d.ts

@@ -0,0 +1,15 @@
+export { optimizeDeps };
+export { resolveOptimizeDeps };
+import type { ResolvedConfig } from 'vite';
+declare const optimizeDeps: {
+    readonly optimizeDeps: {
+        readonly exclude: ["vike/client", "vike/client/router"];
+        readonly include: ["vike > @brillout/json-serializer/parse", "vike > @brillout/json-serializer/stringify", "vike > @brillout/picocolors"];
+    };
+    readonly ssr: {
+        readonly optimizeDeps: {
+            readonly exclude: ["@brillout/import", "@brillout/json-serializer", "@brillout/picocolors", "@brillout/vite-plugin-server-entry", "vike"];
+        };
+    };
+};
+declare function resolveOptimizeDeps(config: ResolvedConfig): Promise<void>;