vike 0.4.231 → 0.4.232-commit-134207d

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, } 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);
@@ -211,7 +213,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 +251,7 @@ function getPageContextHttpResponseError(err, pageContextBegin) {
     const httpResponse = createHttpResponseError(pageContextBegin);
     objectAssign(pageContextWithError, {
         httpResponse,
-        errorWhileRendering: err
+        errorWhileRendering: err,
     });
     return pageContextWithError;
 }
@@ -258,7 +260,7 @@ function getPageContextHttpResponseErrorWithoutGlobalContext(err, pageContextIni
     const httpResponse = createHttpResponseErrorWithoutGlobalContext();
     objectAssign(pageContextWithError, {
         httpResponse,
-        errorWhileRendering: err
+        errorWhileRendering: err,
     });
     return pageContextWithError;
 }
@@ -270,7 +272,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 +293,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 +307,8 @@ async function getPageContextBegin(pageContextInit, globalContext, httpRequestId
         isPrerendering: false,
         ssr: {
             urlHandler: _urlHandler,
-            isClientSideNavigation
-        }
+            isClientSideNavigation,
+        },
     });
     objectAssign(pageContextBegin, { _httpRequestId: httpRequestId });
     return pageContextBegin;
@@ -315,7 +317,7 @@ function handlePageContextUrl(urlOriginal) {
     const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
     return {
         isClientSideNavigation: isPageContextRequest,
-        _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix
+        _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix,
     };
 }
 function getRequestId() {
@@ -424,7 +426,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 +451,7 @@ async function checkBaseUrl(pageContextBegin, globalContext) {
     const httpResponse = createHttpResponseBaseIsMissing(urlOriginal, baseServer);
     objectAssign(pageContext, {
         httpResponse,
-        isBaseMissing: true
+        isBaseMissing: true,
     });
     checkType(pageContext);
     return pageContext;
@@ -464,7 +466,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 +477,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;

package/dist/esm/node/{plugin/plugins/baseUrls.js → vite/plugins/pluginBaseUrls.js}

@@ -1,19 +1,18 @@
-export { baseUrls };
+export { pluginBaseUrls };
 import { resolveBase } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
-import { getVikeConfigInternal } from './commonConfig.js';
-function baseUrls() {
+import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+function pluginBaseUrls() {
     let basesResolved;
     return {
-        name: 'vike:baseUrls',
+        name: 'vike:pluginBaseUrls',
         enforce: 'post',
         async config(config) {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            const vike = getVikeConfigInternal(config);
-            basesResolved = resolveBase(baseViteOriginal, vike.config.baseServer ?? null, vike.config.baseAssets ?? null);
+            const vikeConfig = await getVikeConfigInternal();
+            basesResolved = resolveBase(baseViteOriginal, vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
             process.env.BASE_SERVER = basesResolved.baseServer;
             process.env.BASE_ASSETS = basesResolved.baseAssets;
@@ -21,15 +20,15 @@ function baseUrls() {
                 envPrefix: [
                     'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
                     'BASE_SERVER',
-                    'BASE_ASSETS'
+                    'BASE_ASSETS',
                 ],
                 base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
-                _baseViteOriginal: baseViteOriginal
+                _baseViteOriginal: baseViteOriginal,
             };
         },
         async configResolved(config) {
-            const vikeConfig = await getVikeConfig(config);
-            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.global.config.baseServer ?? null, vikeConfig.global.config.baseAssets ?? null, config);
+            const vikeConfig = await getVikeConfigInternal();
+            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null, config);
             assert(basesResolved2.baseServer === basesResolved.baseServer);
             assert(basesResolved2.baseAssets === basesResolved.baseAssets);
             /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
@@ -37,7 +36,7 @@ function baseUrls() {
              *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
             assert(config.base === baseAssets)
             */
-        }
+        },
     };
 }
 function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {

package/dist/esm/node/{plugin/plugins/build → vite/plugins/pluginBuild}/handleAssetsManifest.d.ts

@@ -5,14 +5,15 @@ export { handleAssetsManifest_assertUsageCssCodeSplit };
 export { handleAssetsManifest_assertUsageCssTarget };
 import type { Environment, ResolvedConfig, Rollup, UserConfig } from 'vite';
 type Bundle = Rollup.OutputBundle;
-type Options = Rollup.NormalizedOutputOptions;
 declare function handleAssetsManifest_isFixEnabled(config: ResolvedConfig | UserConfig): boolean;
 declare function handleAssetsManifest_assertUsageCssCodeSplit(config: ResolvedConfig): void;
 declare function handleAssetsManifest_assertUsageCssTarget(config: ResolvedConfig): void;
-declare function handleAssetsManifest_getBuildConfig(config: UserConfig): {
+declare function handleAssetsManifest_getBuildConfig(config: UserConfig): Promise<{
     readonly ssrEmitAssets: true | undefined;
     readonly cssMinify: "esbuild" | undefined;
     readonly manifest: "_temp_manifest.json";
     readonly copyPublicDir: boolean | undefined;
-};
-declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: Options, bundle: Bundle): Promise<void>;
+}>;
+declare function handleAssetsManifest(config: ResolvedConfig, viteEnv: Environment | undefined, options: {
+    dir: string | undefined;
+}, bundle: Bundle): Promise<void>;