vike 0.4.220 → 0.4.221-commit-ab9e52a

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{debug.js → virtual-files/debug.js}

@@ -1,2 +1,2 @@
-import { createDebugger } from '../../../utils.js';
+import { createDebugger } from '../../../../utils.js';
 export const debug = createDebugger('vike:virtual-files');

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{getVirtualFilePageConfigValuesAll.js → virtual-files/getVirtualFilePageConfigValuesAll.js}

@@ -1,13 +1,13 @@
 export { getVirtualFilePageConfigValuesAll };
-import { assert } from '../../../utils.js';
-import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
-import { getVikeConfig } from './getVikeConfig.js';
-import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
+import { assert } from '../../../../utils.js';
+import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll } from '../../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { getVikeConfig } from '../getVikeConfig.js';
+import { extractAssetsAddQuery } from '../../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { fixServerAssets_isEnabled } from '../../buildConfig/fixServerAssets.js';
-import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
+import { serializeConfigValues } from '../../../../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { fixServerAssets_isEnabled } from '../../../buildConfig/fixServerAssets.js';
+import { getConfigValueBuildTime } from '../../../../../../shared/page-configs/getConfigValueBuildTime.js';
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
     assert(result);
@@ -22,16 +22,19 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const { pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig, { id, pageId });
-    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer, isDev);
+    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, 
+    // TODO/now: add meta.default
+    vikeConfig.global.config.includeAssetsImportedByServer ?? true, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
 function getLoadConfigValuesAll(pageConfig, isForClientSide, 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, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '', false));
+    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '', false));
     lines.push('};');
     if (!fixServerAssets_isEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{getVirtualFilePageConfigs.js → virtual-files/getVirtualFilePageConfigs.js}

@@ -1,9 +1,9 @@
 export { getVirtualFilePageConfigs };
-import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { getVirtualFileIdPageConfigValuesAll } from '../../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
-import { getVikeConfig } from './getVikeConfig.js';
+import { getVikeConfig } from '../getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
+import { serializeConfigValues } from '../../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
     const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
     const { pageConfigs, pageConfigGlobal } = vikeConfig;
@@ -12,38 +12,40 @@ async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRou
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
     const lines = [];
     const importStatements = [];
+    const filesEnv = new Map();
     lines.push('export const pageConfigsSerialized = [');
-    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements));
+    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
     lines.push('];');
     lines.push('export const pageConfigGlobalSerialized = {');
-    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements));
+    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
     lines.push('};');
     const code = [...importStatements, ...lines].join('\n');
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements) {
+function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
     const lines = [];
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
-        const virtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
         lines.push(`  {`);
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
+        const virtualFileId = JSON.stringify(getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide));
+        const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
+        lines.push(`    loadConfigValuesAll: ${load},`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...serializeConfigValues(pageConfig, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
+        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
     const code = lines.join('\n');
     return code;
 }
-function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements) {
+function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', null));
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/{isRuntimeEnvMatch.d.ts → virtual-files/isRuntimeEnvMatch.d.ts}

@@ -1,5 +1,5 @@
 export { isRuntimeEnvMatch };
-import type { ConfigEnvInternal } from '../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal } from '../../../../../../shared/page-configs/PageConfig.js';
 declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtime: {
     isForClientSide: boolean;
     isClientRouting: boolean;

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

@@ -8,7 +8,7 @@
  */
 export { packageJsonFile };
 import { rollupIsEsm } from '../shared/rollupIsEsm.js';
-import { viteIsSSR } from '../utils.js';
+import { viteIsSSR } from '../shared/viteIsSSR.js';
 function packageJsonFile() {
     let config;
     return {

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

@@ -1,13 +1,14 @@
 export { previewConfig };
-import { assertUsage, getOutDirs, resolveOutDir, applyPreview } from '../utils.js';
+import { assertUsage, applyPreview } from '../utils.js';
 import fs from 'fs';
 import path from 'path';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import pc from '@brillout/picocolors';
 import { logDockerHint } from './devConfig/index.js';
+import { getOutDirs, resolveOutDir } from '../shared/getOutDirs.js';
 function previewConfig() {
     let config;
-    // let vikeConfigGlobal: VikeConfigGlobal
+    // let vikeConfig: VikeConfigObject
     return {
         name: 'vike:previewConfig',
         apply: applyPreview,
@@ -22,8 +23,7 @@ function previewConfig() {
         async configResolved(config_) {
             config = config_;
             logDockerHint(config.preview.host);
-            // const vikeConfig = await getVikeConfig(config)
-            // vikeConfigGlobal = vikeConfig.vikeConfigGlobal
+            // vikeConfig = await getVikeConfig(config)
         },
         configurePreviewServer(server) {
             /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
@@ -33,7 +33,7 @@ function previewConfig() {
             return () => {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
-                if (!vikeConfigGlobal.prerender || vikeConfigGlobal.prerender.partial) {
+                if (!vikeConfig.global.config.prerender || vikeConfig.global.config.prerender.partial) {
                   addSsrMiddleware(server.middlewares, config, true)
                 }
                 /*/

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

@@ -1,7 +1,7 @@
 export { setGlobalContext };
-import { setGlobalContext_isViteDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_vikeConfig } from '../../runtime/globalContext.js';
-import { assertFilePathAbsoluteFilesystem, getOutDirs, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProduction } from '../../runtime/globalContext.js';
+import { assertFilePathAbsoluteFilesystem, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
+import { getOutDirs } from '../shared/getOutDirs.js';
 function setGlobalContext() {
     return [
         {
@@ -21,7 +21,7 @@ function setGlobalContext() {
                 order: 'pre',
                 handler(_, env) {
                     const isViteDev = isDevCheck(env);
-                    setGlobalContext_isViteDev(isViteDev);
+                    setGlobalContext_isProduction(!isViteDev);
                     markSetup_isViteDev(isViteDev);
                 }
             }
@@ -35,8 +35,6 @@ function setGlobalContext() {
                     const { outDirRoot } = getOutDirs(config);
                     assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for `importServerProductionEntry({ outDir })` of @brillout/vite-plugin-server-entry
                     setGlobalContext_viteConfig(config, outDirRoot);
-                    const vikeConfig = await getVikeConfig(config);
-                    setGlobalContext_vikeConfig(vikeConfig);
                 }
             }
         }

package/dist/esm/node/plugin/shared/findPageFiles.js

@@ -1,7 +1,8 @@
 export { findPageFiles };
 import glob from 'fast-glob';
-import { assertWarning, toPosixPath, scriptFileExtensions, getOutDirs } from '../utils.js';
+import { assertWarning, toPosixPath, scriptFileExtensions } from '../utils.js';
 import pc from '@brillout/picocolors';
+import { getOutDirs } from './getOutDirs.js';
 async function findPageFiles(config, fileTypes, isDev) {
     const cwd = config.root;
     const { outDirRoot } = getOutDirs(config);

package/dist/esm/node/plugin/shared/getFullBuildInlineConfig.d.ts

@@ -0,0 +1,2 @@
+import type { InlineConfig, ResolvedConfig } from 'vite';
+export declare function getFullBuildInlineConfig(config: ResolvedConfig): InlineConfig;

package/dist/esm/node/plugin/shared/getFullBuildInlineConfig.js

@@ -0,0 +1,17 @@
+import { getViteConfigFromCli, isViteCliCall } from './isViteCliCall.js';
+export function getFullBuildInlineConfig(config) {
+    const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
+    if (config._viteConfigEnhanced) {
+        return config._viteConfigEnhanced;
+    }
+    else {
+        return {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
+            build: {
+                ...configFromCli?.build
+            }
+        };
+    }
+}

package/dist/esm/{utils → node/plugin/shared}/getOutDirs.d.ts

@@ -12,4 +12,4 @@ type OutDirs = {
 };
 declare function getOutDirs(config: ResolvedConfig): OutDirs;
 /** Appends `client/` or `server/` to `config.build.outDir` */
-declare function resolveOutDir(config: UserConfig): string;
+declare function resolveOutDir(config: UserConfig, isSSR?: true): string;

package/dist/esm/{utils → node/plugin/shared}/getOutDirs.js

@@ -1,57 +1,39 @@
 export { getOutDirs };
 export { resolveOutDir };
-import { viteIsSSR } from './viteIsSSR.js';
-import { assert, assertUsage } from './assert.js';
-import { pathJoin } from './path-shim.js';
-import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
 import pc from '@brillout/picocolors';
-import { createDebugger } from './debug.js';
+import { assert, assertPosixPath, assertUsage, createDebugger, pathJoin, toPosixPath } from '../utils.js';
+import { viteIsSSR } from './viteIsSSR.js';
 const debug = createDebugger('vike:outDir');
 function getOutDirs(config) {
     debug('getOutDirs()', new Error().stack);
-    let outDirRoot;
-    {
-        const outDir = getOutDirFromViteResolvedConfig(config);
-        if (isOutDirRoot(outDir)) {
-            outDirRoot = outDir;
-        }
-        else {
-            assertOutDirResolved(outDir, config);
-            assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
-            assert('/client'.length === '/server'.length);
-            outDirRoot = outDir.slice(0, -1 * '/client'.length);
-        }
-    }
-    const outDirs = getOutDirsAll(outDirRoot, config.root);
-    debug('outDirRoot', outDirRoot);
-    debug('outDirs', outDirs);
+    const outDir = getOutDirFromViteResolvedConfig(config);
+    if (!isOutDirRoot(outDir))
+        assertOutDirResolved(outDir, config);
+    const outDirs = getOutDirsAll(outDir, config.root);
     return outDirs;
 }
 /** Appends `client/` or `server/` to `config.build.outDir` */
-function resolveOutDir(config) {
+function resolveOutDir(config, isSSR) {
     debug('resolveOutDir()', new Error().stack);
+    const isServerSide = viteIsSSR(config) || isSSR;
+    debug('isServerSide', isServerSide);
     const outDir = getOutDirFromViteUserConfig(config) || 'dist';
-    debug('outDir', 'outDir');
-    // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
-    if (!isOutDirRoot(outDir)) {
-        assertOutDirResolved(outDir, config);
-        return outDir;
+    debug('outDir', outDir);
+    /* outDir may already be resolved when using Telefunc + Vike (because both Telefunc and Vike use this logic)
+    assert(isOutDirRoot(outDir))
+    */
+    const { outDirClient, outDirServer } = getOutDirsAll(outDir);
+    if (isServerSide) {
+        debug('outDirServer', 'outDirServer');
+        return outDirServer;
     }
     else {
-        const { outDirClient, outDirServer } = determineOutDirs(outDir);
-        if (viteIsSSR(config)) {
-            debug('outDirServer', 'outDirServer');
-            return outDirServer;
-        }
-        else {
-            debug('outDirClient', 'outDirClient');
-            return outDirClient;
-        }
+        debug('outDirClient', 'outDirClient');
+        return outDirClient;
     }
 }
 function determineOutDirs(outDirRoot) {
     assertPosixPath(outDirRoot);
-    assert(!outDirRoot.endsWith('/'));
     assert(isOutDirRoot(outDirRoot));
     const outDirClient = pathJoin(outDirRoot, 'client');
     const outDirServer = pathJoin(outDirRoot, 'server');
@@ -59,8 +41,35 @@ function determineOutDirs(outDirRoot) {
     assertIsNotOutDirRoot(outDirServer);
     return { outDirClient, outDirServer };
 }
-function getOutDirsAll(outDirRoot, root) {
-    if (!outDirIsAbsolutePath(outDirRoot)) {
+function getOutDirsAll(outDir, root) {
+    let outDirRoot;
+    {
+        if (isOutDirRoot(outDir)) {
+            outDirRoot = outDir;
+        }
+        else {
+            assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
+            assert('/client'.length === '/server'.length);
+            outDirRoot = outDir.slice(0, -1 * '/client'.length);
+        }
+    }
+    debug('outDirRoot', outDirRoot);
+    let outDirs;
+    if (root) {
+        outDirs = getOutDirsAllFromRootNormalized(outDirRoot, root);
+    }
+    else {
+        outDirs = getOutDirsAllFromRoot(outDirRoot);
+    }
+    debug('outDirs', outDirs);
+    return outDirs;
+}
+function getOutDirsAllFromRoot(outDirRoot) {
+    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
+    return { outDirRoot, outDirClient, outDirServer };
+}
+function getOutDirsAllFromRootNormalized(outDirRoot, root) {
+    if (root && !outDirIsAbsolutePath(outDirRoot)) {
         assertPosixPath(outDirRoot);
         assertPosixPath(root);
         outDirRoot = pathJoin(root, outDirRoot);
@@ -88,7 +97,7 @@ function isOutDirRoot(outDirRot) {
 function assertIsNotOutDirRoot(outDir) {
     assert(outDir.endsWith('/client') || outDir.endsWith('/server'));
 }
-/** `outDir` ends with `/server` or `/client` */
+/** Assert that `outDir` ends with `/server` or `/client` */
 function assertOutDirResolved(outDir, config) {
     assertPosixPath(outDir);
     assertIsNotOutDirRoot(outDir);
@@ -106,16 +115,16 @@ function getOutDirFromViteUserConfig(config) {
     let outDir = config.build?.outDir;
     if (outDir === undefined)
         return undefined;
-    outDir = normalize(outDir);
+    outDir = normalizeOutDir(outDir);
     return outDir;
 }
 function getOutDirFromViteResolvedConfig(config) {
     let outDir = config.build.outDir;
     assert(outDir);
-    outDir = normalize(outDir);
+    outDir = normalizeOutDir(outDir);
     return outDir;
 }
-function normalize(outDir) {
+function normalizeOutDir(outDir) {
     outDir = toPosixPath(outDir);
     outDir = outDir.replace(/\/+$/, ''); // remove trailing slashes
     return outDir;

package/dist/esm/node/plugin/{resolveClientEntriesDev.js → shared/resolveClientEntriesDev.js}

@@ -1,12 +1,9 @@
 export { resolveClientEntriesDev };
-import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsNpmPackageImport, assertIsNotProductionRuntime } from './utils.js';
+import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsNpmPackageImport, assertIsNotProductionRuntime } from '../utils.js';
 import { createRequire } from 'module';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
-const __dirname_ = dirname(fileURLToPath(importMetaUrl));
 assertIsNotProductionRuntime();
 async function resolveClientEntriesDev(clientEntry, viteDevServer) {
     let root = viteDevServer.config.root;
@@ -32,13 +29,13 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer) {
             assert(clientEntry.endsWith('.js'));
             try {
                 // For Vitest (which doesn't resolve vike to its dist but to its source files)
-                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/plugin/resolveClientEntriesDev.js
-                filePath = toPosixPath(require_.resolve(clientEntry.replace('@@vike/dist/esm/client/', '../../client/').replace('.js', '.ts')));
+                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/plugin/shared/resolveClientEntriesDev.js
+                filePath = toPosixPath(require_.resolve(clientEntry.replace('@@vike/dist/esm/client/', '../../../client/').replace('.js', '.ts')));
             }
             catch {
                 // For users
-                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/resolveClientEntriesDev.js
-                filePath = toPosixPath(require_.resolve(clientEntry.replace('@@vike/dist/esm/client/', '../../../../dist/esm/client/')));
+                // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/shared/resolveClientEntriesDev.js
+                filePath = toPosixPath(require_.resolve(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/')));
             }
         }
         else {

package/dist/esm/{utils → node/plugin/shared}/viteIsSSR.d.ts

@@ -1,10 +1,7 @@
+import type { ResolvedConfig, UserConfig } from 'vite';
 export { viteIsSSR };
 export { viteIsSSR_options };
-declare function viteIsSSR(config: {
-    build?: {
-        ssr?: boolean | string;
-    };
-}): boolean;
+declare function viteIsSSR(config: ResolvedConfig | UserConfig): boolean;
 type Options = undefined | boolean | {
     ssr?: boolean;
 };

package/dist/esm/{utils → node/plugin/shared}/viteIsSSR.js

@@ -1,5 +1,5 @@
-import { assert } from './assert.js';
-import { isObject } from './isObject.js';
+import { assert } from '../../../utils/assert.js';
+import { isObject } from '../../../utils/isObject.js';
 export { viteIsSSR };
 export { viteIsSSR_options };
 function viteIsSSR(config) {

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

@@ -1,5 +1,4 @@
 export * from '../runtime/utils.js';
-export * from '../../utils/viteIsSSR.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/includes.js';
 export * from '../../utils/isDev.js';

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

@@ -2,10 +2,9 @@
 // We call onLoad() here so that it's called even when only a subset of the plugin is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
 import { onLoad } from './onLoad.js';
 onLoad();
-// We tolerate the fact that we load all of the runtime utils even though some of it isn't needed
+// It's common practice for Vike's Vite plugin to import from Vike's sever runtime
 export * from '../runtime/utils.js';
 // Utils only needed by `plugin/*`
-export * from '../../utils/viteIsSSR.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/includes.js';
 export * from '../../utils/isDev.js';

package/dist/esm/node/prerender/context.d.ts

@@ -0,0 +1,11 @@
+export { isPrerenderEnabled };
+export { isPrerenderAutoRunEnabled };
+export { temp_disablePrerenderAutoRun };
+export { isPrerendering };
+export { setContextIsPrerendering };
+import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+declare function isPrerenderEnabled(vikeConfig: VikeConfigObject): boolean;
+declare function isPrerenderAutoRunEnabled(vikeConfig: VikeConfigObject): boolean;
+declare function temp_disablePrerenderAutoRun(): void;
+declare function isPrerendering(): boolean;
+declare function setContextIsPrerendering(): void;

package/dist/esm/node/prerender/context.js

@@ -0,0 +1,29 @@
+export { isPrerenderEnabled };
+export { isPrerenderAutoRunEnabled };
+export { temp_disablePrerenderAutoRun };
+export { isPrerendering };
+export { setContextIsPrerendering };
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
+import { resolvePrerenderConfig } from './resolvePrerenderConfig.js';
+const globalObject = getGlobalObject('prerender/context.ts', {});
+function isPrerenderEnabled(vikeConfig) {
+    const prerenderConfig = resolvePrerenderConfig(vikeConfig);
+    return !!prerenderConfig;
+}
+function isPrerenderAutoRunEnabled(vikeConfig) {
+    const prerenderConfig = resolvePrerenderConfig(vikeConfig);
+    return (isPrerenderEnabled(vikeConfig) &&
+        !(prerenderConfig || {}).disableAutoRun &&
+        !globalObject.isDisabled &&
+        vikeConfig.global.config.disableAutoFullBuild !== 'prerender');
+}
+// TODO/v1-release: remove
+function temp_disablePrerenderAutoRun() {
+    globalObject.isDisabled = true;
+}
+function isPrerendering() {
+    return !!globalObject.isPrerendering;
+}
+function setContextIsPrerendering() {
+    globalObject.isPrerendering = true;
+}

package/dist/esm/node/prerender/resolvePrerenderConfig.d.ts

@@ -0,0 +1,12 @@
+export { resolvePrerenderConfig };
+export { resolvePrerenderConfigLocal };
+import type { ConfigResolved } from '../../shared/page-configs/Config/PageContextConfig.js';
+import { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+type PrerenderConfigSemiResolved = ConfigResolved['prerender'];
+type PrerenderConfig = false | Exclude<Required<NonNullable<PrerenderConfigSemiResolved>[number]>, boolean>;
+declare function resolvePrerenderConfig(vikeConfig: VikeConfigObject): PrerenderConfig;
+declare function resolvePrerenderConfigLocal(pageConfig: PageConfigBuildTime): {
+    value: boolean;
+    configValueFilePathToShowToUser: string;
+} | null;

package/dist/esm/node/prerender/resolvePrerenderConfig.js

@@ -0,0 +1,44 @@
+export { resolvePrerenderConfig };
+export { resolvePrerenderConfigLocal };
+import { assert, isArray } from './utils.js';
+import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
+import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
+// TODO/now:
+// - prerender.value
+function resolvePrerenderConfig(vikeConfig) {
+    const prerenderConfigs = vikeConfig.global.config.prerender;
+    if (!prerenderConfigs &&
+        !vikeConfig.pageConfigs.some((pageConfig) => resolvePrerenderConfigLocal(pageConfig)?.value)) {
+        return false;
+    }
+    let prerenderSettings = prerenderConfigs || [];
+    // Needed because of backwards compatibility of `vike({prerender:true})` in `vite.config.js`; after we remove it we can remove this line.
+    prerenderSettings = prerenderSettings.filter(isObject2);
+    assert(prerenderSettings.every(isObject2));
+    const prerenderConfig = {
+        partial: pickFirst(prerenderSettings.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(prerenderSettings.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(prerenderSettings.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(prerenderSettings.map((c) => c.disableAutoRun)) ?? false
+    };
+    return prerenderConfig;
+}
+function resolvePrerenderConfigLocal(pageConfig) {
+    const configValue = getConfigValueBuildTime(pageConfig, 'prerender');
+    if (!configValue)
+        return null;
+    const values = configValue.value;
+    assert(isArray(values));
+    const value = values[0];
+    assert(typeof value === 'boolean');
+    assert(isArray(configValue.definedAtData));
+    const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData[0]);
+    assert(configValueFilePathToShowToUser);
+    return { value, configValueFilePathToShowToUser };
+}
+function isObject2(p) {
+    return typeof p === 'object' && p !== null;
+}
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -3,8 +3,47 @@ export { runPrerenderFromCLIPrerenderCommand };
 export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
+export type { PrerenderContextPublic };
+import { PageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
+import { PageContextUrlInternal } from '../../shared/getPageContextUrlComputed.js';
 import type { APIOptions } from '../api/types.js';
+type ProvidedByHook = null | {
+    hookFilePath: string;
+    hookName: 'onBeforePrerenderStart' | 'prerender';
+};
+type TransformerHook = {
+    hookFilePath: string;
+    hookName: 'onPrerenderStart' | 'onBeforePrerender';
+};
+type PageContextPrerendered = {
+    urlOriginal: string;
+    _providedByHook?: ProvidedByHook;
+};
+type PrerenderedPageContexts = Record<string, PageContextPrerendered>;
+type PrerenderContext = {
+    pageContexts: PageContext[];
+    pageContextInit: Record<string, unknown> | null;
+    noExtraDir: boolean;
+    prerenderedPageContexts: PrerenderedPageContexts;
+    output: Output;
+};
+type Output = {
+    filePath: string;
+    fileType: FileType;
+    fileContent: string;
+    pageContext: PageContextPrerendered;
+}[];
+type FileType = 'HTML' | 'JSON';
+type PrerenderContextPublic = Pick<PrerenderContext, 'pageContexts'>;
+type PageContext = PageContextInitEnhanced & {
+    _urlRewrite: null;
+    _urlHandler: null;
+    _urlOriginalBeforeHook?: string;
+    _urlOriginalModifiedByHook?: TransformerHook;
+    _providedByHook: ProvidedByHook;
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+} & PageContextUrlInternal;
 type PrerenderOptions = APIOptions & {
     /** Initial `pageContext` values */
     pageContextInit?: Record<string, unknown>;
@@ -29,5 +68,7 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<void>;
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined, config: ResolvedConfig): Promise<{
+    forceExit: boolean;
+}>;
 declare function runPrerender_forceExit(): void;