vike 0.4.237 → 0.4.238-commit-3c1a09d

package/dist/esm/client/shared/createGetGlobalContextClient.js

@@ -13,23 +13,23 @@ const globalObject = getGlobalObject('createGetGlobalContextClient.ts', (() => {
         globalContextInitialPromiseResolve,
     };
 })());
-function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGlobalContext) {
+function createGetGlobalContextClient(virtualFileExportsGlobalEntry, isClientRouting, addGlobalContext) {
     assert(globalObject.isClientRouting === undefined || globalObject.isClientRouting === isClientRouting);
     globalObject.isClientRouting = isClientRouting;
     // Eagerly call onCreateGlobalContext() hook
     getGlobalContext();
     return getGlobalContext;
     async function getGlobalContext() {
-        // HMR => virtualFileExports differ
-        if (globalObject.virtualFileExports === virtualFileExports) {
+        // HMR => virtualFileExportsGlobalEntry differ
+        if (globalObject.virtualFileExportsGlobalEntry === virtualFileExportsGlobalEntry) {
             const globalContext = await globalObject.globalContextPromise;
             return globalContext;
         }
         else {
-            globalObject.virtualFileExports = virtualFileExports;
+            globalObject.virtualFileExportsGlobalEntry = virtualFileExportsGlobalEntry;
         }
         // Create
-        const globalContextPromise = createGlobalContextShared(virtualFileExports, globalObject, undefined, async (globalContext) => {
+        const globalContextPromise = createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, undefined, async (globalContext) => {
             const globalContextAddendum = {
                 /**
                  * Whether the environment is client-side or server-side / pre-rendering.

package/dist/esm/client/shared/execHookOnRenderClient.d.ts

@@ -1,6 +1,6 @@
 export { execHookOnRenderClient };
 export type { PageContextBeforeRenderClient };
-import type { PageFile, VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { PageFile, VikeConfigPublicPageLazyLoaded } from '../../shared/getPageFiles.js';
 import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
 import type { GlobalContextClientInternalShared } from './createGetGlobalContextClient.js';
 type PageContextBeforeRenderClient = {
@@ -9,5 +9,5 @@ type PageContextBeforeRenderClient = {
     urlPathname?: string;
     pageId: string;
     _globalContext: GlobalContextClientInternalShared;
-} & VikeConfigPublicPageLazy & PageContextForPublicUsageClientShared;
+} & VikeConfigPublicPageLazyLoaded & PageContextForPublicUsageClientShared;
 declare function execHookOnRenderClient<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

package/dist/esm/client/shared/loadPageConfigsLazyClientSide.d.ts

@@ -11,7 +11,7 @@ type PageContext_loadPageConfigsLazyClientSide = {
         _pageConfigGlobal: PageConfigGlobalRuntime;
     };
 };
-declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<import("../../shared/getPageFiles.js").VikeConfigPublicPageLazyLoaded & {
     _pageFilesLoaded: PageFile[];
 }>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/esm/client/shared/loadPageConfigsLazyClientSide.js

@@ -1,9 +1,9 @@
 export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
-import { resolveVikeConfigPublicPageLazy } from '../../shared/page-configs/resolveVikeConfigPublic.js';
+import { resolveVikeConfigPublicPageLazyLoaded } from '../../shared/page-configs/resolveVikeConfigPublic.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
-import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
+import { loadAndParseVirtualFilePageEntry } from '../../shared/page-configs/loadAndParseVirtualFilePageEntry.js';
 import { objectAssign } from '../runtime-server-routing/utils.js';
 const errStamp = '_isAssetsError';
 async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
@@ -16,7 +16,7 @@ async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs,
         // prettier-ignore
         // biome-ignore format:
         const result = await Promise.all([
-            pageConfig && loadConfigValues(pageConfig, isDev),
+            pageConfig && loadAndParseVirtualFilePageEntry(pageConfig, isDev),
             ...pageFilesClientSide.map((p) => p.loadFile?.()),
         ]);
         pageConfigLoaded = result[0];
@@ -30,7 +30,7 @@ async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs,
         }
         throw err;
     }
-    const configPublicPageLazy = resolveVikeConfigPublicPageLazy(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
+    const configPublicPageLazy = resolveVikeConfigPublicPageLazyLoaded(pageFilesClientSide, pageConfigLoaded, pageConfigGlobal);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, configPublicPageLazy);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

package/dist/esm/client/shared/preparePageContextForPublicUsageClientShared.d.ts

@@ -1,10 +1,10 @@
 export { preparePageContextForPublicUsageClientShared };
 export { preparePageContextForPublicUsageClientMinimal };
 export type { PageContextForPublicUsageClientShared };
-import type { VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../../shared/getPageFiles.js';
 import { type PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
 import type { PageContextInternalClient } from '../../types/PageContext.js';
-type PageContextForPublicUsageClientShared = PageContextPrepareMinimum & PageContextInternalClient & VikeConfigPublicPageLazy;
+type PageContextForPublicUsageClientShared = PageContextPrepareMinimum & PageContextInternalClient & VikeConfigPublicPageLazyLoaded;
 declare function preparePageContextForPublicUsageClientShared<PageContext extends PageContextForPublicUsageClientShared>(pageContext: PageContext): PageContext & {
     Page: unknown;
 };

package/dist/esm/node/api/build.d.ts

@@ -1,8 +1,8 @@
 export { build };
-import type { APIOptions } from './types.js';
+import type { ApiOptions } from './types.js';
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
-declare function build(options?: APIOptions): Promise<{}>;
+declare function build(options?: ApiOptions): Promise<{}>;

package/dist/esm/node/api/build.js

@@ -1,45 +1,19 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-import { build as buildVite, version, createBuilder } from 'vite';
-import { isVikeCli } from '../cli/context.js';
-import { wasPrerenderRun } from '../prerender/context.js';
-import { assert, assertVersion } from './utils.js';
+import { createBuilder } from 'vite';
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigFromUserEnhanced, vikeConfig } = await prepareViteApiCall(options, 'build');
-    // Pass it to pluginAutoFullBuild()
+    const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'build');
+    // Pass it to vike:build:pluginBuildApp
     if (viteConfigFromUserEnhanced)
         viteConfigFromUserEnhanced._viteConfigFromUserEnhanced = viteConfigFromUserEnhanced;
-    if (vikeConfig.config.vite6BuilderApp) {
-        // This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
-        assertVersion('Vite', version, '6.0.0');
-        const builder = await createBuilder(viteConfigFromUserEnhanced);
-        // See Vite plugin vike:build:pluginBuildApp
-        await builder.buildApp();
-    }
-    else {
-        // This buildVite() call does everything:
-        // 1. Build client-side
-        // 2. Build server-side
-        //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
-        // 3. Pre-render (if enabled)
-        //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
-        //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
-        //    > Rationale: https://github.com/vikejs/vike/issues/2123
-        await buildVite(viteConfigFromUserEnhanced);
-        // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
-        if (
-        // When calling Vike's prerender() API pre-rendering is run without force exit
-        ![false, 'prerender()'].includes(wasPrerenderRun()) &&
-            // When calling Vike's build() API pre-rendering is auto run without force exit
-            isVikeCli()) {
-            assert(false);
-        }
-    }
+    const builder = await createBuilder(viteConfigFromUserEnhanced);
+    // buildApp() is implemented by vike:build:pluginBuildApp
+    await builder.buildApp();
     return {
     /* We don't return `viteConfig` because `viteConfigFromUserEnhanced` is `InlineConfig` not `ResolvedConfig`
     viteConfig: viteConfigFromUserEnhanced,

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

@@ -1,13 +1,13 @@
 export { isVikeCliOrApi };
-export { setContextApiOperation };
-export { clearContextApiOperation };
-export { getApiOperation };
-import type { APIOptions, Operation } from './types.js';
-type ApiOperation = {
-    operation: Operation;
-    options: APIOptions;
+export { setContextVikeApiOperation };
+export { clearContextVikeApiOperation };
+export { getVikeApiOperation };
+import type { ApiOptions, ApiOperation } from './types.js';
+type VikeApiOperation = {
+    operation: ApiOperation;
+    options: ApiOptions;
 };
-declare function getApiOperation(): ApiOperation | null;
+declare function getVikeApiOperation(): VikeApiOperation | null;
 declare function isVikeCliOrApi(): boolean;
-declare function setContextApiOperation(operation: Operation, options: APIOptions): void;
-declare function clearContextApiOperation(): void;
+declare function setContextVikeApiOperation(operation: ApiOperation, options: ApiOptions): void;
+declare function clearContextVikeApiOperation(): void;

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

@@ -1,20 +1,21 @@
 export { isVikeCliOrApi };
-export { setContextApiOperation };
-export { clearContextApiOperation };
-export { getApiOperation };
-import { assert, getGlobalObject } from './utils.js';
+export { setContextVikeApiOperation };
+export { clearContextVikeApiOperation };
+export { getVikeApiOperation };
+// We don't import from ./utils.js because we tolerate this file to be loaded in production
+import { assert, getGlobalObject } from '../runtime/utils.js';
 const globalObject = getGlobalObject('api/context.ts', {});
-function getApiOperation() {
-    return globalObject.apiOperation ?? null;
+function getVikeApiOperation() {
+    return globalObject.vikeApiOperation ?? null;
 }
 function isVikeCliOrApi() {
     // The CLI uses the API
-    return !!globalObject.apiOperation;
+    return !!globalObject.vikeApiOperation;
 }
-function setContextApiOperation(operation, options) {
-    assert(!globalObject.apiOperation);
-    globalObject.apiOperation = { operation, options };
+function setContextVikeApiOperation(operation, options) {
+    assert(!globalObject.vikeApiOperation);
+    globalObject.vikeApiOperation = { operation, options };
 }
-function clearContextApiOperation() {
-    globalObject.apiOperation = undefined;
+function clearContextVikeApiOperation() {
+    globalObject.vikeApiOperation = undefined;
 }

package/dist/esm/node/api/dev.d.ts

@@ -1,12 +1,12 @@
 export { dev };
 import { type ResolvedConfig, type ViteDevServer } from 'vite';
-import type { APIOptions } from './types.js';
+import type { ApiOptions } from './types.js';
 /**
  * Programmatically trigger `$ vike dev`
  *
  * https://vike.dev/api#dev
  */
-declare function dev(options?: APIOptions): Promise<{
+declare function dev(options?: ApiOptions): Promise<{
     viteServer: ViteDevServer;
     viteConfig: ResolvedConfig;
 }>;

package/dist/esm/node/api/dev.js

@@ -1,14 +1,12 @@
 export { dev };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { createServer } from 'vite';
-import { setGlobalContext_isProduction } from '../runtime/globalContext.js';
 /**
  * Programmatically trigger `$ vike dev`
  *
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    setGlobalContext_isProduction(false);
     const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'dev');
     const server = await createServer(viteConfigFromUserEnhanced);
     return {

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

@@ -2,8 +2,6 @@ export { build_ as build };
 export { dev_ as dev };
 export { preview_ as preview };
 export { prerender_ as prerender };
-import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-assertIsNotBrowser();
 const build_ = async (...args) => (await import('./build.js')).build(...args);
 const dev_ = async (...args) => (await import('./dev.js')).dev(...args);
 const preview_ = async (...args) => (await import('./preview.js')).preview(...args);

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

@@ -1,6 +1,6 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertIsNotProductionRuntime } from '../runtime/utils.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 function onLoad() {
     assertIsNotBrowser();
     assertIsNotProductionRuntime();

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -3,13 +3,11 @@ export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
 import type { InlineConfig, ResolvedConfig } from 'vite';
-import type { APIOptions, Operation } from './types.js';
-import { type VikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
-declare function prepareViteApiCall(options: APIOptions, operation: Operation): Promise<{
-    vikeConfig: VikeConfigInternal;
+import type { ApiOptions, ApiOperation } from './types.js';
+declare function prepareViteApiCall(options: ApiOptions, operation: ApiOperation): Promise<{
     viteConfigResolved: ResolvedConfig;
     viteConfigFromUserEnhanced: InlineConfig | undefined;
 }>;
-declare function getViteRoot(operation: Operation): Promise<string>;
+declare function getViteRoot(operation: ApiOperation): Promise<string>;
 declare function normalizeViteRoot(root: string): string;
 declare function assertViteRoot(root: string, config: ResolvedConfig): void;

package/dist/esm/node/api/prepareViteApiCall.js

@@ -3,7 +3,7 @@ export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
 import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
-import { clearContextApiOperation, setContextApiOperation } from './context.js';
+import { clearContextVikeApiOperation, setContextVikeApiOperation } from './context.js';
 import { getVikeConfigInternal, getVikeConfigFromCliOrEnv, setVikeConfigContext, } from '../vite/shared/resolveVikeConfigInternal.js';
 import path from 'node:path';
 import { assert, assertUsage, getGlobalObject, isObject, pick, toPosixPath } from './utils.js';
@@ -13,13 +13,13 @@ import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
 const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
 async function prepareViteApiCall(options, operation) {
     clear();
-    setContextApiOperation(operation, options);
+    setContextVikeApiOperation(operation, options);
     const viteConfigFromUserApiOptions = options.viteConfig;
     return resolveConfigs(viteConfigFromUserApiOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
-    clearContextApiOperation();
+    clearContextVikeApiOperation();
     clearGlobalContext();
 }
 async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
@@ -33,7 +33,6 @@ async function resolveConfigs(viteConfigFromUserApiOptions, operation) {
     const viteConfigFromUserEnhanced = applyVikeViteConfig(viteInfo.viteConfigFromUserEnhanced, vikeConfig);
     const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserEnhanced, operation);
     return {
-        vikeConfig,
         viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
         viteConfigFromUserEnhanced,
     };

package/dist/esm/node/api/preview.d.ts

@@ -1,12 +1,12 @@
 export { preview };
 import { type ResolvedConfig, type PreviewServer } from 'vite';
-import type { APIOptions } from './types.js';
+import type { ApiOptions } from './types.js';
 /**
  * Programmatically trigger `$ vike preview`
  *
  * https://vike.dev/api#preview
  */
-declare function preview(options?: APIOptions): Promise<{
+declare function preview(options?: ApiOptions): Promise<{
     viteServer?: PreviewServer;
     viteConfig: ResolvedConfig;
 }>;

package/dist/esm/node/api/preview.js

@@ -3,10 +3,9 @@ import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { preview as previewVite } from 'vite';
 import { importServerProductionIndex } from '@brillout/vite-plugin-server-entry/runtime';
 import { getOutDirs } from '../vite/shared/getOutDirs.js';
-import { assertWarning } from './utils.js';
+import { assertWarning, onSetupPreview } from './utils.js';
 import pc from '@brillout/picocolors';
 import path from 'node:path';
-import { onSetupPreview } from '../runtime/utils.js';
 /**
  * Programmatically trigger `$ vike preview`
  *
@@ -16,7 +15,7 @@ async function preview(options = {}) {
     onSetupPreview();
     const { viteConfigFromUserEnhanced, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
     if (viteConfigResolved.vitePluginServerEntry?.inject) {
-        const outDir = getOutDirs(viteConfigResolved).outDirRoot;
+        const outDir = getOutDirs(viteConfigResolved, undefined).outDirRoot;
         const { outServerIndex } = await importServerProductionIndex({ outDir });
         const outServerIndexRelative = path.relative(viteConfigResolved.root, outServerIndex);
         assertWarning(false, `Never run ${pc.cyan('$ vike preview')} in production, run ${pc.cyan(`$ node ${outServerIndexRelative}`)} instead (or Bun/Deno).`, { onlyOnce: true });

package/dist/esm/node/api/types.d.ts

@@ -1,8 +1,8 @@
-export type { APIOptions };
-export type { Operation };
+export type { ApiOptions };
+export type { ApiOperation };
 import type { InlineConfig } from 'vite';
 import type { Config } from '../../types/Config.js';
-type APIOptions = {
+type ApiOptions = {
     /**
      * Vite config.
      *
@@ -16,4 +16,4 @@ type APIOptions = {
      */
     vikeConfig?: Config;
 };
-type Operation = 'build' | 'dev' | 'preview' | 'prerender';
+type ApiOperation = 'build' | 'dev' | 'preview' | 'prerender';

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

@@ -4,3 +4,4 @@ export * from '../../utils/path.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/assertVersion.js';
 export * from '../../utils/pick.js';
+export * from '../../utils/assertSetup.js';

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

@@ -8,3 +8,4 @@ export * from '../../utils/path.js';
 export * from '../../utils/isObject.js';
 export * from '../../utils/assertVersion.js';
 export * from '../../utils/pick.js';
+export * from '../../utils/assertSetup.js';

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

@@ -1,5 +1,5 @@
 // TO-DO/next-major-release: remove this file
 export { prerender } from '../api/prerender.js';
-import { assertWarning } from '../../utils/assert.js';
+import { assertWarning } from './utils.js';
 import pc from '@brillout/picocolors';
 assertWarning(false, `${pc.cyan("import { prerender } from 'vike/cli'")} is deprecated in favor of ${pc.cyan("import { prerender } from 'vike/api'")}`, { onlyOnce: true });

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

@@ -1,6 +1,6 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertIsNotProductionRuntime } from '../runtime/utils.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 function onLoad() {
     assertIsNotBrowser();
     assertIsNotProductionRuntime();