vike 0.4.149 → 0.4.150-commit-d0822a3

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -36,6 +36,9 @@ const configDefinitionsBuiltIn = {
     guard: {
         env: { server: true, client: 'if-client-routing' }
     },
+    data: {
+        env: { server: true }
+    },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
         env: { server: true, client: 'if-client-routing', eager: true }
     },
@@ -76,6 +79,10 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     },
+    dataEnv: {
+        env: { client: true },
+        _computed: (configValueSources) => !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data')
+    },
     hooksTimeout: {
         env: { server: true, client: true }
     }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -120,5 +120,5 @@ async function isUsingGit(userRootDir) {
 async function runCmd(cmd, cwd) {
     const res = await execA(cmd, { cwd });
     assert(res.stderr === '');
-    return res.stdout.toString().trim().split('\n');
+    return res.stdout.toString().split('\n').filter(Boolean);
 }

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

@@ -18,3 +18,4 @@ export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
+export * from '../../utils/injectRollupInputs.js';

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

@@ -24,3 +24,4 @@ export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
+export * from '../../utils/injectRollupInputs.js';

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

@@ -16,7 +16,8 @@ const PASS_TO_CLIENT = [
     '_abortCaller',
     */
     '_pageContextInitHasClientData',
-    '_pageId'
+    '_pageId',
+    'data' // for data() hook
 ];
 const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', '_isError'];
 function serializePageContextClientSide(pageContext) {

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

@@ -205,7 +205,9 @@ function pipeToStreamWritableNode(htmlRender, writable) {
 async function processStream(streamOriginal, { injectStringAtBegin, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }) {
     const buffer = [];
     let streamOriginalHasStartedEmitting = false;
-    let streamEnded = false;
+    let streamOriginalEnded = false;
+    let streamClosed = false;
+    let onEndWasCalled = false;
     let isReadyToWrite = false;
     let wrapperCreated = false;
     let shouldFlushStream = false;
@@ -229,6 +231,14 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
         writeStream(injectionBegin); // Adds injectionBegin to buffer
         flushStream(); // Sets shouldFlushStream to true
     }
+    // We call onStreamEvent() also when the stream ends in order to properly handle the situation when the stream didn't emit any data
+    const onStreamDataOrEnd = (cb) => {
+        assert(streamOriginalEnded === false);
+        streamOriginalHasStartedEmitting = true;
+        cb();
+        if (wrapperCreated)
+            resolvePromise();
+    };
     const { streamWrapper, streamWrapperOperations } = await createStreamWrapper({
         streamOriginal,
         onReadyToWrite() {
@@ -246,19 +256,21 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
             }
         },
         onData(chunk) {
-            assert(streamEnded === false);
-            streamOriginalHasStartedEmitting = true;
-            writeStream(chunk);
-            if (wrapperCreated)
-                resolvePromise();
+            onStreamDataOrEnd(() => {
+                writeStream(chunk);
+            });
         },
-        async onEnd() {
+        async onEnd(
+        // Should we use this `isCancel`? Maybe we can skip `injectStringAtEnd()`?
+        isCancel) {
             try {
+                assert(!onEndWasCalled);
+                onEndWasCalled = true;
                 debug('stream end');
-                streamEnded = true;
-                streamOriginalHasStartedEmitting = true; // In case original stream (stream provided by user) emits no data
-                if (wrapperCreated)
-                    resolvePromise(); //    In case original stream (stream provided by user) emits no data
+                // We call onStreamEvent() also here in case the stream didn't emit any data
+                onStreamDataOrEnd(() => {
+                    streamOriginalEnded = true;
+                });
                 if (injectStringAtEnd) {
                     const injectEnd = await injectStringAtEnd();
                     writeStream(injectEnd);
@@ -266,10 +278,12 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
                 assert(isReady());
                 flushBuffer();
+                streamClosed = true;
                 debug('stream ended');
             }
             catch (err) {
-                // We should catch and gracefully handle user land errors, as any error thrown here kills the server
+                // Ideally, we should catch and gracefully handle user land errors, as any error thrown here kills the server. (I assume that the fact it kills the server is a Node.js bug?)
+                // Show "[vike][Bug] You stumbled upon a bug in Vike's source code" to user while printing original error
                 if (!isBug(err)) {
                     console.error(err);
                     assert(false);
@@ -293,6 +307,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
     function flushBuffer() {
         if (!isReady())
             return;
+        assert(!streamClosed);
         buffer.forEach((chunk) => {
             streamWrapperOperations.writeChunk(chunk);
         });
@@ -489,6 +504,17 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
     if (isStreamReadableWeb(streamOriginal)) {
         debug('onRenderHtml() hook returned Web Readable');
         const readableOriginal = streamOriginal;
+        let controllerProxyIsClosed = false;
+        let isClosed = false;
+        let isCancel = false;
+        const closeStream = async () => {
+            if (isClosed)
+                return;
+            isClosed = true;
+            await onEnd(isCancel);
+            controllerProxy.close();
+            controllerProxyIsClosed = true;
+        };
         let controllerProxy;
         assertReadableStreamConstructor();
         const readableProxy = new ReadableStream({
@@ -502,16 +528,30 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
                         controllerProxy.close();
                     },
                     async onEnd() {
-                        await onEnd();
-                        controllerProxy.close();
+                        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
+                await closeStream();
             }
         });
         const writeChunk = (chunk) => {
-            controllerProxy.enqueue(encodeForWebStream(chunk));
-            if (debug.isEnabled) {
-                debug('data written (Web Readable)', String(chunk));
+            if (
+            // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether we closed `controllerProxy`.
+            !controllerProxyIsClosed) {
+                controllerProxy.enqueue(encodeForWebStream(chunk));
+                if (debug.isEnabled) {
+                    debug('data written (Web Readable)', String(chunk));
+                }
+            }
+            else {
+                if (debug.isEnabled) {
+                    debug('data emitted but not written (Web Readable)', String(chunk));
+                }
             }
         };
         // Readables don't have the notion of flushing

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

@@ -1,5 +1,8 @@
 // TODO/v1-release: replace this with:
 // assertUsage(false, "`import { something } from 'vike'` doesn't exist: instead import from 'vike/server', 'vike/client', 'vike/plugin', ...")
+import { isBrowser } from '../../utils/isBrowser.js';
+import { assertUsage } from '../../utils/assert.js';
+assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike'` on the client-side: the module 'vike' is a server-only module.", { showStackTrace: true });
 export * from './index-common.js';
 export * from '../../types/index-dreprecated.js';
 import { assertWarning } from './utils.js';
@@ -36,5 +39,3 @@ assertWarning(false, [
     pc.green("  import type { something } from 'vike/types'"),
     "Make sure to import renderPage(), escapeInject, html, dangerouslySkipEscape(), pipeWebStream(), pipeNodeStream(), pipeStream(), stampPipe() from 'vike/server'. (Or inspect the error stack below to find the import causing this warning.)"
 ].join('\n'), { showStackTrace: true, onlyOnce: true });
-import { isBrowser, assertUsage } from './utils.js';
-assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike'` in code loaded in the browser: the module 'vike' is a server-only module.", { showStackTrace: true });

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

@@ -1,3 +1,4 @@
+import { isBrowser } from '../../utils/isBrowser.js';
+import { assertUsage } from '../../utils/assert.js';
+assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike/server'` on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });
 export * from './index-common.js';
-import { isBrowser, assertUsage } from './utils.js';
-assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike/server'` in code loaded on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });

package/dist/esm/node/runtime/renderPage/{executeOnBeforeRenderHook.d.ts → executeOnBeforeRenderAndDataHooks.d.ts}

@@ -1,7 +1,7 @@
-export { executeOnBeforeRenderHooks };
+export { executeOnBeforeRenderAndDataHooks };
 import { type PageContextExports } from '../../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
-declare function executeOnBeforeRenderHooks(pageContext: {
+declare function executeOnBeforeRenderAndDataHooks(pageContext: {
     _pageId: string;
     _pageContextAlreadyProvidedByOnPrerenderHook?: true;
 } & PageContextExports & PageContextForUserConsumptionServerSide): Promise<void>;

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

@@ -0,0 +1,30 @@
+export { executeOnBeforeRenderAndDataHooks };
+import { getHook } from '../../../shared/hooks/getHook.js';
+import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
+import { executeHook } from '../utils.js';
+import { assertOnBeforeRenderHookReturn } from '../../../shared/assertOnBeforeRenderHookReturn.js';
+async function executeOnBeforeRenderAndDataHooks(pageContext) {
+    if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
+        return;
+    }
+    const dataHook = getHook(pageContext, 'data');
+    const onBeforeRenderHook = getHook(pageContext, 'onBeforeRender');
+    if (!dataHook && !onBeforeRenderHook) {
+        return;
+    }
+    preparePageContextForUserConsumptionServerSide(pageContext);
+    if (dataHook) {
+        const hookResult = await executeHook(() => dataHook.hookFn(pageContext), dataHook);
+        // Note: hookResult can be anything (e.g. an object) and is to be assigned to pageContext.data
+        const pageContextFromHook = {
+            data: hookResult
+        };
+        Object.assign(pageContext, pageContextFromHook);
+    }
+    if (onBeforeRenderHook) {
+        const hookResult = await executeHook(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook);
+        assertOnBeforeRenderHookReturn(hookResult, onBeforeRenderHook.hookFilePath);
+        const pageContextFromHook = hookResult?.pageContext;
+        Object.assign(pageContext, pageContextFromHook);
+    }
+}

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

@@ -71,7 +71,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
                     return;
                 }
                 else {
-                    assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
+                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender));
                     assertUsage(false, getErrMsgMixingStreamTypes('Web Writable'));
                 }
             }
@@ -81,7 +81,7 @@ function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
                     return;
                 }
                 else {
-                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender));
+                    assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
                     assertUsage(false, getErrMsgMixingStreamTypes('Node.js Writable'));
                 }
             }

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

@@ -37,13 +37,21 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
         if (mod.url.startsWith('/')) {
             styleUrls.add(mod.url);
         }
+        else if (mod.url.startsWith('\0')) {
+            // Virtual modules
+            //  - https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+            //    - I believe some Vite plugins don't respect the \0 virtual module convention. What should we do then?
+            //  - https://github.com/vikejs/vike/issues/1327
+            //  - https://github.com/vikejs/vike/commit/3f7b9916dddc84e29e2c20d2b0df7211b6f1acbd
+            styleUrls.add(`/@id/${mod.url.substring(1)}`);
+        }
         else {
-            // Vuetify uses virtual SCSS modules which we skip
-            //  - We skip because `<link rel="stylesheet" type="text/css" href="virtual-module.css">` doesn't work
-            //  - Reproduction: https://github.com/vikejs/vike/issues/479
-            //  - Possible workaround: `<script>import 'virtual-module.css'</script>`
-            // logModule(mod)
+            // Is this useful? Maybe for virtual modules that don't respect the \0 virtual module convention?
+            styleUrls.add(`/@id/${mod.url}`);
         }
+        /* Debug:
+        logModule(mod)
+        //*/
     }
     mod.importedModules.forEach((dep) => {
         collectCss(dep, styleUrls, visitedModules, mod);

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

@@ -20,6 +20,12 @@ function sortPageAssetsForEarlyHintsHeader(pageAssets) {
         if (assetType === 'image')
             return priority;
         priority--;
+        if (assetType === 'video')
+            return priority;
+        priority--;
+        if (assetType === 'audio')
+            return priority;
+        priority--;
         // Others
         if (assetType !== 'script')
             return priority;

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

@@ -82,7 +82,7 @@ async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
         const { createRequire } = (await import_('module')).default;
         const { dirname } = (await import_('path')).default;
         const { fileURLToPath } = (await import_('url')).default;
-        // @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+        // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
         const importMetaUrl = import.meta.url;
         const require_ = createRequire(importMetaUrl);
         const __dirname_ = dirname(fileURLToPath(importMetaUrl));

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

@@ -1,7 +1,7 @@
 export { inferMediaType };
 export type { MediaType };
 type MediaType = null | {
-    assetType: 'image' | 'script' | 'font' | 'style';
-    mediaType: 'text/javascript' | 'text/css' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2';
+    assetType: 'image' | 'script' | 'font' | 'style' | 'audio' | 'video' | 'document' | 'fetch' | 'track' | 'worker' | 'embed' | 'object';
+    mediaType: 'text/javascript' | 'text/css' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2' | 'video/mp4' | 'video/webm' | 'video/ogg' | 'video/mpeg' | 'video/x-msvideo' | 'video/quicktime' | 'audio/mpeg' | 'audio/wav' | 'audio/ogg' | 'audio/aac' | 'audio/midi' | 'audio/flac';
 };
 declare function inferMediaType(href: string): MediaType;

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

@@ -34,5 +34,43 @@ function inferMediaType(href) {
     if (href.endsWith('.woff2')) {
         return { assetType: 'font', mediaType: 'font/woff2' };
     }
+    // Videos
+    if (href.endsWith('.mp4')) {
+        return { assetType: 'video', mediaType: 'video/mp4' };
+    }
+    if (href.endsWith('.webm')) {
+        return { assetType: 'video', mediaType: 'video/webm' };
+    }
+    if (href.endsWith('.ogv')) {
+        return { assetType: 'video', mediaType: 'video/ogg' };
+    }
+    if (href.endsWith('.mpeg') || href.endsWith('.mpg')) {
+        return { assetType: 'video', mediaType: 'video/mpeg' };
+    }
+    if (href.endsWith('.avi')) {
+        return { assetType: 'video', mediaType: 'video/x-msvideo' };
+    }
+    if (href.endsWith('.mov') || href.endsWith('.qt')) {
+        return { assetType: 'video', mediaType: 'video/quicktime' };
+    }
+    // Audios
+    if (href.endsWith('.mp3')) {
+        return { assetType: 'audio', mediaType: 'audio/mpeg' };
+    }
+    if (href.endsWith('.wav')) {
+        return { assetType: 'audio', mediaType: 'audio/wav' };
+    }
+    if (href.endsWith('.ogg')) {
+        return { assetType: 'audio', mediaType: 'audio/ogg' };
+    }
+    if (href.endsWith('.m4a')) {
+        return { assetType: 'audio', mediaType: 'audio/aac' };
+    }
+    if (href.endsWith('midi') || href.endsWith('.mid')) {
+        return { assetType: 'audio', mediaType: 'audio/midi' };
+    }
+    if (href.endsWith('.flac')) {
+        return { assetType: 'audio', mediaType: 'audio/flac' };
+    }
     return null;
 }

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

@@ -13,7 +13,7 @@ import { getGlobalContext } from '../globalContext.js';
 import { createHttpResponseObject, createHttpResponsePageContextJson } from './createHttpResponseObject.js';
 import { loadPageFilesServerSide } from './loadPageFilesServerSide.js';
 import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
-import { executeOnBeforeRenderHooks } from './executeOnBeforeRenderHook.js';
+import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
 import { logRuntimeError } from './loggerRuntime.js';
 import { isNewError } from './isNewError.js';
 import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
@@ -33,11 +33,11 @@ async function renderPageAlreadyRouted(pageContext) {
         await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext));
     }
     if (!isError) {
-        await executeOnBeforeRenderHooks(pageContext);
+        await executeOnBeforeRenderAndDataHooks(pageContext);
     }
     else {
         try {
-            await executeOnBeforeRenderHooks(pageContext);
+            await executeOnBeforeRenderAndDataHooks(pageContext);
         }
         catch (err) {
             if (isNewError(err, pageContext.errorWhileRendering)) {
@@ -75,7 +75,7 @@ async function prerenderPage(pageContext) {
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
     await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext))
     */
-    await executeOnBeforeRenderHooks(pageContext);
+    await executeOnBeforeRenderAndDataHooks(pageContext);
     const { htmlRender, renderHook } = await executeOnRenderHtmlHook(pageContext);
     assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
     assert(pageContext.isClientSideNavigation === false);

package/dist/esm/shared/VikeNamespace.d.ts

@@ -15,9 +15,10 @@ declare global {
         /** Extend and/or refine the `PageContext` type (`import type { PageContext } from 'vike/types'`).
          *
          *  For example:
-         *  - You can define the type of fetched data, e.g. `PageContext['movies']`.
          *  - You can refine the type of `PageContext['Page']`.
+         *  - You can define the type of custom `pageContext` values such as `pageContext.user`, see https://vike.dev/pageContext#custom
          *
+         *  https://vike.dev/pageContext#typescript
          */
         interface PageContext {
         }

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

@@ -5,6 +5,8 @@ export type { ConfigMeta };
 export type { HookName };
 export type { HookNamePage };
 export type { HookNameGlobal };
+export type { DataAsync };
+export type { DataSync };
 export type { GuardAsync };
 export type { GuardSync };
 export type { OnBeforePrerenderStartAsync };
@@ -35,11 +37,21 @@ import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
 type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
-type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard';
+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' | 'isClientSideRenderable' | 'onBeforeRenderEnv' | 'hooksTimeout';
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientSideRenderable' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte);
+/** Hook for fetching data.
+ *
+ *  https://vike.dev/data
+ */
+type DataAsync<Data> = (pageContext: PageContextServer) => Promise<Data>;
+/** Hook for fetching data.
+ *
+ *  https://vike.dev/data
+ */
+type DataSync<Data> = (pageContext: PageContextServer) => Data;
 /** Protect page(s), e.g. forbid unauthorized access.
  *
  *  https://vike.dev/guard
@@ -66,14 +78,14 @@ type OnBeforePrerenderStartSync = () => (string | {
     url: string;
     pageContext: Partial<Vike.PageContext>;
 })[];
-/** Hook called before the page is rendered, usually for fetching data.
+/** Hook called before the page is rendered.
  *
  *  https://vike.dev/onBeforeRender
  */
 type OnBeforeRenderAsync = (pageContext: PageContextServer) => Promise<{
     pageContext: Partial<Vike.PageContext>;
 } | void>;
-/** Hook called before the page is rendered, usually for fetching data.
+/** Hook called before the page is rendered.
  *
  *  https://vike.dev/onBeforeRender
  */
@@ -234,11 +246,16 @@ type ConfigBuiltIn = {
      * https://vike.dev/extends
      */
     extends?: Config | Config[] | ImportString | ImportString[];
-    /** Hook called before the page is rendered, usually for fetching data.
+    /** Hook called before the page is rendered.
      *
      *  https://vike.dev/onBeforeRender
      */
     onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportString | null;
+    /** Hook for fetching data.
+     *
+     *  https://vike.dev/data
+     */
+    data?: DataAsync<unknown> | DataSync<unknown> | ImportString | null;
     /** Determines what pageContext properties are sent to the client-side.
      *
      * https://vike.dev/passToClient

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

@@ -28,13 +28,20 @@ function assertExports(fileExports, filePathToShowToUser, configName) {
         if (exportsRelevant.length === 1) {
             return;
         }
-        else {
-            assert(exportsRelevant.length === 0);
-            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${pc.cyan('export default')}`;
+        const exportDefault = pc.cyan('export default');
+        const exportConfigName = pc.cyan(`export { ${configName} }`);
+        if (exportsRelevant.length === 0) {
+            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${exportDefault}`;
             if (configName)
-                errMsg += ` or ${pc.cyan(`export { ${configName} }`)}`;
+                errMsg += ` or ${exportConfigName}`;
             assertUsage(false, errMsg);
         }
+        else {
+            assert(exportsRelevant.length === 2);
+            assertWarning(false, `${filePathToShowToUser} remove ${exportConfigName} or ${exportDefault}`, {
+                onlyOnce: true
+            });
+        }
     }
     else {
         // !configName => isConfigFile

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

@@ -4,6 +4,7 @@ export { resolveRouteStringRedirect };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
 import { isUriWithProtocol } from '../../utils/parseUrl-extras.js';
 import { assert, assertUsage } from '../utils.js';
+import { resolveUrlPathname } from './resolveUrlPathname.js';
 import { assertRouteString, resolveRouteString } from './resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
@@ -27,16 +28,7 @@ function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
     const match = resolveRouteString(urlSource, urlPathname);
     if (!match)
         return null;
-    let urlResolved = urlTarget;
-    Object.entries(match.routeParams).forEach(([key, val]) => {
-        if (key !== '*') {
-            key = `@${key}`;
-        }
-        urlResolved = urlResolved.replaceAll(key, val);
-    });
-    if (!urlResolved.startsWith('mailto:')) {
-        assertUsage(!urlResolved.includes('@'), 'URL should not contain "@" unless it is a mailto link.');
-    }
+    const urlResolved = resolveUrlPathname(urlTarget, match.routeParams);
     if (urlResolved === urlPathname)
         return null;
     assert(urlResolved.startsWith('/') || isUriWithProtocol(urlResolved));

package/dist/esm/shared/route/resolveUrlPathname.d.ts

@@ -0,0 +1,12 @@
+export { resolveUrlPathname };
+/** Given a `routeString` and `routeParams`, resolve `urlPathname`.
+ *
+ * Basically, the correct implementation of following:
+ * ```js
+ * let urlPathname = routeString
+ * Object.entries(routeParams).forEach(([key, val]) => {
+ *   urlPathname = urlPathname.replaceAll(key, val)
+ * })
+ * ```
+ */
+declare function resolveUrlPathname(routeString: string, routeParams: Record<string, string>): string;

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

@@ -0,0 +1,45 @@
+export { resolveUrlPathname };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { assert, assertUsage } from '../utils.js';
+assertIsNotBrowser(); // Don't bloat the client
+/** Given a `routeString` and `routeParams`, resolve `urlPathname`.
+ *
+ * Basically, the correct implementation of following:
+ * ```js
+ * let urlPathname = routeString
+ * Object.entries(routeParams).forEach(([key, val]) => {
+ *   urlPathname = urlPathname.replaceAll(key, val)
+ * })
+ * ```
+ */
+function resolveUrlPathname(routeString, routeParams) {
+    let parts = [{ val: routeString, type: 'ROUTE_STRING' }];
+    Object.entries(routeParams).forEach(([key, val]) => {
+        if (key.startsWith('*')) {
+            assert(key === '*' || /\d+/.test(key.slice(1)));
+            assertUsage(key === '*', "Resolving URL with multiple globs isn't implemented yet");
+        }
+        else {
+            key = `@${key}`;
+        }
+        parts = parts
+            .map((part) => {
+            if (part.type === 'URL') {
+                return part;
+            }
+            else {
+                return part.val
+                    .split(key)
+                    .map((rest, i) => {
+                    const partURL = { val, type: 'URL' };
+                    const partRouteString = { val: rest, type: 'ROUTE_STRING' };
+                    return i === 0 ? [partRouteString] : [partURL, partRouteString];
+                })
+                    .flat();
+            }
+        })
+            .flat();
+    });
+    const urlPathname = parts.map((p) => p.val).join('');
+    return urlPathname;
+}

package/dist/esm/shared/types.d.ts

@@ -35,6 +35,11 @@ type PageContextBuiltInCommon<Page = [never]> = {
      * https://vike.dev/route-string
      */
     routeParams: Record<string, string>;
+    /** The page's data which was fetched using the data() hook.
+     *
+     * https://vike.dev/data
+     */
+    data?: unknown;
     /** The page's configuration values.
      *
      * https://vike.dev/config

package/dist/esm/types/index.d.ts

@@ -6,7 +6,7 @@ export type { PageContextClientWithServerRouting } from '../shared/types.js';
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
-export type { Config, ConfigMeta as Meta, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync } from '../shared/page-configs/Config.js';
+export type { Config, ConfigMeta as Meta, DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync } from '../shared/page-configs/Config.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';