vike-react 0.6.2 → 0.6.4

package/README.md

@@ -1 +1,5 @@
+<!-- WARNING: keep links absolute in this file so they work on NPM too -->
+
+[![npm version](https://img.shields.io/npm/v/vike-react)](https://www.npmjs.com/package/vike-react)
+
 See [Vike Docs > vike-react](https://vike.dev/vike-react).

package/dist/config.d.ts

@@ -96,6 +96,7 @@ declare const config: {
             env: {
                 server: true;
             };
+            cumulative: true;
         };
         streamIsRequired: {
             env: {

package/dist/config.js

@@ -76,6 +76,7 @@ const config = {
         },
         stream: {
             env: { server: true },
+            cumulative: true,
         },
         streamIsRequired: {
             env: { server: true },

package/dist/integration/Loading.d.ts

@@ -3,5 +3,4 @@ declare const _default: {
 };
 export default _default;
 import React from 'react';
-import './Loading.css';
 declare function LoadingComponent(): React.JSX.Element;

package/dist/integration/Loading.js

@@ -2,7 +2,11 @@ export default {
     component: LoadingComponent,
 };
 import React from 'react';
-import './Loading.css';
+/* We can't import it here: https://github.com/vikejs/vike/issues/2460
+ * - We import it inside onRenderClient.js instead.
+ * - We'll be able to do it if Vite + Rolldown always transpiles the server-side.
+import './Loading.css'
+*/
 function LoadingComponent() {
     return (React.createElement("div", { style: {
             width: '100%',

package/dist/integration/onRenderClient.d.ts

@@ -1,3 +1,4 @@
 export { onRenderClient };
 import type { OnRenderClientAsync } from 'vike/types';
+import './Loading.css';
 declare const onRenderClient: OnRenderClientAsync;

package/dist/integration/onRenderClient.js

@@ -6,6 +6,7 @@ import { getPageElement } from './getPageElement.js';
 import { callCumulativeHooks } from '../utils/callCumulativeHooks.js';
 import { applyHeadSettings } from './applyHeadSettings.js';
 import { resolveReactOptions } from './resolveReactOptions.js';
+import './Loading.css'; // See comment inside Loading.tsx
 let root;
 const onRenderClient = async (pageContext) => {
     pageContext._headAlreadySet = pageContext.isHydration;

package/dist/integration/onRenderHtml.js

@@ -12,6 +12,9 @@ import { getTagAttributesString } from '../utils/getTagAttributesString.js';
 import { assert } from '../utils/assert.js';
 import { callCumulativeHooks } from '../utils/callCumulativeHooks.js';
 import { resolveReactOptions } from './resolveReactOptions.js';
+import { isNotNullish } from '../utils/isNotNullish.js';
+import { isObject } from '../utils/isObject.js';
+import { isType } from '../utils/isType.js';
 addEcosystemStamp();
 const onRenderHtml = async (pageContext) => {
     await renderPageToHtml(pageContext);
@@ -52,19 +55,32 @@ async function renderPageToHtml(pageContext) {
     await callCumulativeHooks(pageContext.config.onBeforeRenderHtml, pageContext);
     const { renderToStringOptions } = resolveReactOptions(pageContext);
     if (pageContext.page) {
-        const { stream, streamIsRequired } = pageContext.config;
-        if (!stream && !streamIsRequired) {
+        const streamSetting = resolveStreamSetting(pageContext);
+        if (!streamSetting.enable && !streamSetting.require) {
             const pageHtmlString = renderToString(pageContext.page, renderToStringOptions);
             pageContext.pageHtmlString = pageHtmlString;
         }
         else {
             const pageHtmlStream = await renderToStream(pageContext.page, {
-                webStream: typeof stream === 'string' ? stream === 'web' : undefined,
+                webStream: !streamSetting.type
+                    ? /* Let react-streaming decide which stream type to use.
+                      false
+                      */
+                        undefined
+                    : streamSetting.type === 'web',
                 userAgent: pageContext.headers?.['user-agent'] ||
                     // TODO/eventually: remove old way of acccessing the User Agent header.
                     // @ts-ignore
                     pageContext.userAgent,
-                disable: stream === false ? true : undefined,
+                disable: 
+                // +stream.require is true  => default +stream.enable is true
+                // +stream.require is false => default +stream.enable is false
+                streamSetting.enable === false
+                    ? true
+                    : /* Don't override disabling when bot is detected.
+                      false,
+                      */
+                        undefined,
             });
             pageContext.pageHtmlStream = pageHtmlStream;
         }
@@ -164,3 +180,45 @@ async function getBodyHtmlBoundary(pageContext) {
     const bodyHtmlEnd = dangerouslySkipEscape((await callCumulativeHooks(pageContext.config.bodyHtmlEnd, pageContext)).join(''));
     return { bodyHtmlBegin, bodyHtmlEnd };
 }
+function resolveStreamSetting(pageContext) {
+    const { stream, 
+    // TODO/eventually: remove +streamIsRequired
+    //  - Let's remove it once following last vike-react-{query,apollo} releases using +streamIsRequired can be considered old versions.
+    //    - Last vike-react-query version that uses +streamIsRequired was 0.1.3
+    //    - Last vike-react-apollo version that uses +streamIsRequired was 0.1.1
+    //    - New vike-react-{query,apollo} versions using +stream.require instead +streamIsRequired were released on May 29th 2025
+    //  - Remove it in a minor release (AFAICT it's only used by vike-react-{query,apollo})
+    //    - Add a `Negligible Breaking Change`
+    streamIsRequired, } = pageContext.config;
+    const streamSetting = {
+        type: null,
+        enable: null,
+        require: streamIsRequired ?? false,
+    };
+    stream
+        ?.reverse()
+        .filter(isNotNullish)
+        .forEach((setting) => {
+        if (typeof setting === 'boolean') {
+            streamSetting.enable = setting;
+            return;
+        }
+        if (typeof setting === 'string') {
+            streamSetting.type = setting;
+            streamSetting.enable = true;
+            return;
+        }
+        if (isObject(setting)) {
+            if (setting.enable !== null)
+                streamSetting.enable = setting.enable ?? true;
+            if (setting.require !== undefined)
+                streamSetting.require = setting.require;
+            if (setting.type !== undefined)
+                streamSetting.type = setting.type;
+            return;
+        }
+        isType(setting);
+        throw new Error(`Unexpected +stream value ${setting}`);
+    });
+    return streamSetting;
+}

package/dist/integration/ssrEffect.js

@@ -13,7 +13,7 @@ function ssrEffect({ configDefinedAt, configValue }) {
     return {
         meta: {
             Page: { env },
-            /* We don't do this to enable wraping <Head> with <Wrapper>
+            /* We don't do this to enable wrapping <Head> with <Wrapper>
             Wrapper: { env }, */
             Layout: { env },
             Loading: { env },

package/dist/types/Config.d.ts

@@ -1,4 +1,4 @@
-import type { ImportString, PageContextServer, PageContext, PageContextClient } from 'vike/types';
+import type { ImportString, PageContext } from 'vike/types';
 import type { TagAttributes } from '../utils/getTagAttributesString.js';
 import type { Viewport } from '../integration/onRenderHtml.js';
 import type { ConfigsCumulative } from '../hooks/useConfig/configsCumulative.js';
@@ -140,16 +140,35 @@ declare global {
              */
             ssr?: boolean;
             /**
-             * Enable or disable HTML Streaming.
+             * Settings for HTML Streaming.
              *
              * https://vike.dev/stream
              */
-            stream?: boolean | 'node' | 'web';
-            /**
-             * Whether the existence of the React SSR stream is required (some integrations require it).
-             *
-             * HTML Streaming can still be disabled: the SSR stream is awaited and converted to a string.
-             */
+            stream?: boolean | 'node' | 'web' | {
+                /**
+                 * Whether the HTML stream should be a Web Stream or a Node.js Stream.
+                 *
+                 * https://vike.dev/stream
+                 */
+                type?: 'node' | 'web';
+                /**
+                 * Whether Server-Side Rendering (SSR) must use a stream. (Some tool integrations require it.)
+                 *
+                 * Setting +stream to `{ require: true, disable: true }` means that SSR is done using a stream but, from the user's perspective, HTML Streaming is disabled: the stream is awaited, converted to a string, and the full HTML is sent at once.
+                 *
+                 * https://vike.dev/stream
+                 */
+                require?: boolean;
+                /**
+                 * Setting +stream to `{ enable: null }` is the same as not setting +stream at all.
+                 *
+                 * Useful for changing stream settings without enabling streaming. For example, Vike extensions can set +stream to `{ enable: null, type: 'web' }` to change the default stream type without enabling streaming.
+                 *
+                 * https://vike.dev/stream
+                 */
+                enable?: boolean | null;
+            };
+            /** @deprecated Set +stream.require instead */
             streamIsRequired?: boolean;
             /**
              * Whether to use `<StrictMode>`.
@@ -176,13 +195,13 @@ declare global {
              *
              * https://vike.dev/onBeforeRenderClient
              */
-            onBeforeRenderClient?: (pageContext: PageContextClient) => void;
+            onBeforeRenderClient?: ((pageContext: PageContextClient) => void) | ImportString;
             /**
              * Client-side hook called after the page is rendered.
              *
              * https://vike.dev/onAfterRenderClient
              */
-            onAfterRenderClient?: (pageContext: PageContextClient) => void;
+            onAfterRenderClient?: ((pageContext: PageContextClient) => void) | ImportString;
             /**
              * Define loading animations.
              *
@@ -209,6 +228,7 @@ declare global {
             onBeforeRenderClient?: Function[];
             onAfterRenderClient?: Function[];
             react?: Exclude<Config['react'], ImportString>[];
+            stream?: Exclude<Config['stream'], ImportString>[];
         }
     }
 }

package/dist/utils/isNotNullish.d.ts

@@ -0,0 +1,2 @@
+export declare function isNullish(val: unknown): val is null | undefined;
+export declare function isNotNullish<T>(p: T | null | undefined): p is T;

package/dist/utils/isNotNullish.js

@@ -0,0 +1,7 @@
+export function isNullish(val) {
+    return val === null || val === undefined;
+}
+// someArray.filter(isNotNullish)
+export function isNotNullish(p) {
+    return !isNullish(p);
+}

package/dist/utils/isObject.d.ts

@@ -0,0 +1 @@
+export declare function isObject(value: unknown): value is Record<string, unknown>;

package/dist/utils/isObject.js

@@ -0,0 +1,3 @@
+export function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/utils/isType.d.ts

@@ -0,0 +1 @@
+export declare function isType<Type>(_: Type): void;

package/dist/utils/isType.js

@@ -0,0 +1 @@
+export function isType(_) { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike-react",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "repository": "https://github.com/vikejs/vike-react",
   "type": "module",
   "exports": {
@@ -44,7 +44,7 @@
     "react-dom": "^19.0.0",
     "rimraf": "^5.0.5",
     "typescript": "^5.7.3",
-    "vike": "^0.4.223",
+    "vike": "^0.4.230",
     "vite": "^6.2.5"
   },
   "typesVersions": {