vike 0.4.231-commit-e1c3295 → 0.4.232-commit-134207d

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

@@ -26,17 +26,18 @@ export { vikeConfigErrorRecoverMsg };
 //   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
 // - In development: globalObject.viteDevServer which is Vite's development server
 //   - globalObject.viteDevServer is used by updateUserFiles() which then sets virtualFileExports
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, getGlobalObject, genPromise, createDebugger, checkType, PROJECT_VERSION } from './utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, getGlobalObject, genPromise, createDebugger, checkType, PROJECT_VERSION, } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
 import { virtualFileIdEntryServer } from '../shared/virtualFiles/virtualFileEntry.js';
 import pc from '@brillout/picocolors';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
 import { resolveBase } from '../shared/resolveBase.js';
-import { createGlobalContextShared, getGlobalContextSyncErrMsg } from '../../shared/createGlobalContextShared.js';
+import { createGlobalContextShared, getGlobalContextSyncErrMsg, } from '../../shared/createGlobalContextShared.js';
 import { prepareGlobalContextForPublicUsage } from '../../shared/prepareGlobalContextForPublicUsage.js';
-import { renderPage_vikeConfigHasError } from './renderPage.js';
-import { logRuntimeInfo } from './loggerRuntime.js';
+import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
+import { getVikeConfigErrorBuild, setVikeConfigError } from '../shared/getVikeConfigError.js';
+import { hasAlreadyLogged } from './renderPage/isNewError.js';
 const debug = createDebugger('vike:globalContext');
 const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGlobalContext());
 // Trick to break down TypeScript circular dependency
@@ -122,7 +123,7 @@ async function setGlobalContext_viteDevServer(viteDevServer) {
     setIsProduction(false);
     // We cannot cache globalObject.viteDevServer because it's fully replaced when the user modifies vite.config.js => Vite's dev server is fully reloaded and a new viteDevServer replaces the previous one.
     if (!globalObject.viteDevServer) {
-        assertIsNotInitilizedYet();
+        assertIsNotInitializedYet();
     }
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
@@ -135,11 +136,11 @@ async function setGlobalContext_viteDevServer(viteDevServer) {
 function setGlobalContext_viteConfig(viteConfig, viteConfigRuntime) {
     if (globalObject.viteConfig)
         return;
-    assertIsNotInitilizedYet();
+    assertIsNotInitializedYet();
     globalObject.viteConfig = viteConfig;
     globalObject.viteConfigRuntime = viteConfigRuntime;
 }
-function assertIsNotInitilizedYet() {
+function assertIsNotInitializedYet() {
     // In development, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     assert(!globalObject.globalContext);
 }
@@ -163,7 +164,7 @@ function getViteConfig() {
 }
 async function initGlobalContext_renderPage() {
     debug('initGlobalContext_renderPage()');
-    // `globalObject.isProduction === undefined` when using production server without `vike-server`. (There isn't any reliable signal we can use to determine early whether the environement is production or development.)
+    // `globalObject.isProduction === undefined` when using production server without `vike-server`. (There isn't any reliable signal we can use to determine early whether the environment is production or development.)
     if (globalObject.isProduction === undefined)
         setIsProduction(true);
     await initGlobalContext();
@@ -180,7 +181,7 @@ async function initGlobalContext_runPrerender() {
     // We assume initGlobalContext_runPrerender() to be called before:
     // - initGlobalContext_renderPage()
     // - initGlobalContext_getGlobalContextAsync()
-    assertIsNotInitilizedYet();
+    assertIsNotInitializedYet();
     await initGlobalContext();
 }
 async function initGlobalContext_getGlobalContextAsync() {
@@ -300,8 +301,10 @@ async function updateUserFiles() {
     globalObject.waitForUserFilesUpdateResolve ?? (globalObject.waitForUserFilesUpdateResolve = []);
     globalObject.waitForUserFilesUpdateResolve.push(resolve);
     const onError = (err) => {
-        console.error(err);
-        renderPage_vikeConfigHasError({ hasRuntimeError: { err } });
+        if (!hasAlreadyLogged(err)) {
+            logRuntimeError(err, null);
+        }
+        setVikeConfigError({ errorRuntime: { err } });
         globalObject.vikeConfigHasRuntimeError = true;
         return { success: false };
     };
@@ -311,7 +314,7 @@ async function updateUserFiles() {
             logRuntimeInfo(vikeConfigErrorRecoverMsg, null, 'error-recover');
         }
         globalObject.vikeConfigHasRuntimeError = false;
-        renderPage_vikeConfigHasError({ hasRuntimeError: false });
+        setVikeConfigError({ errorRuntime: false });
         globalObject.waitForUserFilesUpdateResolve.forEach((resolve) => resolve());
         globalObject.waitForUserFilesUpdateResolve = [];
         resolve();
@@ -340,6 +343,9 @@ async function updateUserFiles() {
     if (hasError)
         return onError(err);
     virtualFileExports = virtualFileExports.default || virtualFileExports;
+    if (getVikeConfigErrorBuild()) {
+        return { success: false };
+    }
     try {
         await setGlobalContext(virtualFileExports);
     }
@@ -354,6 +360,7 @@ async function updateUserFiles() {
     return onSuccess();
 }
 async function setGlobalContext(virtualFileExports) {
+    assert(!getVikeConfigErrorBuild());
     const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext);
     assertV1Design(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
@@ -368,7 +375,7 @@ async function addGlobalContext(globalContext) {
     const globalContextBase = {
         isClientSide: false,
         _pageRoutes: pageRoutes,
-        _onBeforeRouteHook: onBeforeRouteHook
+        _onBeforeRouteHook: onBeforeRouteHook,
     };
     const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction } = globalObject;
     assert(typeof isProduction === 'boolean');
@@ -386,7 +393,7 @@ async function addGlobalContext(globalContext) {
             assetsManifest: null,
             _viteDevServer: viteDevServer,
             viteConfig,
-            viteConfigRuntime
+            viteConfigRuntime,
         };
     }
     else {
@@ -402,21 +409,21 @@ async function addGlobalContext(globalContext) {
             assetsManifest,
             _viteDevServer: null,
             viteConfigRuntime: buildInfo.viteConfigRuntime,
-            _usesClientRouter: buildInfo.usesClientRouter
+            _usesClientRouter: buildInfo.usesClientRouter,
         };
         if (isPrerendering) {
             assert(viteConfig);
             return {
                 ...globalContextBase2,
                 _isPrerendering: true,
-                viteConfig
+                viteConfig,
             };
         }
         else {
             return {
                 ...globalContextBase2,
                 _isPrerendering: false,
-                viteConfig: null
+                viteConfig: null,
             };
         }
     }
@@ -430,7 +437,7 @@ function getInitialGlobalContext() {
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
     return {
         viteDevServerPromise,
-        viteDevServerPromiseResolve
+        viteDevServerPromiseResolve,
     };
 }
 function resolveBaseRuntime(viteConfigRuntime, config) {

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -1,7 +1,7 @@
 import { isFontFallback } from '../../renderPage/isFontFallback.js';
 export { getHtmlTags };
 import { assert, assertWarning, assertUsage, isObject, freezePartial } from '../../utils.js';
-import { getGlobalContextClientSerialized, getPageContextClientSerialized } from '../serializeContext.js';
+import { getGlobalContextClientSerialized, getPageContextClientSerialized, } from '../serializeContext.js';
 import { sanitizeJson } from './sanitizeJson.js';
 import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
@@ -23,7 +23,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             // We could allow the user to change the position of <script> but we currently don't:
             //  - Because of mergeScriptEntries()
             //  - We would need to add HTML_STREAM to to PreloadFilterInject
-            // To suppor this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
+            // To support this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
             return false;
         }
         return true;
@@ -51,7 +51,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             ...asset,
             inject,
             // @ts-ignore
-            [stamp]: true
+            [stamp]: true,
         };
         injectFilterEntries.push(entry);
     });
@@ -126,14 +126,14 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getPageContextJsonScriptTag(pageContext),
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
         // <script id="vike_globalContext" type="application/json">
         htmlTags.push({
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getGlobalContextJsonScriptTag(pageContext),
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
     }
     // The JavaScript entry <script> tag
@@ -141,7 +141,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
     if (scriptEntry) {
         htmlTags.push({
             htmlTag: scriptEntry,
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
     }
     // Preload tags
@@ -216,12 +216,12 @@ function checkForWarnings(injectFilterEntries) {
             //  - https://github.com/vitejs/vite/issues/2282
             //  - https://github.com/vikejs/vike/issues/261
             assertWarning(a.inject, `[injectFilter()] We recommend against not injecting ${a.src}`, {
-                onlyOnce: true
+                onlyOnce: true,
             });
         }
         if (a.assetType === 'script') {
             assertWarning(a.inject, `[injectFilter()] We recommend against not preloading JavaScript (${a.src})`, {
-                onlyOnce: true
+                onlyOnce: true,
             });
         }
     });

package/dist/esm/node/runtime/html/injectAssets/getViteDevScript.js

@@ -18,7 +18,7 @@ async function getViteDevScript(pageContext) {
     const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
     assert(viteInjection.includes('script'));
     assertWarning(!viteInjection.includes('import('), `Unexpected Vite injected HMR code. ${reachOutCTA}`, {
-        onlyOnce: true
+        onlyOnce: true,
     });
     const viteDevScript = viteInjection;
     return viteDevScript;

package/dist/esm/node/runtime/html/injectAssets/inferHtmlTags.js

@@ -14,7 +14,7 @@ function inferPreloadTag(pageAsset) {
         !assetType ? null : `as="${assetType}"`,
         !mediaType ? null : `type="${mediaType}"`,
         // `crossorigin` is needed for fonts, see https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#cors-enabled_fetches
-        !isCrossOrigin(pageAsset) ? null : 'crossorigin'
+        !isCrossOrigin(pageAsset) ? null : 'crossorigin',
     ]
         .filter(Boolean)
         .join(' ');

package/dist/esm/node/runtime/html/injectAssets/injectAssets__public.js

@@ -6,22 +6,22 @@ async function injectAssets__public(htmlString, pageContext) {
     assertWarning(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
     assertUsage(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });
     assertUsage(pageContext, '[injectAssets(htmlString, pageContext)]: Argument `pageContext` is missing.', {
-        showStackTrace: true
+        showStackTrace: true,
     });
     const errMsg = (body) => '[injectAssets(htmlString, pageContext)]: ' +
         body +
         '. Make sure that `pageContext` is the object that Vike provided to your `render(pageContext)` hook.';
     assertUsage(hasProp(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(hasProp(pageContext, 'pageId', 'string'), errMsg('`pageContext.pageId` should be a string'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(hasProp(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(hasProp(pageContext, '_passToClient', 'string[]'), errMsg('`pageContext._passToClient` is missing'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     castProp(pageContext, '__getPageAssets');
     htmlString = await injectHtmlTagsToString([htmlString], pageContext, null);

package/dist/esm/node/runtime/html/injectAssets/injectHtmlTags.js

@@ -29,7 +29,7 @@ function joinHtmlTags(htmlTags) {
 function injectHtmlFragment(position, htmlFragment, htmlString) {
     if (position === 'HTML_BEGIN') {
         {
-            const res = injectAtPaceholder(htmlFragment, htmlString, true);
+            const res = injectAtPlaceholder(htmlFragment, htmlString, true);
             if (res)
                 return res;
         }
@@ -39,7 +39,7 @@ function injectHtmlFragment(position, htmlFragment, htmlString) {
     }
     if (position === 'HTML_END') {
         {
-            const res = injectAtPaceholder(htmlFragment, htmlString, false);
+            const res = injectAtPlaceholder(htmlFragment, htmlString, false);
             if (res)
                 return res;
         }
@@ -148,7 +148,7 @@ function getTagClosing(tag) {
     const tagClosing = new RegExp(`</${tag}>`, 'i');
     return tagClosing;
 }
-function injectAtPaceholder(htmlFragment, htmlString, isFirst) {
+function injectAtPlaceholder(htmlFragment, htmlString, isFirst) {
     const placeholder = isFirst ? '__VITE_PLUGIN_SSR__ASSETS_FIRST__' : '__VITE_PLUGIN__SSR_ASSETS_LAST__';
     const parts = htmlString.split(placeholder);
     if (parts.length === 1)

package/dist/esm/node/runtime/html/injectAssets.js

@@ -2,7 +2,7 @@ export { injectHtmlTagsToString };
 export { injectHtmlTagsToStream };
 import { assert, isCallable, isPromise } from '../utils.js';
 import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
-import { joinHtmlTags, injectHtmlTags, createHtmlHeadIfMissing, injectHtmlTagsUsingStream } from './injectAssets/injectHtmlTags.js';
+import { joinHtmlTags, injectHtmlTags, createHtmlHeadIfMissing, injectHtmlTagsUsingStream, } from './injectAssets/injectHtmlTags.js';
 import { getHtmlTags } from './injectAssets/getHtmlTags.js';
 import { getViteDevScript } from './injectAssets/getViteDevScript.js';
 async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
@@ -20,7 +20,7 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
     return {
         injectAtStreamBegin,
         injectAtStreamAfterFirstChunk,
-        injectAtStreamEnd
+        injectAtStreamEnd,
     };
     async function injectAtStreamBegin(htmlPartsBegin) {
         const pageAssets = await pageContext.__getPageAssets();

package/dist/esm/node/runtime/html/renderHtml.js

@@ -3,9 +3,9 @@ export { dangerouslySkipEscape };
 export { renderDocumentHtml };
 export { isDocumentHtml };
 export { getHtmlString };
-import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isHtml, isPromise, objectAssign } from '../utils.js';
+import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isHtml, isPromise, objectAssign, } from '../utils.js';
 import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
-import { processStream, isStream, streamToString } from './stream.js';
+import { processStream, isStream, streamToString, } from './stream.js';
 import { isStreamFromReactStreamingPackage } from './stream/react-streaming.js';
 import pc from '@brillout/picocolors';
 function isDocumentHtml(something) {
@@ -42,7 +42,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
             const { htmlStream } = render;
             const streamWrapper = await renderHtmlStream(htmlStream, {
                 htmlPartsBegin: render.htmlPartsBegin,
-                htmlPartsEnd: render.htmlPartsEnd
+                htmlPartsEnd: render.htmlPartsEnd,
             }, pageContext, onErrorWhileStreaming, injectFilter);
             return streamWrapper;
         }
@@ -53,7 +53,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
 async function renderHtmlStream(streamOriginal, injectString, pageContext, onErrorWhileStreaming, injectFilter) {
     const processStreamOptions = {
         onErrorWhileStreaming,
-        enableEagerStreaming: pageContext.enableEagerStreaming
+        enableEagerStreaming: pageContext.enableEagerStreaming,
     };
     if (injectString) {
         let streamFromReactStreamingPackage = null;
@@ -107,8 +107,8 @@ function escapeInject(templateStrings, ...templateVariables) {
     return {
         _template: {
             templateStrings,
-            templateVariables: templateVariables
-        }
+            templateVariables: templateVariables,
+        },
     };
 }
 function dangerouslySkipEscape(alreadyEscapedString) {
@@ -125,7 +125,7 @@ function _dangerouslySkipEscape(arg) {
     }
     assertWarning(false, `[dangerouslySkipEscape(${pc.cyan('str')})] Argument ${pc.cyan('str')} should be a string but we got ${pc.cyan(`typeof str === "${typeof arg}"`)}.`, {
         onlyOnce: false,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { _escaped: String(arg) };
 }
@@ -180,7 +180,7 @@ function renderTemplate(templateContent, pageContext) {
             const nth = (i === 0 && '1st') || (i === 1 && '2nd') || (i === 2 && '3rd') || `${i}-th`;
             return [
                 `The ${nth} HTML variable is ${msg}`,
-                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`
+                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`,
             ]
                 .filter(Boolean)
                 .join(' ');
@@ -219,13 +219,13 @@ function renderTemplate(templateContent, pageContext) {
     if (htmlStream === null) {
         assert(htmlPartsEnd.length === 0);
         return {
-            htmlPartsAll: htmlPartsBegin
+            htmlPartsAll: htmlPartsBegin,
         };
     }
     return {
         htmlStream,
         htmlPartsBegin,
-        htmlPartsEnd
+        htmlPartsEnd,
     };
 }
 async function getHtmlString(htmlRender) {

package/dist/esm/node/runtime/html/serializeContext.js

@@ -22,7 +22,7 @@ const passToClientBuiltInPageContext = [
     pageContextInitIsPassedToClient,
     'pageId',
     'routeParams',
-    'data' // for data() hook
+    'data', // for data() hook
 ];
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
 function getPageContextClientSerialized(pageContext) {
@@ -73,7 +73,7 @@ function serializeObject(obj, objName, passToClient) {
                 // Non-serializable property set by the user
                 let msg = [
                     `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
-                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`
+                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`,
                 ].join(' ');
                 if (isJsonSerializerError(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
@@ -133,7 +133,7 @@ function getPageContextClientSerializedAbort(pageContext) {
         'abortStatusCode',
         'abortReason',
         'is404',
-        'pageProps'
+        'pageProps',
     ].includes(prop));
     if (!pageContext._isLegacyRenderErrorPage) {
         assert(unknownProps.length === 0);
@@ -143,9 +143,9 @@ function getPageContextClientSerializedAbort(pageContext) {
         assertWarning(unknownProps.length === 0, [
             "The following pageContext values won't be available on the client-side:",
             unknownProps.map((p) => `  pageContext[${JSON.stringify(p)}]`),
-            'Use `throw render()` instead of `throw RenderErrorPage()`'
+            'Use `throw render()` instead of `throw RenderErrorPage()`',
         ].join('\n'), {
-            onlyOnce: false
+            onlyOnce: false,
         });
     }
     return serializeValue(pageContext);

package/dist/esm/node/runtime/html/stream.d.ts

@@ -50,7 +50,7 @@ declare function getStreamReadableNode(htmlRender: HtmlRender): Promise<null | S
 declare function getStreamReadableWeb(htmlRender: HtmlRender): null | StreamReadableWeb;
 declare function pipeToStreamWritableWeb(htmlRender: HtmlRender, writable: StreamWritableWeb): boolean;
 declare function pipeToStreamWritableNode(htmlRender: HtmlRender, writable: StreamWritableNode): boolean;
-declare function processStream(streamOriginal: StreamProviderAny, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }: {
+declare function processStream(streamOriginal: StreamProviderAny, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, }: {
     injectStringAtBegin?: () => Promise<string>;
     injectStringAfterFirstChunk?: () => string | null;
     injectStringAtEnd?: () => Promise<string>;

package/dist/esm/node/runtime/html/stream.js

@@ -19,8 +19,8 @@ export { streamReadableWebToString };
 export { streamPipeNodeToString };
 export { isStreamWritableWeb };
 export { isStreamWritableNode };
-import { assert, assertUsage, checkType, isObject, hasProp, objectAssign, capitalizeFirstLetter, assertWarning, isCallable, createDebugger, isBug } from '../utils.js';
-import { getStreamOfReactStreamingPackage, isStreamFromReactStreamingPackage, streamFromReactStreamingPackageToString } from './stream/react-streaming.js';
+import { assert, assertUsage, checkType, isObject, hasProp, objectAssign, capitalizeFirstLetter, assertWarning, isCallable, createDebugger, isBug, } from '../utils.js';
+import { getStreamOfReactStreamingPackage, isStreamFromReactStreamingPackage, streamFromReactStreamingPackageToString, } from './stream/react-streaming.js';
 import { import_ } from '@brillout/import';
 import pc from '@brillout/picocolors';
 const debug = createDebugger('vike:stream');
@@ -77,7 +77,7 @@ function stringToStreamReadableWeb(str) {
         start(controller) {
             controller.enqueue(encodeForWebStream(str));
             controller.close();
-        }
+        },
     });
     return readableStream;
 }
@@ -121,7 +121,7 @@ async function streamPipeNodeToString(streamPipeNode) {
             else {
                 resolve();
             }
-        }
+        },
     });
     streamPipeNode(writable);
     return promise;
@@ -138,7 +138,7 @@ function streamPipeWebToString(streamPipeWeb) {
         close() {
             str += getClosingChunk();
             resolve(str);
-        }
+        },
     });
     streamPipeWeb(writable);
     return promise;
@@ -212,7 +212,7 @@ function pipeToStreamWritableNode(htmlRender, writable) {
     checkType(htmlRender);
     assert(false);
 }
-async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }) {
+async function processStream(streamOriginal, { injectStringAtBegin, injectStringAfterFirstChunk, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming, }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
     let streamOriginalEnded = false;
@@ -310,7 +310,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         },
         onFlush() {
             flushStream();
-        }
+        },
     });
     wrapperCreated = true;
     flushBuffer(); // In case onReadyToWrite() was already called (the flushBuffer() of onReadyToWrite() wasn't called because `wrapperCreated === false`)
@@ -373,7 +373,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         return !enableEagerStreaming && !streamOriginalHasStartedEmitting;
     }
 }
-async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite }) {
+async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onFlush, onReadyToWrite, }) {
     if (isStreamFromReactStreamingPackage(streamOriginal)) {
         debug(`onRenderHtml() hook returned ${pc.cyan('react-streaming')} result`);
         const stream = getStreamOfReactStreamingPackage(streamOriginal);
@@ -429,13 +429,13 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 }
                 callback(err);
                 endStream();
-            }
+            },
         });
         // Forward the flush() call
         objectAssign(writableProxy, {
             flush: () => {
                 onFlush();
-            }
+            },
         });
         assert(typeof writableProxy.flush === 'function');
         const pipeOriginal = getStreamPipeNode(streamOriginal);
@@ -492,7 +492,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 abort(err) {
                     onError(err);
                     endStream();
-                }
+                },
             });
         }
         else {
@@ -507,7 +507,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                 async onEnd() {
                     await onEnd();
                     endStream();
-                }
+                },
             });
         }
         const pipeOriginal = getStreamPipeWeb(streamOriginal);
@@ -540,15 +540,15 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                     },
                     async onEnd() {
                         await closeStream();
-                    }
+                    },
                 });
             },
             async cancel(...args) {
                 isCancel = true;
                 await readableOriginal.cancel(...args);
-                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therfore closeStream() may already have been called at this point
+                // If readableOriginal has implemented readableOriginal.cancel() then the onEnd() callback and therefore closeStream() may already have been called at this point
                 await closeStream();
-            }
+            },
         });
         const writeChunk = (chunk) => {
             if (
@@ -565,7 +565,7 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const flushStream = null;
         return {
             streamWrapper: readableProxy,
-            streamWrapperOperations: { writeChunk, flushStream }
+            streamWrapperOperations: { writeChunk, flushStream },
         };
     }
     if (isStreamReadableNode(streamOriginal)) {
@@ -600,12 +600,12 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         });
         return {
             streamWrapper: readableProxy,
-            streamWrapperOperations: { writeChunk, flushStream }
+            streamWrapperOperations: { writeChunk, flushStream },
         };
     }
     assert(false);
 }
-async function handleReadableWeb(readable, { onData, onError, onEnd }) {
+async function handleReadableWeb(readable, { onData, onError, onEnd, }) {
     const reader = readable.getReader();
     while (true) {
         let result;
@@ -640,7 +640,7 @@ const __streamPipeWeb = '__streamPipeWeb';
 function pipeWebStream(pipe) {
     assertWarning(false, 'pipeWebStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { [__streamPipeWeb]: pipe };
 }
@@ -675,7 +675,7 @@ const __streamPipeNode = '__streamPipeNode';
 function pipeNodeStream(pipe) {
     assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/streaming', {
         onlyOnce: true,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { [__streamPipeNode]: pipe };
 }
@@ -707,7 +707,7 @@ function isStreamPipeNode(thing) {
 }
 function stampPipe(pipe, pipeType) {
     assertUsage(pipeType, `stampPipe(pipe, pipeType): argument ${pc.cyan('pipeType')} is missing.)`, {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(['web-stream', 'node-stream'].includes(pipeType), `stampPipe(pipe, pipeType): argument ${pc.cyan('pipeType')} should be either ${pc.cyan("'web-stream'")} or ${pc.cyan("'node-stream'")}.`, { showStackTrace: true });
     if (pipeType === 'node-stream') {

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

@@ -7,8 +7,8 @@ assertWarning(false, [
     'You have outdated imports:',
     pc.bold(pc.red("  import { something } from 'vike/server'")),
     'Replace them with:',
-    pc.bold(pc.green("  import { something } from 'vike'"))
-    /* Add migration guide, with migration scritps such as `$ rename vike/server vike`
+    pc.bold(pc.green("  import { something } from 'vike'")),
+    /* Add migration guide, with migration scripts such as `$ rename vike/server vike`
     `See ${pc.underline('https://vike.dev/migration/0.4.xxx')}`
     */
 ].join('\n'), { showStackTrace: true, onlyOnce: true });

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

@@ -33,7 +33,7 @@ export const RenderErrorPage = (...args) => {
         pc.red("  import { RenderErrorPage } from 'vike'"),
         'With:',
         pc.green("  import { render } from 'vike/abort'"),
-        'See https://vike.dev/render'
+        'See https://vike.dev/render',
     ].join('\n'), { onlyOnce: true, showStackTrace: true });
     return RenderErrorPage_(...args);
 };