vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/esm/node/client/router.js

@@ -0,0 +1,12 @@
+export { navigate };
+export { reload };
+import { assertWarning } from '../../utils/assert.js';
+// `never` to ensure package.json#exports["./client/router"].types points to type defined by the client-side code
+const navigate = (() => warnNoEffect('navigate'));
+const reload = (() => warnNoEffect('reload'));
+function warnNoEffect(caller) {
+    assertWarning(false, `Calling ${caller} on the server-side has no effect`, {
+        showStackTrace: true,
+        onlyOnce: false
+    });
+}

package/dist/esm/node/createPageRenderer.d.ts

@@ -0,0 +1,13 @@
+import { renderPage } from './runtime/renderPage.js';
+export { createPageRenderer };
+type RenderPage = typeof renderPage;
+type Options = {
+    viteDevServer?: unknown;
+    root?: string;
+    outDir?: string;
+    isProduction?: boolean;
+    base?: string;
+    baseAssets?: string | null;
+};
+/** @deprecated */
+declare function createPageRenderer(options: Options): RenderPage;

package/dist/esm/node/createPageRenderer.js

@@ -0,0 +1,131 @@
+// TODO/v1-release: remove this file
+//import { SsrEnv, setSsrEnv } from './ssrEnv.js'
+import { renderPage } from './runtime/renderPage.js';
+import { assertWarning } from './runtime/utils.js';
+//import { importBuildWasLoaded } from './importBuild.js'
+export { createPageRenderer };
+/** @deprecated */
+function createPageRenderer(options) {
+    showWarnings(options);
+    return renderPage;
+}
+function showWarnings(options) {
+    assertWarning(false, '`createPageRenderer()` is outdated, use `renderPage()` instead. See https://vike.dev/renderPage', { onlyOnce: true, showStackTrace: true });
+    const { viteDevServer, root, outDir, isProduction, base, baseAssets } = options;
+    {
+        const opts = [
+            viteDevServer !== undefined && 'viteDevServer',
+            root !== undefined && 'root',
+            outDir !== undefined && 'outDir',
+            isProduction !== undefined && 'isProduction'
+        ].filter(notFalse);
+        assertWarning(opts.length === 0, `The options ${str(opts)} you passed to \`createPageRenderer()\` have no effect anymore: they are now automatically determined.`, { onlyOnce: true });
+    }
+    {
+        const opts = [base !== undefined && 'base', baseAssets !== undefined && 'baseAssets'].filter(notFalse);
+        assertWarning(opts.length === 0, `The options ${str(opts)} you passed to \`createPageRenderer()\` have no effect. See https://vike.dev/migration-0.4`, { onlyOnce: true });
+    }
+}
+function str(opts) {
+    return opts
+        .map((opt) => '`' + opt + '`')
+        .join(', ')
+        .replace(/,(?=[^,]*$)/, ' and');
+}
+function notFalse(val) {
+    return val !== false;
+}
+/*
+function assertArguments(
+  ssrEnv: {
+    viteDevServer?: unknown
+    root?: unknown
+    outDir?: unknown
+    isProduction?: unknown
+    baseServer?: unknown
+    baseAssets?: unknown
+  },
+  args: unknown[],
+): asserts ssrEnv is SsrEnv {
+  const { viteDevServer, root, outDir, isProduction, baseServer, baseAssets } = ssrEnv
+  assertUsage(
+    root === undefined || typeof root === 'string',
+    '`createPageRenderer({ root })`: argument `root` should be a string.',
+  )
+  assertUsage(typeof outDir === 'string', '`createPageRenderer({ outDir })`: argument `outDir` should be a string.')
+  assertUsage(typeof baseServer === 'string', '`createPageRenderer({ base })`: argument `base` should be a string.')
+  assertUsage(
+    baseAssets === null || typeof baseAssets === 'string',
+    '`createPageRenderer({ baseAssets })`: argument `baseAssets` should be a string.',
+  )
+  assertUsageBaseServer(baseServer, '`createPageRenderer({ base })`: ')
+  assertUsage(
+    isProduction === true || isProduction === false || isProduction === undefined,
+    '`createPageRenderer({ isProduction })`: argument `isProduction` should be `true`, `false`, or `undefined`.',
+  )
+  if (importBuildWasLoaded()) {
+    assertUsage(
+      isProduction,
+      '`createPageRenderer({ isProduction })`: argument `isProduction` should be `true` if `dist/server/importBuild.js` is loaded. (You should load `dist/server/importBuild.js` only in production.)',
+    )
+    assertUsage(
+      root === undefined,
+      '`createPageRenderer({ root })`: argument `root` has no effect if `dist/server/importBuild.js` is loaded. Remove the `root` argument.',
+    )
+  }
+  if (isProduction === true) {
+    assertUsage(
+      viteDevServer === undefined,
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is `true`, then `viteDevServer` should be `undefined`.',
+    )
+    assertUsage(
+      root || importBuildWasLoaded(),
+      "`createPageRenderer({ root })`: argument `root` is missing. (Alternatively, if `root` doesn't exist because you are bundling your server code into a single file, then load `dist/server/importBuild.js`.)",
+    )
+  } else {
+    assertUsage(root, '`createPageRenderer({ root })`: argument `root` is missing.')
+
+    assertUsage(
+      !!viteDevServer,
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is not `true`, then `viteDevServer` cannot be `undefined`.',
+    )
+
+    const wrongViteDevServerValueError =
+      '`createPageRenderer({ viteDevServer, isProduction })`: if `isProduction` is not `true`, then `viteDevServer` should be `viteDevServer = await vite.createServer()`.'
+    assertUsage(
+      hasProp(viteDevServer, 'config') &&
+        hasProp(viteDevServer.config, 'root') &&
+        typeof viteDevServer.config.root === 'string',
+      wrongViteDevServerValueError,
+    )
+    {
+      const rootVite = resolve(viteDevServer.config.root)
+      const rootResolved = resolve(root)
+      assertUsage(
+        rootVite === rootResolved,
+        '`createPageRenderer({ viteDevServer, root })`: wrong `root` value, make sure it matches `viteDevServer.config.root`. ' +
+          `The \`root\` you provided resolves to \`'${rootResolved}'\` while \`viteDevServer.config.root\` resolves to \`${rootVite}\`.`,
+      )
+    }
+
+    assertUsage(
+      hasProp(viteDevServer, 'config', 'object') && hasProp(viteDevServer.config, 'plugins', 'array'),
+      wrongViteDevServerValueError,
+    )
+    assertUsage(
+      (viteDevServer as any as ViteDevServer).config.plugins.find((plugin) =>
+        plugin.name.startsWith('vike'),
+      ),
+      "Vike's Vite plugin is not installed. Make sure to add it to your `vite.config.js`.",
+    )
+  }
+  assertUsage(args.length === 1, '`createPageRenderer()`: all arguments should be passed as a single argument object.')
+  assert(typeof args[0] === 'object' && args[0] !== null)
+  Object.keys(args[0]).forEach((argName) => {
+    assertUsage(
+      ['viteDevServer', 'root', 'outDir', 'isProduction', 'base', 'baseAssets'].includes(argName),
+      '`createPageRenderer()`: Unknown argument `' + argName + '`.',
+    )
+  })
+}
+    */

package/dist/esm/node/importBuild.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/node/importBuild.js

@@ -0,0 +1,3 @@
+// TODO/v1-release: remove
+console.warn("[vike][Warning] importBuild.js is not needed anymore; it has no effect. Remove `import 'dist/server/importBuild.js'` to remove this warning. More infos at https://vike.dev/importBuild.js");
+export {};

package/dist/esm/node/plugin/index.d.ts

@@ -0,0 +1,6 @@
+export default plugin;
+export { plugin };
+export { plugin as ssr };
+export type { ConfigVikeUserProvided as UserConfig };
+import type { ConfigVikeUserProvided } from '../../shared/ConfigVike.js';
+declare function plugin(vikeConfig?: ConfigVikeUserProvided): any;

package/dist/esm/node/plugin/index.js

@@ -0,0 +1,64 @@
+export default plugin;
+export { plugin };
+export { plugin as ssr };
+import { assertUsage, markEnvAsVite } from './utils.js';
+import { buildConfig } from './plugins/buildConfig.js';
+import { previewConfig } from './plugins/previewConfig.js';
+import { autoFullBuild } from './plugins/autoFullBuild.js';
+import { devConfig } from './plugins/devConfig/index.js';
+import { manifest } from './plugins/manifest.js';
+import { packageJsonFile } from './plugins/packageJsonFile.js';
+import { removeRequireHookPlugin } from './plugins/removeRequireHookPlugin.js';
+import { importUserCode } from './plugins/importUserCode/index.js';
+import { resolveVikeConfig } from './plugins/config/index.js';
+import { distFileNames } from './plugins/distFileNames.js';
+import { extractAssetsPlugin } from './plugins/extractAssetsPlugin.js';
+import { extractExportNamesPlugin } from './plugins/extractExportNamesPlugin.js';
+import { suppressRollupWarning } from './plugins/suppressRollupWarning.js';
+import { setGlobalContext } from './plugins/setGlobalContext.js';
+import { importBuild } from './plugins/importBuild/index.js';
+import { commonConfig } from './plugins/commonConfig.js';
+import { extensionsAssets } from './plugins/extensionsAssets.js';
+import { baseUrls } from './plugins/baseUrls.js';
+import { envVarsPlugin } from './plugins/envVars.js';
+import pc from '@brillout/picocolors';
+markEnvAsVite();
+// Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
+function plugin(vikeConfig) {
+    const plugins = [
+        resolveVikeConfig(vikeConfig),
+        ...commonConfig(),
+        importUserCode(),
+        ...devConfig(),
+        buildConfig(),
+        previewConfig(),
+        ...autoFullBuild(),
+        ...manifest(),
+        packageJsonFile(),
+        removeRequireHookPlugin(),
+        distFileNames(),
+        ...extractAssetsPlugin(),
+        extractExportNamesPlugin(),
+        suppressRollupWarning(),
+        setGlobalContext(),
+        ...importBuild(),
+        extensionsAssets(),
+        baseUrls(vikeConfig),
+        envVarsPlugin()
+    ];
+    return plugins;
+}
+// Enable `const ssr = require('vike/plugin')`.
+//  - This lives at the end of the file to ensure it happens after all assignments to `exports`.
+//  - This is only used for the CJS build; we wrap it in a try-catch for the ESM build.
+try {
+    module.exports = Object.assign(exports.default, exports);
+}
+catch { }
+// Error upon wrong usage
+Object.defineProperty(plugin, 'apply', {
+    enumerable: true,
+    get: () => {
+        assertUsage(false, `Add ${pc.cyan('ssr()')} instead of ${pc.cyan('ssr')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
+    }
+});

package/dist/esm/node/plugin/onLoad.d.ts

@@ -0,0 +1,2 @@
+export { onLoad };
+declare function onLoad(): void;

package/dist/esm/node/plugin/onLoad.js

@@ -0,0 +1,10 @@
+export { onLoad };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertIsNotProductionRuntime.js';
+import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
+function onLoad() {
+    assertIsNotBrowser();
+    assertNodeVersion();
+    // Ensure we don't bloat the server runtime with heavy plugin dependencies such as esbuild
+    assertIsNotProductionRuntime();
+}

package/dist/esm/node/plugin/plugins/autoFullBuild.d.ts

@@ -0,0 +1,3 @@
+export { autoFullBuild };
+import type { Plugin } from 'vite';
+declare function autoFullBuild(): Plugin[];

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -0,0 +1,98 @@
+export { autoFullBuild };
+import { build } from 'vite';
+import { assertWarning } from '../utils.js';
+import { prerenderFromAutoFullBuild, prerenderForceExit } from '../../prerender/runPrerender.js';
+import { getConfigVike } from '../../shared/getConfigVike.js';
+import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
+import pc from '@brillout/picocolors';
+let forceExit = false;
+function autoFullBuild() {
+    let config;
+    let configVike;
+    return [
+        {
+            name: 'vike:autoFullBuild',
+            apply: 'build',
+            enforce: 'pre',
+            async configResolved(config_) {
+                configVike = await getConfigVike(config_);
+                config = config_;
+                abortViteBuildSsr(configVike);
+            },
+            writeBundle: {
+                /* We can't use this because it breaks Vite's logging. TODO: try again with latest Vite version.
+                sequential: true,
+                order: 'pre',
+                */
+                async handler(_options, bundle) {
+                    try {
+                        await triggerFullBuild(config, configVike, bundle);
+                    }
+                    catch (err) {
+                        // Avoid Rollup prefixing the error with [vike:autoFullBuild], for example see https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        console.error(err);
+                        process.exit(1);
+                    }
+                }
+            }
+        },
+        {
+            name: 'vike:autoFullBuild:forceExit',
+            apply: 'build',
+            enforce: 'post',
+            closeBundle: {
+                sequential: true,
+                order: 'post',
+                handler() {
+                    if (forceExit) {
+                        prerenderForceExit();
+                    }
+                }
+            }
+        }
+    ];
+}
+async function triggerFullBuild(config, configVike, bundle) {
+    if (config.build.ssr)
+        return; // already triggered
+    if (isDisabled(configVike))
+        return;
+    // vike.json missing => it isn't a `$ vite build` call (e.g. @vitejs/plugin-legacy calls Vite's build() API) => skip
+    if (!bundle['vike.json'])
+        return;
+    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
+    const configInline = {
+        ...configFromCli,
+        configFile: configFromCli?.configFile || config.configFile,
+        root: config.root,
+        build: {
+            ...configFromCli?.build
+        }
+    };
+    await build({
+        ...configInline,
+        build: {
+            ...configInline.build,
+            ssr: true
+        }
+    });
+    if (configVike.prerender && !configVike.prerender.disableAutoRun) {
+        await prerenderFromAutoFullBuild({ viteConfig: configInline });
+        forceExit = true;
+    }
+}
+function abortViteBuildSsr(configVike) {
+    if (!configVike.disableAutoFullBuild && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+        assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
+        process.exit(0);
+    }
+}
+function isDisabled(configVike) {
+    if (configVike.disableAutoFullBuild === null) {
+        // TODO/v1-release: also enable autoFullBuild when running Vite's build() API
+        return !isViteCliCall();
+    }
+    else {
+        return configVike.disableAutoFullBuild;
+    }
+}

package/dist/esm/node/plugin/plugins/baseUrls.d.ts

@@ -0,0 +1,4 @@
+export { baseUrls };
+import type { Plugin } from 'vite';
+import type { ConfigVikeUserProvided } from '../../../shared/ConfigVike.js';
+declare function baseUrls(configVike?: ConfigVikeUserProvided): Plugin;

package/dist/esm/node/plugin/plugins/baseUrls.js

@@ -0,0 +1,40 @@
+export { baseUrls };
+import { resolveBaseFromUserConfig } from '../plugins/config/resolveBase.js';
+import { assert } from '../utils.js';
+import { getConfigVike } from '../../shared/getConfigVike.js';
+function baseUrls(configVike) {
+    let baseServer;
+    let baseAssets;
+    return {
+        name: 'vike:baseUrls',
+        enforce: 'post',
+        config: (config) => {
+            const bases = resolveBaseFromUserConfig(config, configVike);
+            baseServer = bases.baseServer;
+            baseAssets = bases.baseAssets;
+            // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
+            process.env.BASE_SERVER = baseServer;
+            process.env.BASE_ASSETS = baseAssets;
+            return {
+                envPrefix: [
+                    'VITE_',
+                    'BASE_SERVER',
+                    'BASE_ASSETS'
+                ],
+                base: baseAssets,
+                _baseOriginal: config.base ?? '/__UNSET__' // Vite resolves `_baseOriginal: null` to `undefined`
+            };
+        },
+        async configResolved(config) {
+            const configVike = await getConfigVike(config);
+            // Ensure that the premature base URL resolving we did in config() isn't erroneous
+            assert(configVike.baseServer === baseServer);
+            assert(configVike.baseAssets === 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)
+            */
+        }
+    };
+}

package/dist/esm/node/plugin/plugins/buildConfig.d.ts

@@ -0,0 +1,12 @@
+export { buildConfig };
+export { assertRollupInput };
+export { analyzeClientEntries };
+import type { ResolvedConfig, Plugin } from 'vite';
+import type { PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
+declare function buildConfig(): Plugin;
+declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config: ResolvedConfig): {
+    hasClientRouting: boolean;
+    hasServerRouting: boolean;
+    clientEntries: Record<string, string>;
+};
+declare function assertRollupInput(config: ResolvedConfig): void;

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -0,0 +1,246 @@
+export { buildConfig };
+export { assertRollupInput };
+export { analyzeClientEntries };
+import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage } from '../utils.js';
+import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
+import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { getConfigValue } from '../../../shared/page-configs/utils.js';
+import { findPageFiles } from '../shared/findPageFiles.js';
+import { getConfigVike } from '../../shared/getConfigVike.js';
+import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
+import { createRequire } from 'module';
+import { getClientEntryFilePath } from '../../shared/getClientEntryFilePath.js';
+import fs from 'fs/promises';
+import path from 'path';
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+const manifestTempFile = '_temp_manifest.json';
+function buildConfig() {
+    let generateManifest;
+    return {
+        name: 'vike:buildConfig',
+        apply: 'build',
+        enforce: 'post',
+        configResolved: {
+            order: 'post',
+            async handler(config) {
+                assertRollupInput(config);
+                const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
+                const entries = await getEntries(config);
+                assert(Object.keys(entries).length > 0);
+                const input = {
+                    ...entries,
+                    ...userInputs
+                };
+                config.build.rollupOptions.input = input;
+                addLogHook();
+            }
+        },
+        config(config) {
+            generateManifest = !viteIsSSR(config);
+            return {
+                build: {
+                    outDir: resolveOutDir(config),
+                    manifest: generateManifest ? manifestTempFile : false,
+                    copyPublicDir: !viteIsSSR(config)
+                }
+            };
+        },
+        async writeBundle(options, bundle) {
+            const manifestEntry = bundle[manifestTempFile];
+            if (generateManifest) {
+                assert(manifestEntry);
+                const { dir } = options;
+                assert(dir);
+                const manifestFilePathOld = path.join(dir, manifestEntry.fileName);
+                // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
+                //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
+                //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
+                const manifestFilePathNew = path.join(dir, '..', 'assets.json');
+                await fs.rename(manifestFilePathOld, manifestFilePathNew);
+            }
+            else {
+                assert(!manifestEntry);
+            }
+        }
+    };
+}
+async function getEntries(config) {
+    const configVike = await getConfigVike(config);
+    const pageFileEntries = await getPageFileEntries(config, configVike.includeAssetsImportedByServer); // TODO/v1-release: remove
+    const { pageConfigs } = await getVikeConfig(config.root, false, configVike.extensions);
+    assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
+    if (viteIsSSR(config)) {
+        const serverEntries = analyzeServerEntries(pageConfigs);
+        const entries = {
+            pageFiles: virtualFileIdImportUserCodeServer,
+            importBuild: resolve('dist/esm/node/importBuild.js'),
+            ...pageFileEntries,
+            ...serverEntries
+        };
+        return entries;
+    }
+    else {
+        let { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
+        if (Object.entries(pageFileEntries).length > 0) {
+            hasClientRouting = true;
+            hasServerRouting = true;
+        }
+        const entries = {
+            ...clientEntries,
+            ...pageFileEntries
+        };
+        const clientRoutingEntry = resolve(`dist/esm/client/client-routing-runtime/entry.js`);
+        const serverRoutingEntry = resolve(`dist/esm/client/server-routing-runtime/entry.js`);
+        if (hasClientRouting) {
+            entries['entries/entry-client-routing'] = clientRoutingEntry;
+        }
+        if (hasServerRouting) {
+            entries['entries/entry-server-routing'] = serverRoutingEntry;
+        }
+        return entries;
+    }
+}
+function analyzeClientEntries(pageConfigs, config) {
+    let hasClientRouting = false;
+    let hasServerRouting = false;
+    let clientEntries = {};
+    let clientFilePaths = [];
+    pageConfigs.forEach((pageConfig) => {
+        const configValue = getConfigValue(pageConfig, 'clientRouting', 'boolean');
+        if (configValue?.value) {
+            hasClientRouting = true;
+        }
+        else {
+            hasServerRouting = true;
+        }
+        {
+            const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, true);
+            clientEntries[entryName] = entryTarget;
+        }
+        {
+            const clientFilePath = getClientEntryFilePath(pageConfig);
+            if (clientFilePath) {
+                clientFilePaths.push(clientFilePath);
+            }
+        }
+    });
+    clientFilePaths = unique(clientFilePaths);
+    clientFilePaths.forEach((pageFile) => {
+        const { entryName, entryTarget } = getEntryFromFilePath(pageFile, config);
+        clientEntries[entryName] = entryTarget;
+    });
+    return { hasClientRouting, hasServerRouting, clientEntries };
+}
+function analyzeServerEntries(pageConfigs) {
+    const serverEntries = {};
+    pageConfigs.forEach((pageConfig) => {
+        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
+        serverEntries[entryName] = entryTarget;
+    });
+    return serverEntries;
+}
+// Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
+// (Otherwise the page files may be missing in the client manifest.json)
+async function getPageFileEntries(config, includeAssetsImportedByServer) {
+    const isForClientSide = !viteIsSSR(config);
+    const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
+    if (isForClientSide && includeAssetsImportedByServer) {
+        fileTypes.push('.page.server');
+    }
+    let pageFiles = await findPageFiles(config, fileTypes, false);
+    const pageFileEntries = {};
+    pageFiles = unique(pageFiles);
+    pageFiles.forEach((pageFile) => {
+        let addExtractAssetsQuery = false;
+        if (isForClientSide && pageFile.includes('.page.server.')) {
+            assert(includeAssetsImportedByServer);
+            addExtractAssetsQuery = true;
+        }
+        const { entryName, entryTarget } = getEntryFromFilePath(pageFile, config, addExtractAssetsQuery);
+        pageFileEntries[entryName] = entryTarget;
+    });
+    return pageFileEntries;
+}
+function getEntryFromFilePath(filePath, config, addExtractAssetsQuery) {
+    assertPosixPath(filePath);
+    assert(filePath.startsWith('/'));
+    let entryTarget = getFilePathAbsolute(filePath, config);
+    if (addExtractAssetsQuery)
+        entryTarget = extractAssetsAddQuery(entryTarget);
+    let entryName = filePath;
+    if (addExtractAssetsQuery)
+        entryName = extractAssetsAddQuery(entryName);
+    entryName = removeFileExtention(entryName);
+    entryName = prependEntriesDir(entryName);
+    return { entryName, entryTarget };
+}
+function getEntryFromPageConfig(pageConfig, isForClientSide) {
+    let { pageId } = pageConfig;
+    const entryTarget = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
+    let entryName = pageId;
+    entryName = prependEntriesDir(entryName);
+    return { entryName, entryTarget };
+}
+function prependEntriesDir(entryName) {
+    if (entryName.startsWith('/')) {
+        entryName = entryName.slice(1);
+    }
+    assert(!entryName.startsWith('/'));
+    entryName = `entries/${entryName}`;
+    return entryName;
+}
+function resolve(filePath) {
+    assert(filePath.startsWith('dist/'));
+    // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/
+    return require_.resolve(`../../../../../${filePath}`);
+}
+function normalizeRollupInput(input) {
+    if (!input) {
+        return {};
+    }
+    // Usually `input` is an oject, but the user can set it as a `string` or `string[]`
+    if (typeof input === 'string') {
+        input = [input];
+    }
+    if (Array.isArray(input)) {
+        return Object.fromEntries(input.map((input) => [input, input]));
+    }
+    assert(isObject(input));
+    return input;
+}
+function addLogHook() {
+    const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27
+    if (!tty)
+        return;
+    let lastLog = null;
+    ['stdout', 'stderr'].forEach((stdName) => {
+        var methodOriginal = process[stdName].write;
+        process[stdName].write = function (...args) {
+            lastLog = String(args[0]);
+            return methodOriginal.apply(process[stdName], args);
+        };
+    });
+    // Exhaustive list extracted from writeLine() calls at https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts
+    // prettier-ignore
+    const viteTransientLogs = [
+        'transforming (',
+        'rendering chunks (',
+        'computing gzip size ('
+    ];
+    addOnBeforeLogHook(() => {
+        // Using viteTransientLogs is very conservative as clearing the current line is low risk. (We can assume that important messages, such as errors, include a trailing new line. Usually, only transient messages have no trailing new lines.)
+        if (viteTransientLogs.some((s) => lastLog?.startsWith(s))) {
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+        }
+    });
+}
+function assertRollupInput(config) {
+    const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
+    const htmlInputs = Object.values(userInputs).filter((entry) => entry.endsWith('.html') || entry.endsWith('.htm'));
+    const htmlInput = htmlInputs[0];
+    assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using vike, instead follow https://vike.dev/add`);
+}

package/dist/esm/node/plugin/plugins/commonConfig/assertResolveAlias.d.ts

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