vike 0.4.149-commit-19b2220 → 0.4.149-commit-aa0ab7b

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

@@ -200,7 +200,9 @@ exports.pipeToStreamWritableNode = pipeToStreamWritableNode;
 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;
@@ -224,6 +226,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) => {
+        (0, utils_js_1.assert)(streamOriginalEnded === false);
+        streamOriginalHasStartedEmitting = true;
+        cb();
+        if (wrapperCreated)
+            resolvePromise();
+    };
     const { streamWrapper, streamWrapperOperations } = await createStreamWrapper({
         streamOriginal,
         onReadyToWrite() {
@@ -241,19 +251,21 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
             }
         },
         onData(chunk) {
-            (0, utils_js_1.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 {
+                (0, utils_js_1.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);
@@ -261,10 +273,12 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
                 await promiseReadyToWrite; // E.g. if the user calls the pipe wrapper after the original writable has ended
                 (0, utils_js_1.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 (!(0, utils_js_1.isBug)(err)) {
                     console.error(err);
                     (0, utils_js_1.assert)(false);
@@ -288,6 +302,7 @@ async function processStream(streamOriginal, { injectStringAtBegin, injectString
     function flushBuffer() {
         if (!isReady())
             return;
+        (0, utils_js_1.assert)(!streamClosed);
         buffer.forEach((chunk) => {
             streamWrapperOperations.writeChunk(chunk);
         });
@@ -485,6 +500,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({
@@ -498,16 +524,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/cjs/node/runtime/renderPage/getHttpResponseBody.js

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

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.149-commit-19b2220';
+const PROJECT_VERSION = '0.4.149-commit-aa0ab7b';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

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/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/utils/projectInfo.d.ts

@@ -1,13 +1,13 @@
 export { projectInfo };
 export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.149-commit-19b2220";
+declare const PROJECT_VERSION: "0.4.149-commit-aa0ab7b";
 type PackageName = typeof projectInfo.npmPackageName;
 type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.149-commit-19b2220";
+    projectVersion: "0.4.149-commit-aa0ab7b";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.149-commit-19b2220';
+const PROJECT_VERSION = '0.4.149-commit-aa0ab7b';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.149-commit-19b2220",
+  "version": "0.4.149-commit-aa0ab7b",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",