vike 0.4.215 → 0.4.217

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

@@ -1,5 +1,5 @@
 export { previewConfig };
-import { assertUsage, getOutDirs, resolveOutDir, markEnvAsVitePreview, applyPreview } from '../utils.js';
+import { assertUsage, getOutDirs, resolveOutDir, applyPreview } from '../utils.js';
 import fs from 'fs';
 import path from 'path';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
@@ -7,7 +7,7 @@ import pc from '@brillout/picocolors';
 import { logDockerHint } from './devConfig/index.js';
 function previewConfig() {
     let config;
-    // let configVike: ConfigVikeResolved
+    // let vikeConfigGlobal: VikeConfigGlobal
     return {
         name: 'vike:previewConfig',
         apply: applyPreview,
@@ -22,18 +22,18 @@ function previewConfig() {
         async configResolved(config_) {
             config = config_;
             logDockerHint(config.preview.host);
-            // configVike = await getConfigVike(config)
+            // const vikeConfig = await getVikeConfig(config)
+            // vikeConfigGlobal = vikeConfig.vikeConfigGlobal
         },
         configurePreviewServer(server) {
             /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
                - This ugly hack to set appType for preview won't be need once https://github.com/vitejs/vite/pull/14855 is merged.
             config.appType = 'mpa'
             */
-            markEnvAsVitePreview();
             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 (!configVike.prerender || configVike.prerender.partial) {
+                if (!vikeConfigGlobal.prerender || vikeConfigGlobal.prerender.partial) {
                   addSsrMiddleware(server.middlewares, config, true)
                 }
                 /*/

package/dist/esm/node/plugin/plugins/setGlobalContext.d.ts

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

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

@@ -1,26 +1,44 @@
 export { setGlobalContext };
-import { setGlobalContext_isDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
-import { assertFilePathAbsoluteFilesystem, getOutDirs, isDevCheck } from '../utils.js';
+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';
 function setGlobalContext() {
-    return {
-        name: 'vike:setGlobalContext',
-        enforce: 'pre',
-        configureServer: {
-            order: 'pre',
-            handler(viteDevServer) {
-                setGlobalContext_viteDevServer(viteDevServer);
+    return [
+        {
+            name: 'vike:setGlobalContext:pre',
+            enforce: 'pre',
+            configureServer: {
+                order: 'pre',
+                handler(viteDevServer) {
+                    setGlobalContext_viteDevServer(viteDevServer);
+                    markSetup_viteDevServer();
+                }
+            },
+            configurePreviewServer() {
+                markSetup_vitePreviewServer();
+            },
+            config: {
+                order: 'pre',
+                handler(_, env) {
+                    const isViteDev = isDevCheck(env);
+                    setGlobalContext_isViteDev(isViteDev);
+                    markSetup_isViteDev(isViteDev);
+                }
             }
         },
-        config: {
-            handler(_, env) {
-                const isDev = isDevCheck(env);
-                setGlobalContext_isDev(isDev);
+        {
+            name: 'vike:setGlobalContext:post',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                async handler(config) {
+                    const { outDirRoot } = getOutDirs(config);
+                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+                    setGlobalContext_viteConfig(config, outDirRoot);
+                    const vikeConfig = await getVikeConfig(config);
+                    setGlobalContext_vikeConfig(vikeConfig);
+                }
             }
-        },
-        configResolved(config) {
-            const { outDirRoot } = getOutDirs(config);
-            assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
-            setGlobalContext_viteConfig(config, outDirRoot);
         }
-    };
+    ];
 }

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

@@ -5,13 +5,12 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, isArray, changeEnumerable } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender } from './utils.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
 import { getGlobalContext, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
-import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
@@ -28,7 +27,7 @@ import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVik
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
 import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 import { getConfigValueBuildTime } from '../../shared/page-configs/getConfigValueBuildTime.js';
-import { prepareApiCall } from '../api/prepareApiCall.js';
+import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
 async function runPrerenderFromAPI(options = {}) {
     return await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.
@@ -36,7 +35,7 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigEnhanced } = await prepareApiCall(undefined, 'prerender');
+        const { viteConfigEnhanced } = await prepareViteApiCall(undefined, 'prerender');
         await runPrerender({ viteConfig: viteConfigEnhanced }, '$ vike prerender');
     }
     catch (err) {
@@ -61,20 +60,20 @@ async function runPrerenderFromAutoRun(viteConfig, forceExit) {
 }
 async function runPrerender(options = {}, standaloneTrigger) {
     checkOutdatedOptions(options);
+    onSetupPrerender();
     setGlobalContext_isPrerendering();
     getHook_setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
     }
-    handleNodeEnv_prerender();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
     assertLoadedConfig(viteConfig, options);
-    const configVike = await getConfigVike(viteConfig);
+    const vikeConfig = await getVikeConfig(viteConfig);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
-    const prerenderConfig = configVike.prerender;
+    const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
     if (!prerenderConfig) {
         assert(standaloneTrigger);
         assertWarning(prerenderConfig, `You're executing ${pc.cyan(standaloneTrigger)} but the config ${pc.cyan('prerender')} isn't set to true`, {
@@ -94,7 +93,6 @@ async function runPrerender(options = {}, standaloneTrigger) {
         pageContextInit: options.pageContextInit ?? null
     });
     const doNotPrerenderList = [];
-    const vikeConfig = await getVikeConfig(viteConfig, false);
     await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
     await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);

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

@@ -9,7 +9,7 @@ export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/assertNodeEnv.js';
+export * from '../../utils/assertSetup.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';

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

@@ -11,7 +11,7 @@ export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
 export * from '../../utils/isPlainObject.js';
-export * from '../../utils/assertNodeEnv.js';
+export * from '../../utils/assertSetup.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';

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

@@ -9,13 +9,15 @@ export { initGlobalContext_runPrerender };
 export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
-export { setGlobalContext_isDev };
+export { setGlobalContext_vikeConfig };
+export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { PluginManifest } from '../shared/assertPluginManifest.js';
-import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
+import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
 import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
+import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 type GlobalContextPublic = {
     assetsManifest: null | ViteManifest;
 };
@@ -30,6 +32,7 @@ type GlobalContext = {
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
+    vikeConfig: VikeConfigObject;
     viteDevServer: ViteDevServer;
     assetsManifest: null;
     pluginManifest: null;
@@ -52,11 +55,12 @@ declare function getGlobalContextSync(): GlobalContextPublic;
 declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
 declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
-declare function setGlobalContext_isDev(isDev: boolean): void;
+declare function setGlobalContext_vikeConfig(vikeConfig: VikeConfigObject): void;
+declare function setGlobalContext_isViteDev(isViteDev: boolean): void;
 declare function setGlobalContext_isPrerendering(): void;
 declare function getViteDevServer(): ViteDevServer | null;
 declare function getViteConfig(): ResolvedConfig | null;
 declare function initGlobalContext_renderPage(): Promise<void>;
 declare function initGlobalContext_runPrerender(): Promise<void>;
 declare function initGlobalContext_getGlobalContextAsync(isProduction: boolean): Promise<void>;
-declare function getRuntimeManifest(configVike: ConfigVikeResolved): RuntimeManifest;
+declare function getRuntimeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): RuntimeManifest;

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

@@ -11,16 +11,17 @@ export { initGlobalContext_runPrerender };
 export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
-export { setGlobalContext_isDev };
+export { setGlobalContext_vikeConfig };
+export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
-import { assert, assertNodeEnv_runtime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys, genPromise } from './utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys, genPromise } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
-import { getConfigVike } from '../shared/getConfigVike.js';
 import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import pc from '@brillout/picocolors';
 import { getPageFilesExports } from './page-files/getPageFilesExports.js';
+import { resolveBaseFromResolvedConfig } from '../shared/resolveBase.js';
 const globalObject = getGlobalObject('globalContext.ts', (() => {
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
     return {
@@ -85,12 +86,18 @@ function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
     globalObject.viteConfig = viteConfig;
     globalObject.outDirRoot = outDirRoot;
 }
+function setGlobalContext_vikeConfig(vikeConfig) {
+    if (globalObject.vikeConfig)
+        return;
+    assertIsNotInitilizedYet();
+    globalObject.vikeConfig = vikeConfig;
+}
 function assertIsNotInitilizedYet() {
     // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     assert(!globalObject.globalContext);
 }
-function setGlobalContext_isDev(isDev) {
-    globalObject.isDev = isDev;
+function setGlobalContext_isViteDev(isViteDev) {
+    globalObject.isViteDev = isViteDev;
 }
 function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
@@ -102,7 +109,7 @@ function getViteConfig() {
     return globalObject.viteConfig ?? null;
 }
 async function initGlobalContext_renderPage() {
-    await initGlobalContext(!globalObject.isDev);
+    await initGlobalContext(!globalObject.isViteDev);
 }
 async function initGlobalContext_runPrerender() {
     if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
@@ -138,14 +145,15 @@ async function initGlobalContext(isProduction) {
         assert(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
         return;
     }
-    const { viteDevServer, viteConfig, isDev, isPrerendering } = globalObject;
-    assertNodeEnv_runtime(isDev ?? false);
+    const { viteDevServer, viteConfig, vikeConfig, isPrerendering } = globalObject;
+    onSetupRuntime();
     if (!isProduction) {
         assert(viteConfig);
+        assert(vikeConfig);
         assert(viteDevServer);
         assert(!isPrerendering);
-        const configVike = await getConfigVike(viteConfig);
-        const pluginManifest = getRuntimeManifest(configVike);
+        const vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
+        const pluginManifest = getRuntimeManifest(vikeConfigGlobal, viteConfig);
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
@@ -153,6 +161,7 @@ async function initGlobalContext(isProduction) {
             pluginManifest: null,
             viteDevServer,
             viteConfig,
+            vikeConfig,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
@@ -182,8 +191,6 @@ async function initGlobalContext(isProduction) {
         };
         if (isPrerendering) {
             assert(viteConfig);
-            const configVike = await getConfigVike(viteConfig);
-            assert(configVike);
             objectAssign(globalContext, {
                 isPrerendering: true,
                 viteConfig
@@ -199,8 +206,9 @@ async function initGlobalContext(isProduction) {
         }
     }
 }
-function getRuntimeManifest(configVike) {
-    const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;
+function getRuntimeManifest(vikeConfigGlobal, viteConfig) {
+    const { includeAssetsImportedByServer, redirects, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
+    const { baseServer, baseAssets } = resolveBaseFromResolvedConfig(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
     const manifest = {
         baseServer,
         baseAssets,

package/dist/esm/node/runtime/index-common.d.ts

@@ -3,6 +3,7 @@ export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
 export { PROJECT_VERSION as version } from './utils.js';
 export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
+export { createDevMiddleware } from '../runtime-dev/index.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 export { createPageRenderer } from '../createPageRenderer.js';
 import './page-files/setup.js';

package/dist/esm/node/runtime/index-common.js

@@ -3,6 +3,7 @@ export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
 export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
 export { PROJECT_VERSION as version } from './utils.js';
 export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
+export { createDevMiddleware } from '../runtime-dev/index.js';
 // TODO/v1-release: remove
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 // TODO/v1-release: remove

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

@@ -121,7 +121,7 @@ function getPageContextInitEnhanced(pageContextInit, renderContext, { ssr: { url
     objectAssign(pageContextInitEnhanced, pageContextInit);
     objectAssign(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
-        // The following is defined on `pageContext` because we can eventually make these non-global (e.g. sot that two pages can have different includeAssetsImportedByServer settings)
+        // The following is defined on `pageContext` because we can eventually make these non-global
         _baseServer: globalContext.baseServer,
         _baseAssets: globalContext.baseAssets,
         _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,

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

@@ -2,7 +2,7 @@ export { renderPage };
 export { renderPage_addWrapper };
 import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, createUrlFromComponents, isUri, getUrlPretty } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
 import { getGlobalContext, initGlobalContext_renderPage } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -31,7 +31,7 @@ const renderPage_addWrapper = (wrapper) => {
 async function renderPage(pageContextInit) {
     assertArguments(...arguments);
     assert(hasProp(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
-    assertEnv();
+    onSetupRuntime();
     assertIsUrl(pageContextInit.urlOriginal);
     const urlPathnameWithBase = parseUrl(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
@@ -332,7 +332,9 @@ function assertIsUrl(urlOriginal) {
 }
 function assertIsNotViteRequest(urlPathname, urlOriginal) {
     const isViteRequest = urlPathname.startsWith('/@vite/client') || urlPathname.startsWith('/@fs/') || urlPathname.startsWith('/__vite_ping');
-    assertUsage(!isViteRequest, `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage) called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because this URL should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* Vike's middleware, see https://vike.dev/renderPage`);
+    if (!isViteRequest)
+        return;
+    assertUsage(false, `${pc.code('renderPage(pageContextInit)')} called with ${pc.code(`pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}`)} which is unexpected because the URL ${pc.bold(urlOriginal)} should have already been handled by the development middleware: make sure the ${pc.cyan('createDevMiddleware()')} middleware is executed *before* the ${pc.cyan('renderPage()')} middleware, see ${pc.underline('https://vike.dev/renderPage')}`);
 }
 function normalizeUrl(pageContextInit, httpRequestId) {
     const { trailingSlash, disableUrlNormalization, baseServer } = getGlobalContext();

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

@@ -39,9 +39,8 @@ export * from '../../utils/objectKeys.js';
 export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';
 export * from '../../utils/getFileExtension.js';
-export * from '../../utils/assertIsNotProductionRuntime.js';
+export * from '../../utils/assertSetup.js';
 export * from '../../utils/path-shim.js';
-export * from '../../utils/assertNodeEnv.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
 export * from '../../utils/stripAnsi.js';

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

@@ -43,9 +43,8 @@ export * from '../../utils/objectKeys.js';
 export * from '../../utils/objectEntries.js';
 export * from '../../utils/objectFromEntries.js';
 export * from '../../utils/getFileExtension.js';
-export * from '../../utils/assertIsNotProductionRuntime.js';
+export * from '../../utils/assertSetup.js';
 export * from '../../utils/path-shim.js';
-export * from '../../utils/assertNodeEnv.js';
 export * from '../../utils/isHtml.js';
 export * from '../../utils/warnIfErrorIsNotObject.js';
 export * from '../../utils/stripAnsi.js';

package/dist/esm/node/runtime-dev/createDevMiddleware.d.ts

@@ -0,0 +1,10 @@
+export { createDevMiddleware };
+import type { ResolvedConfig, Connect, ViteDevServer } from 'vite';
+import type { APIOptions } from '../api/types.js';
+declare function createDevMiddleware(options?: {
+    root?: string;
+} & APIOptions): Promise<{
+    devMiddleware: Connect.Server;
+    viteServer: ViteDevServer;
+    viteConfig: ResolvedConfig;
+}>;

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

@@ -0,0 +1,23 @@
+export { createDevMiddleware };
+import { createServer } from 'vite';
+import { prepareViteApiCall } from '../api/prepareViteApiCall.js';
+/*
+ * Create server middleware for development with HMR and lazy-transpiling.
+ *
+ * https://vike.dev/createDevMiddleware
+ */
+async function createDevMiddleware(options = {}) {
+    const viteConfig = {
+        ...options.viteConfig,
+        server: {
+            ...options.viteConfig?.server,
+            middlewareMode: options.viteConfig?.server?.middlewareMode ?? true
+        }
+    };
+    if (options.root)
+        viteConfig.root = options.root;
+    const { viteConfigEnhanced } = await prepareViteApiCall(viteConfig, 'dev');
+    const server = await createServer(viteConfigEnhanced);
+    const devMiddleware = server.middlewares;
+    return { devMiddleware, viteServer: server, viteConfig: server.config };
+}

package/dist/esm/node/runtime-dev/index.d.ts

@@ -0,0 +1,3 @@
+export { createDevMiddleware_ as createDevMiddleware };
+import type { createDevMiddleware as createDevMiddlewareType } from '../runtime-dev/createDevMiddleware.js';
+declare const createDevMiddleware_: typeof createDevMiddlewareType;

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

@@ -0,0 +1,6 @@
+export { createDevMiddleware_ as createDevMiddleware };
+const createDevMiddleware_ = async (...args) => {
+    const p = './createDevMiddleware.js';
+    const { createDevMiddleware } = await import(/*webpackIgnore: true*/ /* @vite-ignore */ p);
+    return createDevMiddleware(...args);
+};

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

@@ -0,0 +1,11 @@
+export { resolveBase };
+export { resolveBaseFromResolvedConfig };
+import type { ResolvedConfig } from 'vite';
+declare function resolveBaseFromResolvedConfig(baseServer: string | null, baseAssets: string | null, config: ResolvedConfig): {
+    baseServer: string;
+    baseAssets: string;
+};
+declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): {
+    baseServer: string;
+    baseAssets: string;
+};

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

@@ -0,0 +1,36 @@
+export { resolveBase };
+export { resolveBaseFromResolvedConfig };
+import { assert, assertUsage, isBaseServer, isBaseAssets } from './utils.js';
+import pc from '@brillout/picocolors';
+function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
+    let baseViteOriginal = config._baseViteOriginal;
+    if (baseViteOriginal === '/__UNSET__')
+        baseViteOriginal = null;
+    assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
+    return resolveBase(baseViteOriginal, baseServer, baseAssets);
+}
+function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
+    {
+        const wrongBase = (val) => `should start with ${pc.cyan('/')}, ${pc.cyan('http://')}, or ${pc.cyan('https://')} (it's ${pc.cyan(val)} instead)`;
+        assertUsage(baseViteOriginal === null || isBaseAssets(baseViteOriginal), `vite.config.js#base ${wrongBase(baseViteOriginal)}`);
+        assertUsage(baseAssetsUnresolved === null || isBaseAssets(baseAssetsUnresolved), `Config ${pc.cyan('baseAssets')} ${wrongBase(baseAssetsUnresolved)}`);
+        assertUsage(baseServerUnresolved === null || baseServerUnresolved.startsWith('/'), `Config ${pc.cyan('baseServer')} should start with a leading slash ${pc.cyan('/')} (it's ${pc.cyan(String(baseServerUnresolved))} instead)`);
+    }
+    if (baseViteOriginal) {
+        if (baseViteOriginal.startsWith('http')) {
+            baseAssetsUnresolved = baseAssetsUnresolved ?? baseViteOriginal;
+        }
+        else {
+            baseAssetsUnresolved = baseAssetsUnresolved ?? baseViteOriginal;
+            baseServerUnresolved = baseServerUnresolved ?? baseViteOriginal;
+        }
+    }
+    const baseServer = baseServerUnresolved ?? '/';
+    const baseAssets = baseAssetsUnresolved ?? '/';
+    assert(isBaseAssets(baseAssets));
+    assert(isBaseServer(baseServer));
+    return {
+        baseServer,
+        baseAssets
+    };
+}

package/dist/esm/shared/page-configs/Config.d.ts

@@ -35,7 +35,7 @@ import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { InjectFilterEntry } from '../../types/index.js';
-import type { ConfigVikeUserProvided } from '../ConfigVike.js';
+import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
@@ -43,7 +43,7 @@ type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
 type HookNameOldDesign = 'render' | 'prerender';
-type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);
 /** Hook for fetching data.
  *

package/dist/esm/shared/page-configs/getConfigValueBuildTime.js

@@ -1,6 +1,6 @@
 export { getConfigValueBuildTime };
 import { assert } from '../utils.js';
-import { assertIsNotProductionRuntime } from '../../utils/assertIsNotProductionRuntime.js';
+import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 import { getConfigValueTyped } from './getConfigValueTyped.js';
 assertIsNotProductionRuntime();
 function getConfigValueBuildTime(pageConfig, configName, type) {

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.js

@@ -1,5 +1,5 @@
 export { serializeConfigValues };
-import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
+import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
 import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
 import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
 import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformPointerImports.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.215";
+export declare const PROJECT_VERSION: "0.4.217";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.215';
+export const PROJECT_VERSION = '0.4.217';

package/dist/esm/utils/assertSetup.d.ts

@@ -0,0 +1,20 @@
+export { assertIsNotProductionRuntime };
+export { onSetupRuntime };
+export { onSetupBuild };
+export { onSetupPrerender };
+export { setNodeEnvProduction };
+export { markSetup_viteDevServer };
+export { markSetup_vitePreviewServer };
+export { markSetup_vikeVitePlugin };
+export { markSetup_isViteDev };
+export { markSetup_isPrerendering };
+declare function assertIsNotProductionRuntime(): void | undefined;
+declare function onSetupRuntime(): void | undefined;
+declare function onSetupBuild(): void;
+declare function onSetupPrerender(): void;
+declare function markSetup_viteDevServer(): void | undefined;
+declare function markSetup_vitePreviewServer(): void | undefined;
+declare function markSetup_vikeVitePlugin(): void;
+declare function markSetup_isViteDev(isViteDev: boolean): void;
+declare function markSetup_isPrerendering(): void;
+declare function setNodeEnvProduction(): void | undefined;