vike 0.4.267 → 0.4.268-commit-ca58695

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

@@ -6,11 +6,13 @@ import { pluginServerEntryInject } from './pluginUniversalDeploy/pluginServerEnt
 import { getDeployConfig } from './pluginUniversalDeploy/getDeployConfig.js';
 import { pluginCommon } from './pluginUniversalDeploy/common.js';
 import { hasVikeServerOrVikePhoton } from './pluginUniversalDeploy/detectDeprecated.js';
-import { getServerConfig } from './pluginUniversalDeploy/getServerConfig.js';
+import { getServerConfig, getServerEntryFilePath_ifDev } from './pluginUniversalDeploy/getServerConfig.js';
 import { pluginServerEntryAlias } from './pluginUniversalDeploy/pluginServerEntryAlias.js';
-import { pluginUnwrapProdOptions } from './pluginUniversalDeploy/pluginUnwrapProdOptions.js';
+import { pluginWrapServerFile } from './pluginUniversalDeploy/pluginWrapServerFile.js';
+import { getViteCliCommand } from '../shared/isViteCli.js';
 import { unique } from '../../../utils/unique.js';
 import { assertUsage } from '../../../utils/assert.js';
+import pc from '@brillout/picocolors';
 import '../assertEnvVite.js';
 function pluginUniversalDeploy(vikeConfig) {
     if (hasVikeServerOrVikePhoton(vikeConfig))
@@ -25,9 +27,31 @@ function pluginUniversalDeploy(vikeConfig) {
             }),
             precompress(vikeConfig.config.precompress),
         ];
-    const { serverEntryVike, serverEntryId, serverFilePath } = serverConfig;
+    const { serverEntryVike, serverEntryId, serverFilePath, serverEntryFilePath } = serverConfig;
+    const isServerEntryDev = !!getServerEntryFilePath_ifDev(vikeConfig);
+    // Vite's CLI always starts Vite's own server => it can't run +serverEntry.js
+    assertUsage(!(isServerEntryDev && getViteCliCommand() === 'dev'), `${pc.cyan('+serverEntry.js')} (without ${pc.cyan('+server.js')}) requires ${pc.cyan('$ vike dev')} instead of ${pc.cyan('$ vite dev')} (because Vite's CLI always starts Vite's own server)`);
     return [
-        ...universalDeploy({ node: { precompress: vikeConfig.config.precompress } }),
+        ...(!serverEntryFilePath
+            ? universalDeploy({ node: { precompress: vikeConfig.config.precompress } })
+            : [
+                // +serverEntry.js is the production server entry dist/server/index.mjs (instead of @universal-deploy/node's server)
+                // https://vike.dev/serverEntry
+                ...universalDeploy({
+                    entry: {
+                        id: serverEntryFilePath,
+                        // Without +server.js, +serverEntry.js handles requests itself (it calls renderPage() instead of using vike:server) and `$ vike dev` runs it
+                        catchAll: !isServerEntryDev,
+                    },
+                }),
+                precompress(vikeConfig.config.precompress),
+                resolveTargets((targets) => {
+                    const target = targets[0];
+                    assertUsage(target === undefined, `+serverEntry cannot be used with ${target} (because it uses its own server entry)`);
+                }),
+                // dist/server/index.mjs loads dist/server/entry.mjs
+                pluginServerEntryInject(serverEntryFilePath),
+            ]),
         {
             name: 'vike:pluginUniversalDeploy:entries',
             config() {
@@ -55,6 +79,6 @@ function pluginUniversalDeploy(vikeConfig) {
         },
         pluginServerEntryInject(serverFilePath ?? serverEntryId),
         pluginServerEntryAlias(serverFilePath),
-        !serverFilePath ? null : pluginUnwrapProdOptions(serverFilePath),
+        !serverFilePath ? null : pluginWrapServerFile(serverFilePath),
     ].filter((p) => p !== null);
 }

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntry.d.ts

@@ -1,3 +1,4 @@
 export { generateVirtualFileGlobalEntry };
+import type { RuntimeEnvRuntime } from './getConfigValueSourcesRelevant.js';
 import '../../assertEnvVite.js';
-declare function generateVirtualFileGlobalEntry(isForClientSide: boolean, isDev: boolean, id: string, isClientRouting: boolean): Promise<string>;
+declare function generateVirtualFileGlobalEntry(runtimeEnv: RuntimeEnvRuntime, id: string): Promise<string>;

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntry.js

@@ -4,25 +4,31 @@ import { debug } from './debug.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { serializeConfigValues, } from '../../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
 import { VIRTUAL_FILE_ID_constantsGlobalThis } from '../pluginReplaceConstantsGlobalThis.js';
+import { getEnvironmentEntryPlaceholder } from '../build/pluginEnvironmentEntries.js';
 import '../../assertEnvVite.js';
-async function generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting) {
+async function generateVirtualFileGlobalEntry(runtimeEnv, id) {
     const vikeConfig = await getVikeConfigInternal(true);
-    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
-    return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
+    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal, _additionalEnvironmentNames: additionalEnvironmentNames, } = vikeConfig;
+    return getCode(pageConfigs, pageConfigGlobal, runtimeEnv, id, additionalEnvironmentNames);
 }
-function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
+function getCode(pageConfigs, pageConfigGlobal, runtimeEnv, id, additionalEnvironmentNames) {
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
+    const { environmentName, isDev } = runtimeEnv;
+    const isForClientSide = environmentName === 'client';
     if (!isForClientSide) {
         importStatements.push(`import '${VIRTUAL_FILE_ID_constantsGlobalThis}';`);
     }
     lines.push('export const pageConfigsSerialized = [');
-    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
+    lines.push(getCodePageConfigsSerialized(pageConfigs, runtimeEnv, importStatements, filesEnv));
     lines.push('];');
     lines.push('export const pageConfigGlobalSerialized = {');
-    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
+    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, runtimeEnv, importStatements, filesEnv));
     lines.push('};');
+    if (environmentName === 'server') {
+        lines.push(getCodeEnvironmentEntries(additionalEnvironmentNames, isDev, importStatements));
+    }
     if (!isForClientSide && isDev) {
         // https://vite.dev/guide/api-environment-frameworks.html
         lines.push('if (import.meta.hot) import.meta.hot.accept();');
@@ -31,10 +37,21 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     if (!isForClientSide) {
         code = `import '${VIRTUAL_FILE_ID_constantsGlobalThis}';\n` + code;
     }
-    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    debug(id, `${environmentName.toUpperCase()}-SIDE`, code);
     return code;
 }
-function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
+// The global entries of the additional environments (e.g. `rsc`), loaded by loadPageContextEnvironments.ts
+// - In development, they're loaded with the environment's module runner instead
+function getCodeEnvironmentEntries(additionalEnvironmentNames, isDev, importStatements) {
+    const entries = additionalEnvironmentNames.map((name, i) => {
+        if (isDev)
+            return `${JSON.stringify(name)}: null`;
+        importStatements.push(`import * as environmentEntry${i} from ${JSON.stringify(getEnvironmentEntryPlaceholder(name))};`);
+        return `${JSON.stringify(name)}: environmentEntry${i}`;
+    });
+    return `export const environmentEntries = { ${entries.join(', ')} };`;
+}
+function getCodePageConfigsSerialized(pageConfigs, runtimeEnv, importStatements, filesEnv) {
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
@@ -42,20 +59,20 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide }));
+        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, environmentName: runtimeEnv.environmentName }));
         lines.push(`    loadVirtualFilePageEntry: () => ({ moduleId: ${virtualFileId}, moduleExportsPromise: import(${virtualFileId}) }),`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', true));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, runtimeEnv, '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
     const code = lines.join('\n');
     return code;
 }
-function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
+function getCodePageConfigGlobalSerialized(pageConfigGlobal, runtimeEnv, importStatements, filesEnv) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', null));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, runtimeEnv, '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js

@@ -18,7 +18,8 @@ import '../../assertEnvVite.js';
 async function generateVirtualFileGlobalEntryWithOldDesign(id, options, config, env, isDev) {
     const idParsed = parseVirtualFileId(id);
     assert(idParsed && idParsed.type === 'global-entry');
-    const { isForClientSide, isClientRouting } = idParsed;
+    const { environmentName, isClientRouting } = idParsed;
+    const isForClientSide = environmentName === 'client';
     assert(isForClientSide === !isViteServerSide_extraSafe(config, env, options));
     const code = await getCode(config, isForClientSide, isClientRouting, isDev, id);
     return code;
@@ -75,7 +76,7 @@ export const pageFilesExportNamesEager = {};
 export const pageFilesList = [];
 export const neverLoaded = {};
 
-${await generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting)}
+${await generateVirtualFileGlobalEntry({ environmentName: isForClientSide ? 'client' : 'server', isClientRouting, isDev }, id)}
 
 `;
     const vikeConfig = await getVikeConfigInternal();

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFilePageEntry.js

@@ -18,7 +18,7 @@ async function generateVirtualFilePageEntry(id, isDev) {
       assert(result.isForClientSide === isForClientSide)
     }
     */
-    const { pageId, isForClientSide } = result;
+    const { pageId, environmentName } = result;
     const vikeConfig = await getVikeConfigInternal(true);
     const { _pageConfigs: pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
@@ -31,20 +31,20 @@ async function generateVirtualFilePageEntry(id, isDev) {
             throw getProjectError(`Outdated request. Try again. ${getDebugInfoStr({ id, pageId })}`);
         }
     }
-    const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
-    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    const code = getCode(pageConfig, environmentName, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
+    debug(id, `${environmentName.toUpperCase()}-SIDE`, code);
     return code;
 }
-function getCode(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
+function getCode(pageConfig, environmentName, pageId, includeAssetsImportedByServer, isDev) {
     const lines = [];
     const importStatements = [];
     const filesEnv = new Map();
     const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '', false));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { environmentName, isClientRouting, isDev }, '', false));
     lines.push('};');
-    if (!handleAssetsManifest_isFixEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
-        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide: false }))}'`);
+    if (!handleAssetsManifest_isFixEnabled() && includeAssetsImportedByServer && environmentName === 'client' && !isDev) {
+        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, environmentName: 'server' }))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');
     return code;

package/dist/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.d.ts

@@ -3,14 +3,18 @@ export { getConfigValueSourceRelevantAnyEnv };
 export { isRuntimeEnvMatch };
 export { isConfigSourceValueNull };
 export type { RuntimeEnv };
+export type { RuntimeEnvRuntime };
 import type { ConfigEnv, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
 import '../../assertEnvVite.js';
-type RuntimeEnv = {
-    isForClientSide: boolean;
-    isClientRouting: boolean;
-    isDev?: boolean;
-} | {
-    isForConfig: true;
+type RuntimeEnv = (RuntimeEnvRuntime & {
+    isConfigEnvironment?: undefined;
+}) | {
+    isConfigEnvironment: true;
+};
+type RuntimeEnvRuntime = {
+    environmentName: string;
+    isClientRouting?: boolean;
+    isDev: boolean;
 };
 type PageConfigPartial = Pick<PageConfigBuildTime | PageConfigGlobalBuildTime, 'configValueSources' | 'configDefinitions'>;
 declare function getConfigValueSourcesRelevant(configName: string, runtimeEnv: RuntimeEnv, pageConfig: PageConfigPartial): ConfigValueSource[];

package/dist/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js

@@ -44,19 +44,13 @@ function getConfigValueSourceRelevantAnyEnv(configName, pageConfig) {
     return source;
 }
 function isRuntimeEnvMatch(configEnv, runtimeEnv) {
-    if ('isForConfig' in runtimeEnv)
+    if (runtimeEnv.isConfigEnvironment)
         return !!configEnv.config;
     // Runtime
-    if (!runtimeEnv.isForClientSide) {
-        if (!configEnv.server)
-            return false;
-    }
-    else {
-        if (!configEnv.client)
-            return false;
-        if (configEnv.client === 'if-client-routing' && !runtimeEnv.isClientRouting)
-            return false;
-    }
+    if (!configEnv[runtimeEnv.environmentName])
+        return false;
+    if (runtimeEnv.environmentName === 'client' && configEnv.clientRoutingOnly && !runtimeEnv.isClientRouting)
+        return false;
     // Production/development
     if (configEnv.production !== undefined) {
         assert(typeof configEnv.production === 'boolean');

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

@@ -2,6 +2,7 @@ export { pluginVirtualFiles };
 import { normalizePath } from 'vite';
 import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
 import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
+import { generateVirtualFileGlobalEntry } from './pluginVirtualFiles/generateVirtualFileGlobalEntry.js';
 import { escapeRegex } from '../../../utils/escapeRegex.js';
 import { isScriptFile } from '../../../utils/isScriptFile.js';
 import { addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, virtualFileIdPrefix1, virtualFileIdPrefix2, } from '../../../utils/virtualFileId.js';
@@ -9,6 +10,8 @@ import { assert } from '../../../utils/assert.js';
 import { assertPosixPath } from '../../../utils/path.js';
 import { parseVirtualFileId } from '../../../shared-server-node/virtualFileId.js';
 import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
+import { isEnvironmentBuiltIn } from '../../../shared-server-node/vike-environments.js';
+import { isRunnableDevEnvironment } from '../../../utils/isRunnableDevEnvironment.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo } from '../shared/loggerDev.js';
 import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
@@ -73,6 +76,9 @@ function pluginVirtualFiles() {
                             return code;
                         }
                         if (idParsed.type === 'global-entry') {
+                            if (!isEnvironmentBuiltIn(idParsed.environmentName)) {
+                                return generateVirtualFileGlobalEntry({ environmentName: idParsed.environmentName, isDev }, id);
+                            }
                             const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
                             return code;
                         }
@@ -179,6 +185,20 @@ function invalidateVikeVirtualFiles(server) {
     vikeVirtualFiles.forEach((mod) => {
         server.moduleGraph.invalidateModule(mod);
     });
+    // - `server.moduleGraph` only covers the `client` and `ssr` environments, while additional environments (e.g. `rsc`) also load Vike's virtual files
+    Object.values(server.environments).forEach((environment) => {
+        environment.moduleGraph.idToModuleMap.forEach((mod, id) => {
+            if (parseVirtualFileId(id))
+                environment.moduleGraph.invalidateModule(mod);
+        });
+        if (!isRunnableDevEnvironment(environment))
+            return;
+        const { evaluatedModules } = environment.runner;
+        evaluatedModules.idToModuleMap.forEach((mod, id) => {
+            if (parseVirtualFileId(id))
+                evaluatedModules.invalidateModule(mod);
+        });
+    });
 }
 function getVikeVirtualFiles(server) {
     const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())

package/dist/node/vite/shared/addSsrMiddleware.js

@@ -1,8 +1,10 @@
 export { addSsrMiddleware };
-import { renderPageServer } from '../../../server/runtime/renderPageServer.js';
-import { assertWarning } from '../../../utils/assert.js';
-import pc from '@brillout/picocolors';
+import { vikeUniversalMiddleware } from '../../../server/runtime/universal-middleware/vikeUniversalMiddleware.js';
+import { getAdapterRuntime } from '@universal-middleware/core';
+import { createRequestAdapter } from '@universal-middleware/node/request';
+import { sendResponse } from '@universal-middleware/node/response';
 import '../assertEnvVite.js';
+const requestAdapter = createRequestAdapter();
 function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled) {
     middlewares.use(async (req, res, next) => {
         if (res.headersSent)
@@ -10,26 +12,11 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
         const url = req.originalUrl || req.url;
         if (!url)
             return next();
-        const { headers } = req;
-        const pageContextInit = {
-            urlOriginal: url,
-            headersOriginal: headers,
-            _nodeDev: { req, res },
-        };
-        Object.defineProperty(pageContextInit, 'userAgent', {
-            get() {
-                // TO-DO/next-major-release: assertUsage() instead of assertWarning()
-                assertWarning(false, `${pc.cyan('pageContext.userAgent')} is deprecated: use ${pc.cyan("pageContext.headers['user-agent']")} instead.`, {
-                    showStackTrace: true,
-                    onlyOnce: true,
-                });
-                return headers['user-agent'];
-            },
-            enumerable: false,
-        });
-        let pageContext;
+        let response;
         try {
-            pageContext = await renderPageServer(pageContextInit);
+            const runtime = Object.assign(getAdapterRuntime('other', { params: undefined }), { req, res });
+            const context = { urlOriginal: url };
+            response = await vikeUniversalMiddleware(requestAdapter(req, res), context, runtime);
         }
         catch (err) {
             // Throwing an error in a connect middleware shuts down the server
@@ -39,7 +26,7 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
             // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
             return next();
         }
-        if (pageContext.httpResponse.statusCode === 404 && isPreview && isPrerenderingEnabled) {
+        if (response.status === 404 && isPreview && isPrerenderingEnabled) {
             // Serve /dist/client/404.html instead
             return next();
         }
@@ -49,9 +36,6 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
                 if (value)
                     res.setHeader(name, value);
         }
-        const { httpResponse } = pageContext;
-        httpResponse.headers.forEach(([name, value]) => res.setHeader(name, value));
-        res.statusCode = httpResponse.statusCode;
-        httpResponse.pipe(res);
+        await sendResponse(response, res);
     });
 }

package/dist/node/vite/shared/findPageFiles.d.ts

@@ -2,4 +2,4 @@ export { findPageFiles };
 import type { ResolvedConfig } from 'vite';
 import type { FileType } from '../../../shared-server-client/getPageFiles/fileTypes.js';
 import '../assertEnvVite.js';
-declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[], isDev: boolean): Promise<string[]>;
+declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[]): Promise<string[]>;

package/dist/node/vite/shared/findPageFiles.js

@@ -2,22 +2,12 @@ export { findPageFiles };
 import { glob } from 'tinyglobby';
 import { scriptFileExtensionPattern } from '../../../utils/isScriptFile.js';
 import { toPosixPath } from '../../../utils/path.js';
-import { assertWarning } from '../../../utils/assert.js';
-import pc from '@brillout/picocolors';
 import { getOutDirs } from './getOutDirs.js';
 import '../assertEnvVite.js';
-async function findPageFiles(config, fileTypes, isDev) {
+async function findPageFiles(config, fileTypes) {
     const cwd = config.root;
     const { outDirRoot } = getOutDirs(config, undefined);
-    const timeBase = new Date().getTime();
     let pageFiles = await glob(fileTypes.map((fileType) => `**/*${fileType}.${scriptFileExtensionPattern}`), { ignore: ['**/node_modules/**', `${outDirRoot}/**`], cwd, dot: false, expandDirectories: false });
     pageFiles = pageFiles.map((p) => '/' + toPosixPath(p));
-    const time = new Date().getTime() - timeBase;
-    if (isDev) {
-        // We only warn in dev, because while building it's expected to take a long time as tinyglobby is competing for resources with other tasks
-        assertWarning(time < 1.5 * 1000, `Finding your page files ${pc.cyan('**/*.page.*')} took an unexpected long time (${time}ms). Reach out to the vike maintainer.`, {
-            onlyOnce: 'slow-page-files-search',
-        });
-    }
     return pageFiles;
 }

package/dist/node/vite/shared/getAssetsDir.d.ts

@@ -1,4 +1,5 @@
 export { getAssetsDir };
-import type { ResolvedConfig } from 'vite';
 import '../assertEnvVite.js';
-declare function getAssetsDir(config: ResolvedConfig): string;
+declare function getAssetsDir(build: {
+    assetsDir: string;
+}): string;

package/dist/node/vite/shared/getAssetsDir.js

@@ -1,9 +1,9 @@
 export { getAssetsDir };
 import { assertUsage } from '../../../utils/assert.js';
 import '../assertEnvVite.js';
-function getAssetsDir(config) {
-    let { assetsDir } = config.build;
-    assertUsage(assetsDir, `${assetsDir} cannot be an empty string`);
+function getAssetsDir(build) {
+    let { assetsDir } = build;
+    assertUsage(assetsDir, "Vite's build.assetsDir cannot be an empty string");
     assetsDir = assetsDir.split(/\/|\\/).filter(Boolean).join('/');
     return assetsDir;
 }

package/dist/node/vite/shared/isViteCli.d.ts

@@ -1,6 +1,6 @@
 export { isViteCli };
 export { getViteCliArgs };
-export { getViteBuildCliArgs };
+export { getViteCliArgsMinimal };
 export { getViteCliCommand };
 import '../assertEnvVite.js';
 declare function isViteCli(): boolean;
@@ -12,8 +12,8 @@ type ConfigFromCli = {
 };
 type ViteCommand = 'dev' | 'build' | 'optimize' | 'preview';
 declare function getViteCliCommand(): ViteCommand | null;
-declare function getViteBuildCliArgs(): null | ConfigFromCli;
-declare function getViteCliArgs(): null | {
+declare function getViteCliArgsMinimal(): null | {
     root: string | undefined;
     configFile: string | undefined;
 };
+declare function getViteCliArgs(): null | ConfigFromCli;