vike 0.4.164 → 0.4.165-commit-2598887

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

@@ -25,71 +25,81 @@ function buildConfig() {
     let isSsrBuild;
     let outDirs;
     let config;
-    return {
-        name: 'vike:buildConfig',
-        apply: 'build',
-        enforce: 'post',
-        configResolved: {
-            order: 'post',
-            async handler(config_) {
-                config = config_;
-                assertNodeEnv_build();
-                assertRollupInput(config);
-                const entries = await getEntries(config);
-                assert(Object.keys(entries).length > 0);
-                config.build.rollupOptions.input = injectRollupInputs(entries, config);
-                addLogHook();
-                outDirs = getOutDirs(config);
-                {
-                    isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
-                    if (isServerAssetsFixEnabled) {
-                        // https://github.com/vikejs/vike/issues/1339
-                        config.build.ssrEmitAssets = true;
-                        // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
-                        config.build.cssMinify = 'esbuild';
+    return [
+        {
+            name: 'vike:buildConfig:configResolved',
+            apply: 'build',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                async handler(config_) {
+                    config = config_;
+                    assertNodeEnv_build();
+                    assertRollupInput(config);
+                    const entries = await getEntries(config);
+                    assert(Object.keys(entries).length > 0);
+                    config.build.rollupOptions.input = injectRollupInputs(entries, config);
+                    addLogHook();
+                    outDirs = getOutDirs(config);
+                    {
+                        isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
+                        if (isServerAssetsFixEnabled) {
+                            // https://github.com/vikejs/vike/issues/1339
+                            config.build.ssrEmitAssets = true;
+                            // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
+                            config.build.cssMinify = 'esbuild';
+                        }
                     }
                 }
+            },
+            config(config) {
+                assertNodeEnv_build();
+                isSsrBuild = viteIsSSR(config);
+                return {
+                    build: {
+                        outDir: resolveOutDir(config),
+                        manifest: manifestTempFile,
+                        copyPublicDir: !isSsrBuild
+                    }
+                };
+            },
+            buildStart() {
+                assertNodeEnv_build();
             }
         },
-        config(config) {
-            assertNodeEnv_build();
-            isSsrBuild = viteIsSSR(config);
-            return {
-                build: {
-                    outDir: resolveOutDir(config),
-                    manifest: manifestTempFile,
-                    copyPublicDir: !isSsrBuild
-                }
-            };
-        },
-        buildStart() {
-            assertNodeEnv_build();
-        },
-        writeBundle: {
-            order: 'post',
-            sequential: true,
-            async handler(options, bundle) {
-                if (isSsrBuild) {
-                    // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
-                    //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
-                    //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
-                    const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
-                    const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
-                    const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
-                    if (!isServerAssetsFixEnabled) {
-                        await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
-                    }
-                    else {
-                        const clientManifestMod = await fixServerAssets(config);
-                        await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+        {
+            name: 'vike:buildConfig:writeBundle',
+            apply: 'build',
+            // Make sure other writeBundle() hooks are called after this writeBundle() hook.
+            //  - set_constant_ASSETS_MAP() needs to be called before dist/server/ code is executed.
+            //    - For example, the writeBundle() hook of vite-plugin-vercel needs to be called after this writeBundle() hook, otherwise: https://github.com/vikejs/vike/issues/1527
+            enforce: 'pre',
+            writeBundle: {
+                order: 'pre',
+                sequential: true,
+                async handler(options, bundle) {
+                    if (isSsrBuild) {
+                        // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
+                        //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
+                        //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
+                        const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
+                        const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
+                        const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+                        if (!isServerAssetsFixEnabled) {
+                            await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
+                        }
+                        else {
+                            const clientManifestMod = await fixServerAssets(config);
+                            await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+                        }
+                        await fs.rm(clientManifestFilePath);
+                        await fs.rm(serverManifestFilePath);
+                        await set_constant_ASSETS_MAP(options, bundle);
                     }
-                    await fs.rm(clientManifestFilePath);
-                    await fs.rm(serverManifestFilePath);
-                    await set_constant_ASSETS_MAP(options, bundle);
                 }
             }
         }
-    };
+    ];
 }
 async function getEntries(config) {
     const configVike = await getConfigVike(config);

package/dist/esm/node/plugin/shared/getHttpRequestAsyncStore.d.ts

@@ -4,7 +4,6 @@ type HttpRequestAsyncStore = {
     httpRequestId: number;
     shouldErrorBeSwallowed: (err: unknown) => boolean;
     markErrorAsLogged: (err: unknown) => void;
-    markErrorMessageAsLogged: (errMsg: string) => void;
     errorDebugNoteAlreadyShown: boolean;
 };
 declare function installHttpRequestAsyncStore(): Promise<void>;

package/dist/esm/node/plugin/shared/getHttpRequestAsyncStore.js

@@ -11,10 +11,11 @@
 export { getHttpRequestAsyncStore };
 export { installHttpRequestAsyncStore };
 import { renderPage_addWrapper } from '../../runtime/renderPage.js';
-import { assert, assertIsNotProductionRuntime, isObject } from '../utils.js';
+import { assert, assertIsNotProductionRuntime, isObject, unique } from '../utils.js';
 import { getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js';
 import { logErrorDebugNote } from './loggerNotProd.js';
 import { isEquivalentErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
+import { isDeepStrictEqual } from 'node:util';
 assertIsNotProductionRuntime();
 let asyncLocalStorage = null;
 async function installHttpRequestAsyncStore() {
@@ -44,29 +45,14 @@ async function installHttpRequestAsyncStore() {
                 return false;
             }
         };
-        // Remove once https://github.com/vitejs/vite/pull/13495 is released
-        const swallowedErrorMessages = new Set();
-        const markErrorMessageAsLogged = (errMsg) => {
-            swallowedErrorMessages.add(errMsg);
-        };
-        const onRequestDone = () => {
-            swallowedErrorMessages.forEach((errMsg) => {
-                if (!Array.from(loggedErrors).some((err) => String(err).includes(errMsg))) {
-                    console.error('loggedErrors', loggedErrors);
-                    console.error('swallowedErrorMessages', swallowedErrorMessages);
-                    assert(false);
-                }
-            });
-        };
         const store = {
             httpRequestId,
             markErrorAsLogged,
-            markErrorMessageAsLogged,
             shouldErrorBeSwallowed,
             errorDebugNoteAlreadyShown: false
         };
         const pageContextReturn = await asyncLocalStorage.run(store, renderPage);
-        return { pageContextReturn, onRequestDone };
+        return { pageContextReturn };
     });
     return;
 }
@@ -90,14 +76,20 @@ function isEquivalent(err1, err2) {
     }
     if (isEquivalentErrorWithCodeSnippet(err1, err2))
         return true;
-    if (err1.constructor === Error &&
-        Object.keys(err1).length === 0 &&
-        isDefinedAndSame(err1.message, err2.message) &&
-        isDefinedAndSame(err1.stack, err2.stack)) {
+    if (unique([
+        // error.message and error.stack aren't enumerable and therefore not listed by Object.keys()
+        'message',
+        'stack',
+        ...Object.keys(err1),
+        ...Object.keys(err2)
+    ]).every((k) => {
+        // isDeepStrictEqual() need to compare error.position wich is an object.
+        if (isDeepStrictEqual(err1[k], err2[k]))
+            return true;
+        // console.log('diff', k)
+        return false;
+    })) {
         return true;
     }
     return false;
 }
-function isDefinedAndSame(val1, val2) {
-    return val1 && val1 === val2;
-}

package/dist/esm/node/plugin/shared/loggerNotProd/errorWithCodeSnippet/fixture-errors/{errMdx.d.ts → errMdx1.d.ts}

@@ -1,4 +1,4 @@
-export declare const errMdx: {
+export declare const errMdx1: {
     name: string;
     message: string;
     reason: string;

package/dist/esm/node/plugin/shared/loggerNotProd/errorWithCodeSnippet/fixture-errors/{errMdx.js → errMdx1.js}

@@ -1,4 +1,4 @@
-export const errMdx = {
+export const errMdx1 = {
     name: '5:5-5:6',
     message: 'Unexpected closing slash `/` in tag, expected an open tag first',
     reason: 'Unexpected closing slash `/` in tag, expected an open tag first',

package/dist/esm/node/plugin/shared/loggerNotProd/errorWithCodeSnippet/fixture-errors/errMdx2.d.ts

@@ -0,0 +1,44 @@
+export declare const errMdx2: {
+    reason: string;
+    line: number;
+    column: number;
+    position: {
+        start: {
+            line: number;
+            column: number;
+            offset: number;
+            _index: number;
+            _bufferIndex: number;
+        };
+        end: {
+            line: number;
+            column: number;
+            offset: number;
+            _index: number;
+            _bufferIndex: number;
+        };
+    };
+    source: string;
+    ruleId: string;
+    plugin: string;
+    id: string;
+    pluginCode: string;
+    loc: {
+        file: string;
+        start: {
+            line: number;
+            column: number;
+            offset: number;
+            _index: number;
+            _bufferIndex: number;
+        };
+        end: {
+            line: number;
+            column: number;
+            offset: number;
+            _index: number;
+            _bufferIndex: number;
+        };
+    };
+    frame: string;
+};

package/dist/esm/node/plugin/shared/loggerNotProd/errorWithCodeSnippet/fixture-errors/errMdx2.js

@@ -0,0 +1,82 @@
+export const errMdx2 = {
+    reason: 'Unexpected closing slash `/` in tag, expected an open tag first',
+    line: 23,
+    column: 450,
+    position: {
+        start: {
+            line: 23,
+            column: 450,
+            offset: 1967,
+            _index: 0,
+            _bufferIndex: 444
+        },
+        end: {
+            line: 23,
+            column: 451,
+            offset: 1968,
+            _index: 0,
+            _bufferIndex: 445
+        }
+    },
+    source: 'mdast-util-mdx-jsx',
+    ruleId: 'unexpected-closing-slash',
+    plugin: '@mdx-js/rollup',
+    id: '/home/rom/code/vike/docs/pages/abort/+Page.mdx',
+    pluginCode: "import { Link } from '@brillout/docpress'\n" +
+        '\n' +
+        'By using <Link href="/render" text={<code>throw render()</code>}></Link> or <Link href="/redirect" text={<code>throw redirect()</code>}></Link> you abort the rendering of the current page and render something else instead.\n' +
+        '\n' +
+        `<h2 id="throw-redirect-vs-throw-render"><code>{'throw redirect()'}</code>{' VS '}<code>{'throw render()'}</code></h2>\n` +
+        '\n' +
+        'While `throw redirect()` changes the URL, `throw render()` preserves it:\n' +
+        " - If a user goes to `/admin` and `throw redirect('/login')` is called, then the user will see the new URL `/login` in the browser's address bar.\n" +
+        " - If a user goes to `/admin` and `throw render('/login')` is called, then the user keeps seeing the same URL `/admin` in the browser's address bar.\n" +
+        '\n' +
+        "In general, we recommend using `throw render('/login')` instead of `throw redirect('/login')` as it preserves the URL and, therefore, the user's intention. We further explain this techniue at <Link href=\"/auth#login-flow\" />.\n" +
+        '\n' +
+        '\n' +
+        `<h2 id="debug">{'Debug'}</h2>\n` +
+        '\n' +
+        "If `throw redirect()` or `throw render()` doesn't work:\n" +
+        " - **Make sure `throw redirect()` / `throw render()` isn't intercepted.**  \n" +
+        "   In developement, check your server logs for the following log. If this log is missing then it means that Vike didn't catch the `throw redirect()` / `throw render()` exception: some other code is intercepting it preventing Vike from catching it.\n" +
+        '   ```\n' +
+        "   10:00:00 AM [vike][request(42)] throw redirect('/some-url') intercepted while\n" +
+        '   rendering /some-other-url\n' +
+        '   ```\n' +
+        '   > Most notably, using `throw redirect()` / `throw render()` inside a UI component usually doesn\'t work because most <Link href="/ui-framework">UI framework</Link> will intercept the execption and thus Vike won\'t be able to catch it. Instead, consider using `throw redirect()` / `throw render()` in a Vike hook such as <Link href="/guard">guard()</Link> or <Link href="/data">data()</Link>, or consider using <Link href="/navigate" />`navigate()`</Link>.\n' +
+        ' - **Make sure to use `throw redirect()` / `throw render()` within a Vike hook.**  \n' +
+        "   If you use `throw redirect()` / `throw render()` outside of Vike hooks, for example in some server middleware code then Vike won't be able to intercept it.\n" +
+        '\n' +
+        "If `throw redirect()` doesn't work:\n" +
+        ' - **Make sure to add `pageContext.httpResponse.headers` to the HTTP response.**  \n' +
+        '   If you\'ve embedded Vike into your server using <Link text={<code>renderPage()</code>} href="/renderPage" />, then insepct whether `pageContext.httpResponse.headers` contains the `Location` header and double check that you\'re correctly adding all the headers defined by `pageContext.httpResponse.headers` to the HTTP response.\n' +
+        '\n' +
+        '\n' +
+        `<h2 id="see-also">{'See also'}</h2>\n` +
+        '\n' +
+        ' - <Link href="/redirect" />\n' +
+        ' - <Link href="/render" />\n' +
+        ' - <Link href="/navigate" />\n' +
+        '\n' +
+        '\n' +
+        'export const headings = [{"headingId":"throw-redirect-vs-throw-render","headingLevel":2,"title":"`throw redirect()` VS `throw render()`"}, {"headingId":"debug","headingLevel":2,"title":"Debug"}, {"headingId":"see-also","headingLevel":2,"title":"See also"}];\n',
+    loc: {
+        file: '/home/rom/code/vike/docs/pages/abort/+Page.mdx',
+        start: {
+            line: 23,
+            column: 450,
+            offset: 1967,
+            _index: 0,
+            _bufferIndex: 444
+        },
+        end: {
+            line: 23,
+            column: 451,
+            offset: 1968,
+            _index: 0,
+            _bufferIndex: 445
+        }
+    },
+    frame: ''
+};

package/dist/esm/node/plugin/shared/loggerNotProd.d.ts

@@ -1,5 +1,5 @@
 export { logViteAny };
-export { logViteErrorContainingCodeSnippet };
+export { logViteError };
 export { logConfigInfo };
 export { logConfigError };
 export { logConfigErrorRecover };
@@ -11,7 +11,6 @@ export type { LogError };
 export type { LogErrorArgs };
 export type { LogType };
 export type { LogCategory };
-import { type ErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 type LogType = 'info' | 'warn' | 'error' | 'error-recover';
 type LogCategory = 'config' | `request(${number})`;
 type LogInfo = (...args: LogInfoArgs) => void;
@@ -22,10 +21,8 @@ declare function logRuntimeInfo(msg: string, httpRequestId: number, logType: Log
 declare function logViteAny(msg: string, logType: LogType, httpRequestId: number | null, prependViteTag: boolean): void;
 declare function logConfigInfo(msg: string, logType: LogType): void;
 declare function logConfigErrorRecover(): void;
-declare function logRuntimeError(err: unknown, 
-/** `httpRequestId` is `null` when pre-rendering */
-httpRequestId: number | null): void;
-declare function logViteErrorContainingCodeSnippet(err: ErrorWithCodeSnippet): void;
+declare function logRuntimeError(err: unknown, httpRequestId: number | null): void;
+declare function logViteError(err: unknown, httpRequestId: number | undefined): void;
 declare function logConfigError(err: unknown): void;
 declare function clearLogs(conditions?: {
     clearErrors?: boolean;

package/dist/esm/node/plugin/shared/loggerNotProd.js

@@ -5,7 +5,7 @@
 //  - Pre-rendering
 // In other words: everywhere except in production
 export { logViteAny };
-export { logViteErrorContainingCodeSnippet };
+export { logViteError };
 export { logConfigInfo };
 export { logConfigError };
 export { logConfigErrorRecover };
@@ -54,14 +54,16 @@ function logConfigErrorRecover() {
     logWithVikeTag(msg, 'error-recover', category);
 }
 function logRuntimeError(err, 
-/** `httpRequestId` is `null` when pre-rendering */
+// httpRequestId is `null` when pre-rendering
 httpRequestId) {
-    logErr(err, httpRequestId);
+    logErr(err, httpRequestId, false);
 }
-function logViteErrorContainingCodeSnippet(err) {
-    logErr(err);
+function logViteError(err, 
+// httpRequestId is `undefined` if development environment doesn't support async stores
+httpRequestId) {
+    logErr(err, httpRequestId, true);
 }
-function logErr(err, httpRequestId = null) {
+function logErr(err, httpRequestId = null, errorComesFromVite) {
     warnIfErrorIsNotObject(err);
     if (isAbortError(err) && !isErrorDebug()) {
         return;
@@ -100,9 +102,10 @@ function logErr(err, httpRequestId = null) {
         logWithVikeTag(pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error', category);
     }
     else if (category) {
-        logFallbackErrIntro(category);
+        logFallbackErrIntro(category, errorComesFromVite);
     }
     logDirectly(err, 'error');
+    // Needs to be called after logging the error.
     onRuntimeError(err);
 }
 function logConfigError(err) {
@@ -137,11 +140,12 @@ function logConfigError(err) {
             return;
     }
     if (category)
-        logFallbackErrIntro(category);
+        logFallbackErrIntro(category, false);
     logDirectly(err, 'error');
 }
-function logFallbackErrIntro(category) {
-    logWithVikeTag(pc.bold(pc.red('[Error] An error was thrown:')), 'error', category);
+function logFallbackErrIntro(category, errorComesFromVite) {
+    const msg = errorComesFromVite ? 'Transpilation error' : 'An error was thrown';
+    logWithVikeTag(pc.bold(pc.red(`[Error] ${msg}:`)), 'error', category);
 }
 function getConfigCategory() {
     const category = getCategory() ?? 'config';

package/dist/esm/node/plugin/shared/loggerVite.js

@@ -1,11 +1,9 @@
 export { improveViteLogs };
 import { assert, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly } from '../utils.js';
-import { logViteErrorContainingCodeSnippet, logViteAny, clearLogs } from './loggerNotProd.js';
-import { isErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
+import { logViteError, logViteAny, clearLogs } from './loggerNotProd.js';
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { removeSuperfluousViteLog } from './loggerVite/removeSuperfluousViteLog.js';
 import { isErrorDebug } from './isErrorDebug.js';
-import { onRuntimeError } from '../../runtime/renderPage/loggerProd.js';
 function improveViteLogs(config) {
     intercept('info', config);
     intercept('warn', config);
@@ -25,29 +23,25 @@ function intercept(logType, config) {
         }
         msg = cleanFirstViteLog(msg);
         const store = getHttpRequestAsyncStore();
-        // Dedupe Vite error messages
-        if (options.error && store?.shouldErrorBeSwallowed(options.error)) {
+        if (options.error) {
+            // Vite does a poor job of handling errors.
+            //  - It doesn't format error code snippets.
+            //  - It only shows error.message which means that crucial information such as error.id isn't shown to the user.
+            logViteError(options.error, store?.httpRequestId);
+            // We swallow Vite's message: we didn't see it add any value so far.
+            //  - It can even be confusing, such as the following:
+            //    ```
+            //    Error when evaluating SSR module virtual:vike:pageConfigValuesAll:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
+            //    ```
+            assert(!isErrorDebug());
             return;
         }
-        // Remove this once https://github.com/vitejs/vite/pull/13495 is released and widely used
-        if (msg.startsWith('Transform failed with ') && store && logType === 'error') {
-            store.markErrorMessageAsLogged(msg);
-            return;
-        }
-        if (options.error && isErrorWithCodeSnippet(options.error)) {
-            logViteErrorContainingCodeSnippet(options.error);
-            return;
-        }
-        // Only allow Vite to clear its first log. All other clearing is controlled by vike.
+        // Only allow Vite to clear for its first log. All other clearing is controlled by vike.
         if (options.clear)
             clearLogs({ clearIfFirstLog: true });
-        if (options.error)
-            store?.markErrorAsLogged(options.error);
         // Vite's default logger preprends the "[vite]" tag if and only if options.timestamp is true
         const prependViteTag = options.timestamp || !!store?.httpRequestId;
         logViteAny(msg, logType, store?.httpRequestId ?? null, prependViteTag);
-        if (options.error)
-            onRuntimeError(options.error);
     };
 }
 function cleanFirstViteLog(msg) {

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

@@ -19,4 +19,4 @@ export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
-export * from '../../utils/isVersionOrAbove.js';
+export * from '../../utils/assertVersion.js';

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

@@ -25,4 +25,4 @@ export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
-export * from '../../utils/isVersionOrAbove.js';
+export * from '../../utils/assertVersion.js';

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

@@ -16,9 +16,13 @@ function logErrorProd(err, _httpRquestId) {
     // We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
     const errStr = isObject(err) && 'stack' in err ? String(err.stack) : String(err);
     console.error(pc.red(errStr));
+    // Needs to be called after logging the error.
     onRuntimeError(err);
 }
-// Every server-side runtime error is expected to go through onRuntimeError(). (In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.)
+// Every server-side runtime error is expected to go through `onRuntimeError()`.
+//  - onRuntimeError(err) should always be called after `console.error(err)`.
+//    - Because the error hint of logErrorHint(err) should be shown *after* the error.
+//  - In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.
 function onRuntimeError(err) {
     // The more runtime errors we pass to logErrorHint() the better.
     logErrorHint(err);

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

@@ -4,7 +4,6 @@ import { HttpResponse } from './renderPage/createHttpResponseObject.js';
 import type { PageContextBuiltInServer } from '../../types/index.js';
 declare let renderPage_wrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
     pageContextReturn: Awaited<PageContext>;
-    onRequestDone: () => void;
 }>;
 declare const renderPage_addWrapper: (wrapper: typeof renderPage_wrapper) => void;
 declare function renderPage<PageContextUserAdded extends {}, PageContextInit extends {

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

@@ -23,8 +23,7 @@ const globalObject = getGlobalObject('runtime/renderPage.ts', {
     pendingRequestsCount: 0
 });
 let renderPage_wrapper = async (_httpRequestId, ret) => ({
-    pageContextReturn: await ret(),
-    onRequestDone: () => { }
+    pageContextReturn: await ret()
 });
 const renderPage_addWrapper = (wrapper) => {
     renderPage_wrapper = wrapper;
@@ -43,10 +42,9 @@ async function renderPage(pageContextInit) {
     const { urlOriginal } = pageContextInit;
     logHttpRequest(urlOriginal, httpRequestId);
     globalObject.pendingRequestsCount++;
-    const { pageContextReturn, onRequestDone } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
+    const { pageContextReturn } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
     logHttpResponse(urlOriginal, httpRequestId, pageContextReturn);
     globalObject.pendingRequestsCount--;
-    onRequestDone();
     checkType(pageContextReturn);
     return pageContextReturn;
 }

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

@@ -2,7 +2,7 @@ export type { PageContextConfig };
 import type { VikePackages } from '../../VikeNamespace.js';
 import type { ConfigBuiltIn } from '../Config.js';
 import type { Combine, IsNotEmpty, XOR5 } from './helpers.ts';
-type PageContextConfig = ConfigBuiltIn & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
+type PageContextConfig = ConfigBuiltIn & Vike.Config & (ConfigVikePackagesNotEmptyXor extends true ? ConfigVikePackagesIntersection : ConfigVikePackagesCombined);
 type ConfigVikePackagesIntersection = VikePackages.ConfigVikeReact & VikePackages.ConfigVikeVue & VikePackages.ConfigVikeSolid & VikePackages.ConfigVikeSvelte & VikePackages.ConfigVikeAngular;
 type ConfigVikePackagesCombined = Combine<VikePackages.ConfigVikeReact, Combine<VikePackages.ConfigVikeVue, Combine<VikePackages.ConfigVikeSolid, Combine<VikePackages.ConfigVikeSvelte, VikePackages.ConfigVikeAngular>>>>;
 type ConfigVikePackagesNotEmptyXor = XOR5<IsNotEmpty<VikePackages.ConfigVikeReact>, IsNotEmpty<VikePackages.ConfigVikeVue>, IsNotEmpty<VikePackages.ConfigVikeSolid>, IsNotEmpty<VikePackages.ConfigVikeSvelte>, IsNotEmpty<VikePackages.ConfigVikeAngular>>;

package/dist/esm/shared/route/resolveRouteString.js

@@ -108,7 +108,6 @@ function parseRouteString(routeString) {
     return segments;
 }
 function getUrlFromRouteString(routeString) {
-    assert(routeString.startsWith('/'));
     if (isStaticRouteString(routeString)) {
         const url = routeString;
         return url;

package/dist/esm/utils/assertNodeVersion.js

@@ -1,11 +1,10 @@
 export { assertNodeVersion };
-import { assertUsage } from './assert.js';
 import { isNodeJS } from './isNodeJS.js';
-import { isVersionOrAbove } from './isVersionOrAbove.js';
-// package.json#engines.node isn't enough as users can ignore it
+import { assertVersion } from './assertVersion.js';
+// node_modules/vike/package.json#engines.node isn't enough as users can ignore it
 function assertNodeVersion() {
     if (!isNodeJS())
         return;
     const version = process.versions.node;
-    assertUsage(isVersionOrAbove(version, '16.0.0'), `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
+    assertVersion('Node.js', version, '16.0.0');
 }

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

@@ -0,0 +1,4 @@
+export { assertVersion };
+export { isVersionOrAbove };
+declare function assertVersion(dependencyName: 'Vite' | 'Node.js', versionActual: string, versionExpected: `${number}.${number}.${number}`): void;
+declare function isVersionOrAbove(versionActual: string, versionExpected: `${number}.${number}.${number}`): boolean;

package/dist/esm/utils/{isVersionOrAbove.js → assertVersion.js}

@@ -1,5 +1,9 @@
+export { assertVersion };
 export { isVersionOrAbove };
-import { assert } from './assert.js';
+import { assert, assertUsage } from './assert.js';
+function assertVersion(dependencyName, versionActual, versionExpected) {
+    assertUsage(isVersionOrAbove(versionActual, versionExpected), `${dependencyName} ${versionActual} isn't supported, use ${dependencyName} >= ${versionExpected} instead.`);
+}
 function isVersionOrAbove(versionActual, versionExpected) {
     const p1 = parseVersion(versionActual);
     const p2 = parseVersion(versionExpected);

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

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.164";
+declare const PROJECT_VERSION: "0.4.165-commit-2598887";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.164";
+    projectVersion: "0.4.165-commit-2598887";
 };