vike 0.4.231 → 0.4.232-commit-ec54a7e

package/dist/esm/node/runtime/renderPage.js

@@ -1,27 +1,25 @@
 export { renderPage };
 export { renderPage_addAsyncHookwrapper };
 import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
-import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext } from './renderPage/createPageContextServerSide.js';
+import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext, } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty } from './utils.js';
-import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
-import { getGlobalContextServerInternal, initGlobalContext_renderPage } from './globalContext.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, augmentType, } from './utils.js';
+import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
+import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
-import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseErrorWithoutGlobalContext, createHttpResponseBaseIsMissing } from './renderPage/createHttpResponse.js';
-import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
+import { createHttpResponse404, createHttpResponseRedirect, createHttpResponsePageContextJson, createHttpResponseError, createHttpResponseErrorWithoutGlobalContext, createHttpResponseBaseIsMissing, } from './renderPage/createHttpResponse.js';
+import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
 import { isNewError } from './renderPage/isNewError.js';
 import { assertArguments } from './renderPage/assertArguments.js';
 import { log404 } from './renderPage/log404/index.js';
-import { isVikeConfigInvalid } from './renderPage/isVikeConfigInvalid.js';
 import pc from '@brillout/picocolors';
 import { getPageContextClientSerializedAbort, getPageContextClientSerialized } from './html/serializeContext.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
 import { loadPageConfigsLazyServerSide } from './renderPage/loadPageConfigsLazyServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
-const globalObject = getGlobalObject('runtime/renderPage.ts', {
-    httpRequestsCount: 0
-});
+import { getVikeConfigError } from '../shared/getVikeConfigError.js';
+const globalObject = getGlobalObject('runtime/renderPage.ts', { httpRequestsCount: 0 });
 // `renderPage()` calls `renderPageNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
 async function renderPage(pageContextInit) {
     assertArguments(...arguments);
@@ -42,7 +40,7 @@ async function renderPage(pageContextInit) {
 }
 // Fallback wrapper if node:async_hooks isn't available
 let asyncHookWrapper = async (_httpRequestId, ret) => ({
-    pageContextReturn: await ret()
+    pageContextReturn: await ret(),
 });
 // Add node:async_hooks wrapper
 function renderPage_addAsyncHookwrapper(wrapper) {
@@ -50,10 +48,11 @@ function renderPage_addAsyncHookwrapper(wrapper) {
 }
 async function renderPagePrepare(pageContextInit, httpRequestId) {
     // Invalid config
-    if (isVikeConfigInvalid &&
-        true // Make TS happy
-    ) {
-        return getPageContextInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
+    {
+        const vikeConfigError = getVikeConfigError();
+        if (vikeConfigError) {
+            return getPageContextInvalidVikeConfig(vikeConfigError.err, pageContextInit, httpRequestId);
+        }
     }
     // Prepare context
     try {
@@ -64,17 +63,20 @@ async function renderPagePrepare(pageContextInit, httpRequestId) {
         // ```bash
         // Re-build your app (you're using 1.2.3 but your app was built with 1.2.2)
         // ```
-        // initGlobalContext_renderPage() doens't call any user hook => err isn't thrown from user code.
+        // initGlobalContext_renderPage() doesn't call any user hook => err isn't thrown from user code.
         assert(!isAbortError(err));
         logRuntimeError(err, httpRequestId);
         const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
         return pageContextWithError;
     }
-    if (isVikeConfigInvalid) {
-        return getPageContextInvalidVikeConfig(isVikeConfigInvalid.err, pageContextInit, httpRequestId);
-    }
-    else {
-        // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
+    {
+        const vikeConfigError = getVikeConfigError();
+        if (vikeConfigError) {
+            return getPageContextInvalidVikeConfig(vikeConfigError.err, pageContextInit, httpRequestId);
+        }
+        else {
+            // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
+        }
     }
     const { globalContext } = await getGlobalContextServerInternal();
     const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, httpRequestId);
@@ -136,59 +138,66 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         assert(errNominalPage);
         assert(pageContextNominalPageSuccess === undefined);
-        assert(pageContextNominalPageBegin);
-        assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
-        // Handle `throw redirect()` and `throw render()` while rendering nominal page
-        if (isAbortError(errNominalPage)) {
-            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-            if (handled.pageContextReturn) {
-                // - throw redirect()
-                // - throw render(url)
-                // - throw render(abortStatusCode) if .pageContext.json request
-                return handled.pageContextReturn;
-            }
-            else {
-                // - throw render(abortStatusCode) if not .pageContext.json request
-            }
-            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+        return await renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite);
+    }
+}
+// When the normal page threw an error
+// - Can be a URL rewrite upon `throw render('/some-url')`
+// - Can be rendering the error page
+// - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
+async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
+    assert(pageContextNominalPageBegin);
+    assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+    // Handle `throw redirect()` and `throw render()` while rendering nominal page
+    if (isAbortError(errNominalPage)) {
+        const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+        if (handled.pageContextReturn) {
+            // - throw redirect()
+            // - throw render(url)
+            // - throw render(abortStatusCode) if .pageContext.json request
+            return handled.pageContextReturn;
         }
-        {
-            const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
-            if (!errorPageId) {
-                objectAssign(pageContextErrorPageInit, { pageId: null });
-                return handleErrorWithoutErrorPage(pageContextErrorPageInit);
-            }
-            else {
-                objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
-            }
+        else {
+            // - throw render(abortStatusCode) if not .pageContext.json request
         }
-        let pageContextErrorPage;
-        try {
-            pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+    }
+    {
+        const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
+        if (!errorPageId) {
+            objectAssign(pageContextErrorPageInit, { pageId: null });
+            return handleErrorWithoutErrorPage(pageContextErrorPageInit);
         }
-        catch (errErrorPage) {
-            // Handle `throw redirect()` and `throw render()` while rendering error page
-            if (isAbortError(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-                // throw render(abortStatusCode)
-                if (!handled.pageContextReturn) {
-                    const pageContextAbort = errErrorPage._pageContextAbort;
-                    assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-                    return pageContextHttpWithError;
-                }
-                // `throw redirect()` / `throw render(url)`
-                return handled.pageContextReturn;
-            }
-            if (isNewError(errErrorPage, errNominalPage)) {
-                logRuntimeError(errErrorPage, httpRequestId);
+        else {
+            objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
+        }
+    }
+    let pageContextErrorPage;
+    try {
+        pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+    }
+    catch (errErrorPage) {
+        // Handle `throw redirect()` and `throw render()` while rendering error page
+        if (isAbortError(errErrorPage)) {
+            const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+            // throw render(abortStatusCode)
+            if (!handled.pageContextReturn) {
+                const pageContextAbort = errErrorPage._pageContextAbort;
+                assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
+                const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+                return pageContextHttpWithError;
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-            return pageContextWithError;
+            // `throw redirect()` / `throw render(url)`
+            return handled.pageContextReturn;
         }
-        return pageContextErrorPage;
+        if (isNewError(errErrorPage, errNominalPage)) {
+            logRuntimeError(errErrorPage, httpRequestId);
+        }
+        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+        return pageContextWithError;
     }
+    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -211,7 +220,7 @@ function logHttpResponse(urlOriginalPretty, httpRequestId, pageContextReturn) {
             //   - Maybe we can/should make the error available at pageContext.errorWhileRendering
             assert(errorWhileRendering === null || errorWhileRendering === undefined);
             msg = `HTTP response ${prettyUrl(urlOriginalPretty)} ${pc.dim('null')}`;
-            // Erroneous value (it shoud sometimes be `false`) but it's fine as it doesn't seem to have much of an impact.
+            // Erroneous value (it should sometimes be `false`) but it's fine as it doesn't seem to have much of an impact.
             isNominal = true;
         }
         else {
@@ -249,7 +258,7 @@ function getPageContextHttpResponseError(err, pageContextBegin) {
     const httpResponse = createHttpResponseError(pageContextBegin);
     objectAssign(pageContextWithError, {
         httpResponse,
-        errorWhileRendering: err
+        errorWhileRendering: err,
     });
     return pageContextWithError;
 }
@@ -258,7 +267,7 @@ function getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextIni
     const httpResponse = createHttpResponseErrorWithoutGlobalContext();
     objectAssign(pageContextWithError, {
         httpResponse,
-        errorWhileRendering: err
+        errorWhileRendering: err,
     });
     return pageContextWithError;
 }
@@ -270,7 +279,7 @@ async function renderPageNominal(pageContext) {
         objectAssign(pageContext, pageContextFromRoute);
         objectAssign(pageContext, { is404: pageContext.pageId ? null : true });
         if (pageContext.pageId === null) {
-            const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+            const errorPageId = getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs);
             if (!errorPageId) {
                 assert(hasProp(pageContext, 'pageId', 'null'));
                 return handleErrorWithoutErrorPage(pageContext);
@@ -291,10 +300,10 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     objectAssign(pageContext, {
         is404: false,
         errorWhileRendering: errNominalPage,
-        routeParams: {}
+        routeParams: {},
     });
     objectAssign(pageContext, {
-        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR'
+        _debugRouteMatches: pageContextNominalPagePartial._debugRouteMatches || 'ROUTING_ERROR',
     });
     assert(pageContext.errorWhileRendering);
     return pageContext;
@@ -305,8 +314,8 @@ async function getPageContextBegin(pageContextInit, globalContext, httpRequestId
         isPrerendering: false,
         ssr: {
             urlHandler: _urlHandler,
-            isClientSideNavigation
-        }
+            isClientSideNavigation,
+        },
     });
     objectAssign(pageContextBegin, { _httpRequestId: httpRequestId });
     return pageContextBegin;
@@ -315,7 +324,7 @@ function handlePageContextUrl(urlOriginal) {
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     return {
         isClientSideNavigation: isPageContextRequest,
-        _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix
+        _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix,
     };
 }
 function getRequestId() {
@@ -410,7 +419,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
-            objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+            augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = getPageContextClientSerialized(pageContext);
         }
@@ -424,7 +433,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
     if (pageContextAbort._urlRewrite) {
         const pageContextReturn = await renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRequestId, [
             ...pageContextsFromRewrite,
-            pageContextAbort
+            pageContextAbort,
         ]);
         Object.assign(pageContextReturn, pageContextAbort);
         return { pageContextReturn };
@@ -449,7 +458,7 @@ async function checkBaseUrl(pageContextBegin, globalContext) {
     const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
     objectAssign(pageContext, {
         httpResponse,
-        isBaseMissing: true
+        isBaseMissing: true,
     });
     checkType(pageContext);
     return pageContext;
@@ -464,7 +473,7 @@ function getPageContextSkipRequest(pageContextInit) {
     if (urlPathnameWithBase.endsWith('.well-known/appspecific/com.chrome.devtools.json')) {
         // https://chromium.googlesource.com/devtools/devtools-frontend/+/main/docs/ecosystem/automatic_workspace_folders.md
         // https://www.reddit.com/r/node/comments/1kcr0wh/odd_request_coming_into_my_localhost_server_from/
-        errMsg404 = 'Not spported';
+        errMsg404 = 'Not supported';
     }
     if (!errMsg404)
         return;
@@ -475,7 +484,7 @@ function getPageContextSkipRequest(pageContextInit) {
     return pageContext;
 }
 function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
-    logRuntimeInfo?.(pc.bold(pc.red('Error while loading a Vike config file, see error above.')), httpRequestId, 'error');
+    logRuntimeInfo?.(pc.bold(pc.red('Error loading Vike config — see error above')), httpRequestId, 'error');
     const pageContextWithError = getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextInit);
     return pageContextWithError;
 }

package/dist/esm/node/runtime/universal-middleware.js

@@ -5,13 +5,13 @@ export default async function universalVikeHandler(request, context, runtime) {
         ...runtime,
         runtime,
         urlOriginal: request.url,
-        headersOriginal: request.headers
+        headersOriginal: request.headers,
     };
     const pageContext = await renderPage(pageContextInit);
     const response = pageContext.httpResponse;
     const readable = response.getReadableWebStream();
     return new Response(readable, {
         status: response.statusCode,
-        headers: response.headers
+        headers: response.headers,
     });
 }

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

@@ -33,7 +33,7 @@ export * from '../../utils/freezePartial.js';
 export * from '../../utils/parseNpmPackage.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
-export * from '../../utils/removeFileExtention.js';
+export * from '../../utils/removeFileExtension.js';
 export * from '../../utils/objectKeys.js';
 export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';

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

@@ -37,7 +37,7 @@ export * from '../../utils/freezePartial.js';
 export * from '../../utils/parseNpmPackage.js';
 export * from '../../utils/isNullish.js';
 export * from '../../utils/isScriptFile.js';
-export * from '../../utils/removeFileExtention.js';
+export * from '../../utils/removeFileExtension.js';
 export * from '../../utils/objectKeys.js';
 export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';

package/dist/esm/node/runtime-dev/createDevMiddleware.js

@@ -16,9 +16,9 @@ async function createDevMiddleware(options = {}) {
             root: options.root ?? options.viteConfig?.root,
             server: {
                 ...options.viteConfig?.server,
-                middlewareMode: options.viteConfig?.server?.middlewareMode ?? true
-            }
-        }
+                middlewareMode: options.viteConfig?.server?.middlewareMode ?? true,
+            },
+        },
     };
     const { viteConfigFromUserEnhanced } = await prepareViteApiCall(optionsMod, 'dev');
     const server = await createServer(viteConfigFromUserEnhanced);

package/dist/esm/node/shared/assertV1Design.d.ts

@@ -1,4 +1,4 @@
 export { assertV1Design };
 import { PageFile } from '../../shared/getPageFiles.js';
-import type { PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+import type { PageConfigBuildTime } from '../../types/PageConfig.js';
 declare function assertV1Design(pageConfigs: PageConfigBuildTime[] | boolean, pageFilesAll: PageFile[] | boolean): void;

package/dist/esm/node/shared/extractAssetsQuery.js

@@ -1,6 +1,6 @@
 export { extractAssetsAddQuery };
 export { extractAssetsRemoveQuery };
-// We import from node/utils.ts insead of node/plugin/utils.ts because this file is loaded by the server runtime
+// We import from node/utils.ts instead of node/vite/utils.ts because this file is loaded by the server runtime
 import { assert, getFileExtension } from './utils.js';
 const query = 'extractAssets';
 function extractAssetsAddQuery(id) {

package/dist/esm/node/shared/getVikeConfigError.d.ts

@@ -0,0 +1,13 @@
+export { getVikeConfigError };
+export { getVikeConfigErrorBuild };
+export { setVikeConfigError };
+type VikeConfigHasError = false | {
+    err: unknown;
+};
+declare function setVikeConfigError(val: {
+    errorRuntime: VikeConfigHasError;
+} | {
+    errorBuild: VikeConfigHasError;
+}): void;
+declare function getVikeConfigError(): VikeConfigHasError;
+declare function getVikeConfigErrorBuild(): VikeConfigHasError;

package/dist/esm/node/shared/getVikeConfigError.js

@@ -0,0 +1,20 @@
+export { getVikeConfigError };
+export { getVikeConfigErrorBuild };
+export { setVikeConfigError };
+import { getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('node/shared/getVikeConfigError.ts', {
+    errorRuntime: false,
+    errorBuild: false,
+});
+function setVikeConfigError(val) {
+    if ('errorRuntime' in val)
+        globalObject.errorRuntime = val.errorRuntime;
+    if ('errorBuild' in val)
+        globalObject.errorBuild = val.errorBuild;
+}
+function getVikeConfigError() {
+    return globalObject.errorBuild || globalObject.errorRuntime;
+}
+function getVikeConfigErrorBuild() {
+    return globalObject.errorBuild;
+}

package/dist/esm/node/shared/resolveBase.js

@@ -25,6 +25,6 @@ function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolve
     assert(isBaseServer(baseServer));
     return {
         baseServer,
-        baseAssets
+        baseAssets,
     };
 }

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

@@ -1,5 +1,6 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/getFileExtension.js';
+export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/hasProp.js';

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

@@ -2,6 +2,7 @@ import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 assertIsNotBrowser();
 export * from '../../utils/assert.js';
 export * from '../../utils/getFileExtension.js';
+export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/hasProp.js';

package/dist/esm/node/shared/virtualFiles/virtualFileEntry.d.ts

@@ -0,0 +1,11 @@
+export { virtualFileIdEntryServer };
+export { virtualFileIdEntryClientSR };
+export { virtualFileIdEntryClientCR };
+export { isVirtualFileIdEntry };
+declare const virtualFileIdEntryServer = "virtual:vike:entry:server";
+declare const virtualFileIdEntryClientSR = "virtual:vike:entry:client:server-routing";
+declare const virtualFileIdEntryClientCR = "virtual:vike:entry:client:client-routing";
+declare function isVirtualFileIdEntry(id: string): false | {
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+};

package/dist/esm/node/shared/virtualFiles/virtualFileEntry.js

@@ -0,0 +1,26 @@
+export { virtualFileIdEntryServer };
+export { virtualFileIdEntryClientSR };
+export { virtualFileIdEntryClientCR };
+export { isVirtualFileIdEntry };
+import { assert } from '../utils.js';
+import { getVirtualFileId } from '../virtualFiles.js';
+const idBase = 'virtual:vike:entry';
+const virtualFileIdEntryServer = `${idBase}:server`;
+const virtualFileIdEntryClientSR = `${idBase}:client:server-routing`;
+const virtualFileIdEntryClientCR = `${idBase}:client:client-routing`;
+function isVirtualFileIdEntry(id) {
+    id = getVirtualFileId(id);
+    if (!id.startsWith(idBase))
+        return false;
+    assert(
+    // prettier-ignore
+    // biome-ignore format:
+    [
+        virtualFileIdEntryServer,
+        virtualFileIdEntryClientCR,
+        virtualFileIdEntryClientSR
+    ].includes(id));
+    const isForClientSide = id !== virtualFileIdEntryServer;
+    const isClientRouting = id === virtualFileIdEntryClientCR;
+    return { isForClientSide, isClientRouting };
+}

package/dist/esm/node/shared/virtualFiles/virtualFilePageConfigLazy.d.ts

@@ -0,0 +1,9 @@
+export { isVirtualFileIdPageConfigLazy };
+export { getVirtualFileIdPageConfigLazy };
+declare const idBase = "virtual:vike:pageConfigLazy:";
+declare function getVirtualFileIdPageConfigLazy(pageId: string, isForClientSide: boolean): `${typeof idBase}${string}`;
+declare function isVirtualFileIdPageConfigLazy(id: string): false | {
+    isForClientSide: boolean;
+    pageId: string;
+    isExtractAssets: boolean;
+};

package/dist/esm/node/shared/{virtual-files/virtualFilePageConfigValuesAll.js → virtualFiles/virtualFilePageConfigLazy.js}

@@ -1,16 +1,16 @@
-export { isVirtualFileIdPageConfigValuesAll };
-export { getVirtualFileIdPageConfigValuesAll };
+export { isVirtualFileIdPageConfigLazy };
+export { getVirtualFileIdPageConfigLazy };
 import { extractAssetsRemoveQuery } from '../extractAssetsQuery.js';
 import { assert } from '../utils.js';
-import { getVirtualFileId } from '../virtual-files.js';
-const idBase = 'virtual:vike:pageConfigValuesAll:';
+import { getVirtualFileId } from '../virtualFiles.js';
+const idBase = 'virtual:vike:pageConfigLazy:';
 const idBaseClient = `${idBase}client:`;
 const idBaseServer = `${idBase}server:`;
-function getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide) {
+function getVirtualFileIdPageConfigLazy(pageId, isForClientSide) {
     const id = `${isForClientSide ? idBaseClient : idBaseServer}${pageId}`;
     return id;
 }
-function isVirtualFileIdPageConfigValuesAll(id) {
+function isVirtualFileIdPageConfigLazy(id) {
     id = getVirtualFileId(id);
     if (!id.includes(idBase))
         return false;
@@ -23,14 +23,14 @@ function isVirtualFileIdPageConfigValuesAll(id) {
         return {
             pageId: id.slice(idBaseClient.length),
             isForClientSide: true,
-            isExtractAssets
+            isExtractAssets,
         };
     }
     if (id.startsWith(idBaseServer)) {
         return {
             pageId: id.slice(idBaseServer.length),
             isForClientSide: false,
-            isExtractAssets
+            isExtractAssets,
         };
     }
     assert(false);

package/dist/esm/node/{plugin → vite}/index.d.ts

@@ -1,7 +1,7 @@
 export default plugin;
 export { plugin };
 export { plugin as ssr };
-export { getVikeConfigPublic as getVikeConfig } from './plugins/commonConfig.js';
+export { getVikeConfig } from './shared/resolveVikeConfigInternal.js';
 export { PROJECT_VERSION as version } from './utils.js';
 export type { VikeVitePluginOptions as UserConfig };
 export type { VikeVitePluginOptions };

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

@@ -0,0 +1,60 @@
+export default plugin;
+export { plugin };
+// TODO/v1-release: remove
+export { plugin as ssr };
+export { getVikeConfig } from './shared/resolveVikeConfigInternal.js';
+export { PROJECT_VERSION as version } from './utils.js';
+import { assertUsage } from './utils.js';
+import { pluginBuild } from './plugins/pluginBuild.js';
+import { pluginPreview } from './plugins/pluginPreview.js';
+import { pluginDev } from './plugins/pluginDev.js';
+import { pluginVirtualFiles } from './plugins/pluginVirtualFiles.js';
+import { pluginExtractAssets } from './plugins/pluginExtractAssets.js';
+import { pluginExtractExportNames } from './plugins/pluginExtractExportNames.js';
+import { pluginSetGlobalContext } from './plugins/pluginSetGlobalContext.js';
+import { pluginCommon } from './plugins/pluginCommon.js';
+import { pluginBaseUrls } from './plugins/pluginBaseUrls.js';
+import { pluginEnvVars } from './plugins/pluginEnvVars.js';
+import pc from '@brillout/picocolors';
+import { pluginFileEnv } from './plugins/pluginFileEnv.js';
+import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
+import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
+import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModuleHmr.js';
+import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
+import { pluginReplaceConstants } from './plugins/pluginReplaceConstants.js';
+// We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
+setResolveClientEntriesDev(resolveClientEntriesDev);
+// Return `PluginInterop` instead of `Plugin` to avoid type mismatch upon different Vite versions
+function plugin(vikeVitePluginOptions = {}) {
+    const plugins = [
+        ...pluginCommon(vikeVitePluginOptions),
+        pluginVirtualFiles(),
+        ...pluginDev(),
+        ...pluginBuild(),
+        pluginPreview(),
+        ...pluginExtractAssets(),
+        pluginExtractExportNames(),
+        ...pluginSetGlobalContext(),
+        pluginBaseUrls(),
+        pluginEnvVars(),
+        pluginFileEnv(),
+        pluginWorkaroundCssModuleHmr(),
+        pluginWorkaroundVite6HmrRegression(),
+        pluginReplaceConstants(),
+    ];
+    Object.assign(plugins, { _vikeVitePluginOptions: vikeVitePluginOptions });
+    return plugins;
+}
+// Error upon wrong usage
+Object.defineProperty(plugin, 'apply', {
+    enumerable: true,
+    get: () => {
+        assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
+    },
+});
+// CJS default export `const vike = require('vike/plugin')`
+//  - It needs to live at the end of this file, in order to ensure we do it after all assignments to `exports`.
+try {
+    module.exports = Object.assign(exports.default, exports);
+}
+catch { }

package/dist/esm/node/vite/plugins/pluginBaseUrls.d.ts

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