vike 0.4.149 → 0.4.150-commit-d0822a3

package/dist/cjs/node/plugin/index.js

@@ -12,7 +12,6 @@ const buildConfig_js_1 = require("./plugins/buildConfig.js");
 const previewConfig_js_1 = require("./plugins/previewConfig.js");
 const autoFullBuild_js_1 = require("./plugins/autoFullBuild.js");
 const index_js_1 = require("./plugins/devConfig/index.js");
-const manifest_js_1 = require("./plugins/manifest.js");
 const packageJsonFile_js_1 = require("./plugins/packageJsonFile.js");
 const removeRequireHookPlugin_js_1 = require("./plugins/removeRequireHookPlugin.js");
 const index_js_2 = require("./plugins/importUserCode/index.js");
@@ -39,7 +38,6 @@ function plugin(vikeConfig) {
         (0, buildConfig_js_1.buildConfig)(),
         (0, previewConfig_js_1.previewConfig)(),
         ...(0, autoFullBuild_js_1.autoFullBuild)(),
-        ...(0, manifest_js_1.manifest)(),
         (0, packageJsonFile_js_1.packageJsonFile)(),
         (0, removeRequireHookPlugin_js_1.removeRequireHookPlugin)(),
         (0, distFileNames_js_1.distFileNames)(),

package/dist/cjs/node/plugin/plugins/autoFullBuild.js

@@ -63,9 +63,10 @@ async function triggerFullBuild(config, configVike, bundle) {
         return; // already triggered
     if (isDisabled(configVike))
         return;
+    /* Is this @vitejs/plugin-legacy workaround still needed? Should we re-implement it?
     // vike.json missing => it isn't a `$ vite build` call (e.g. @vitejs/plugin-legacy calls Vite's build() API) => skip
-    if (!bundle['vike.json'])
-        return;
+    if (!bundle['vike.json']) return
+    */
     const configFromCli = !(0, isViteCliCall_js_1.isViteCliCall)() ? null : (0, isViteCliCall_js_1.getViteConfigFromCli)();
     const configInline = {
         ...configFromCli,

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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeClientEntries = exports.assertRollupInput = exports.buildConfig = void 0;
 const utils_js_1 = require("../utils.js");
-const virtualFileImportUserCode_js_1 = require("../../shared/virtual-files/virtualFileImportUserCode.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
 const helpers_js_1 = require("../../../shared/page-configs/helpers.js");
 const findPageFiles_js_1 = require("../shared/findPageFiles.js");
@@ -16,7 +15,7 @@ const module_1 = require("module");
 const getClientEntryFilePath_js_1 = require("../../shared/getClientEntryFilePath.js");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 const manifestTempFile = '_temp_manifest.json';
@@ -30,14 +29,9 @@ function buildConfig() {
             order: 'post',
             async handler(config) {
                 assertRollupInput(config);
-                const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
                 const entries = await getEntries(config);
                 (0, utils_js_1.assert)(Object.keys(entries).length > 0);
-                const input = {
-                    ...entries,
-                    ...userInputs
-                };
-                config.build.rollupOptions.input = input;
+                config.build.rollupOptions.input = (0, utils_js_1.injectRollupInputs)(entries, config);
                 addLogHook();
             }
         },
@@ -76,12 +70,12 @@ async function getEntries(config) {
     const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config, false);
     (0, utils_js_1.assertUsage)(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if ((0, utils_js_1.viteIsSSR)(config)) {
-        const serverEntries = analyzeServerEntries(pageConfigs);
+        const pageEntries = getPageEntries(pageConfigs);
         const entries = {
-            pageFiles: virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer,
-            importBuild: resolve('dist/esm/node/importBuild.js'),
+            // importBuild: resolve('dist/esm/node/importBuild.js'), // TODO/next-major-release: remove
             ...pageFileEntries,
-            ...serverEntries
+            // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
+            ...pageEntries
         };
         return entries;
     }
@@ -106,6 +100,14 @@ async function getEntries(config) {
         return entries;
     }
 }
+function getPageEntries(pageConfigs) {
+    const pageEntries = {};
+    pageConfigs.forEach((pageConfig) => {
+        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
+        pageEntries[entryName] = entryTarget;
+    });
+    return pageEntries;
+}
 function analyzeClientEntries(pageConfigs, config) {
     let hasClientRouting = false;
     let hasServerRouting = false;
@@ -120,6 +122,7 @@ function analyzeClientEntries(pageConfigs, config) {
             hasServerRouting = true;
         }
         {
+            // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
             const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, true);
             clientEntries[entryName] = entryTarget;
         }
@@ -138,14 +141,6 @@ function analyzeClientEntries(pageConfigs, config) {
     return { hasClientRouting, hasServerRouting, clientEntries };
 }
 exports.analyzeClientEntries = analyzeClientEntries;
-function analyzeServerEntries(pageConfigs) {
-    const serverEntries = {};
-    pageConfigs.forEach((pageConfig) => {
-        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
-        serverEntries[entryName] = entryTarget;
-    });
-    return serverEntries;
-}
 // Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
 // (Otherwise the page files may be missing in the client manifest.json)
 async function getPageFileEntries(config, includeAssetsImportedByServer) {
@@ -201,20 +196,6 @@ function resolve(filePath) {
     // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/
     return require_.resolve(`../../../../../${filePath}`);
 }
-function normalizeRollupInput(input) {
-    if (!input) {
-        return {};
-    }
-    // Usually `input` is an oject, but the user can set it as a `string` or `string[]`
-    if (typeof input === 'string') {
-        input = [input];
-    }
-    if (Array.isArray(input)) {
-        return Object.fromEntries(input.map((input) => [input, input]));
-    }
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(input));
-    return input;
-}
 function addLogHook() {
     const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27
     if (!tty)
@@ -243,9 +224,9 @@ function addLogHook() {
     });
 }
 function assertRollupInput(config) {
-    const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
+    const userInputs = (0, utils_js_1.normalizeRollupInput)(config.build.rollupOptions.input);
     const htmlInputs = Object.values(userInputs).filter((entry) => entry.endsWith('.html') || entry.endsWith('.htm'));
     const htmlInput = htmlInputs[0];
-    (0, utils_js_1.assertUsage)(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using vike, instead follow https://vike.dev/add`);
+    (0, utils_js_1.assertUsage)(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
 }
 exports.assertRollupInput = assertRollupInput;

package/dist/cjs/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -40,6 +40,9 @@ function assertResolveAlias(config) {
             // Allow un-distinguishable aliases set by @preact/preset-vite
             if (find.startsWith('react'))
                 return;
+            // Allow un-distinguishable aliases set by @vitejs/plugin-vue2 https://github.com/vikejs/vike/issues/1329
+            if (find === 'vue')
+                return;
             {
                 const msg = `${errPrefix} defines an invalid ${picocolors_1.default.cyan('resolve.alias')}: a path alias cannot be the empty string ${picocolors_1.default.cyan("''")}`;
                 (0, utils_js_1.assertUsage)(find !== '', msg);

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -11,7 +11,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const path_1 = __importDefault(require("path"));
 const module_1 = require("module");
 const assertResolveAlias_js_1 = require("./commonConfig/assertResolveAlias.js");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 function commonConfig() {

package/dist/cjs/node/plugin/plugins/config/resolveExtensions.js

@@ -10,7 +10,7 @@ const fs_1 = __importDefault(require("fs"));
 const fileTypes_js_1 = require("../../../../shared/getPageFiles/fileTypes.js");
 const module_1 = require("module");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 function resolveExtensions(configs, config) {

package/dist/cjs/node/plugin/plugins/config/stemUtils.js

@@ -9,7 +9,7 @@ const path_1 = __importDefault(require("path"));
 const utils_js_1 = require("../../utils.js");
 const import_1 = require("@brillout/import");
 const module_1 = require("module");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 async function getStemPackages(userAppRootDir) {

package/dist/cjs/node/plugin/plugins/devConfig/determineFsAllowList.js

@@ -11,7 +11,7 @@ const utils_js_1 = require("../../utils.js");
 const module_1 = require("module");
 const path_2 = require("path");
 const url_1 = require("url");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 const __dirname_ = (0, path_2.dirname)((0, url_1.fileURLToPath)(importMetaUrl));

package/dist/cjs/node/plugin/plugins/importBuild/getVikeManifest.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVikeManifest = void 0;
+const utils_js_1 = require("../../utils.js");
+const assertPluginManifest_js_1 = require("../../../shared/assertPluginManifest.js");
+const extractExportNamesPlugin_js_1 = require("../extractExportNamesPlugin.js");
+const path_1 = __importDefault(require("path"));
+const globalContext_js_1 = require("../../../runtime/globalContext.js");
+function getVikeManifest(config, configVike) {
+    const runtimeManifest = (0, globalContext_js_1.getRuntimeManifest)(configVike);
+    const manifest = {
+        version: utils_js_1.projectInfo.projectVersion,
+        usesClientRouter: (0, extractExportNamesPlugin_js_1.isUsingClientRouter)(),
+        manifestKeyMap: getManifestKeyMap(configVike, config),
+        ...runtimeManifest
+    };
+    (0, assertPluginManifest_js_1.assertPluginManifest)(manifest);
+    return manifest;
+}
+exports.getVikeManifest = getVikeManifest;
+function getManifestKeyMap(configVike, config) {
+    const manifestKeyMap = {};
+    configVike.extensions
+        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+        .flat()
+        .filter(utils_js_1.isNotNullish)
+        .forEach(({ importPath, filePath }) => {
+        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
+        const filePathRelative = path_1.default.posix.relative(config.root, (0, utils_js_1.toPosixPath)(filePath));
+        (0, utils_js_1.assertPosixPath)(filePathRelative);
+        (0, utils_js_1.assertPosixPath)(importPath);
+        manifestKeyMap[importPath] = filePathRelative;
+    });
+    return manifestKeyMap;
+}

package/dist/cjs/node/plugin/plugins/importBuild/index.js

@@ -8,47 +8,85 @@ const plugin_js_1 = require("@brillout/vite-plugin-import-build/plugin.js");
 const utils_js_1 = require("../../utils.js");
 const path_1 = __importDefault(require("path"));
 const module_1 = require("module");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const getConfigVike_js_1 = require("../../../shared/getConfigVike.js");
+const getVikeManifest_js_1 = require("./getVikeManifest.js");
+const promises_1 = __importDefault(require("fs/promises"));
+const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
+const ASSETS_MAP = '__VITE_ASSETS_MAP__';
 function importBuild() {
     let config;
+    let configVike;
     return [
         {
             name: 'vike:importBuild:config',
             enforce: 'post',
-            configResolved(config_) {
+            async configResolved(config_) {
                 config = config_;
+                configVike = await (0, getConfigVike_js_1.getConfigVike)(config);
+            },
+            async writeBundle(options, bundle) {
+                if (!(0, utils_js_1.viteIsSSR)(config))
+                    return;
+                await replace_ASSETS_MAP(options, bundle);
             }
         },
         (0, plugin_js_1.importBuild)({
-            getImporterCode: ({ findBuildEntry }) => {
-                const pageFilesEntry = findBuildEntry('pageFiles');
-                return getImporterCode(config, pageFilesEntry);
+            getImporterCode: () => {
+                return getEntryCode(config, configVike);
             },
             libraryName: utils_js_1.projectInfo.projectName
         })
     ];
 }
 exports.importBuild = importBuild;
-function getImporterCode(config, pageFilesEntry) {
-    const filePathAbsolute = (0, utils_js_1.toPosixPath)(
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
-    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
-    const { outDirServer } = (0, utils_js_1.getOutDirs)(config);
-    const filePathRelative = path_1.default.posix.relative(outDirServer, filePathAbsolute);
-    // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
+function getEntryCode(config, configVike) {
+    const importPath = getImportPath(config);
+    const vikeManifest = (0, getVikeManifest_js_1.getVikeManifest)(config, configVike);
     const importerCode = [
-        '(async () => {',
-        `  const { setImportBuildGetters } = await import('${filePathRelative}');`,
+        `  import { setImportBuildGetters } from '${importPath}';`,
+        `  import * as pageFiles from '${virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer}';`,
         '  setImportBuildGetters({',
-        `    pageFiles: () => import('./${pageFilesEntry}'),`,
-        "    clientManifest: () => require('../assets.json'),",
-        // TODO: use virtual file instead of generating vike.json
-        "    pluginManifest: () => require('../client/vike.json'),",
+        `    pageFiles: () => pageFiles,`,
+        // TODO: rename clientManifest -> assetManifest
+        `    clientManifest: () => { return ${ASSETS_MAP} },`,
+        // TODO: rename pluginManifest -> vikeManifest
+        `    pluginManifest: () => (${JSON.stringify(vikeManifest, null, 2)}),`,
         '  });',
-        '})()',
         ''
     ].join('\n');
     return importerCode;
 }
+async function replace_ASSETS_MAP(options, bundle) {
+    const { dir } = options;
+    (0, utils_js_1.assert)(dir);
+    // I guess importBuild won't be found in the bundle when using @vitejs/plugin-legacy
+    const importBuildEntry = (0, plugin_js_1.findImportBuildBundleEntry)(bundle);
+    const importBuildFilePath = path_1.default.join(dir, importBuildEntry.fileName);
+    const assetsJsonFilePath = path_1.default.join(dir, '..', 'assets.json');
+    const [assetsJsonString, importBuildFileContent] = await Promise.all([
+        await promises_1.default.readFile(assetsJsonFilePath, 'utf8'),
+        await promises_1.default.readFile(importBuildFilePath, 'utf8')
+    ]);
+    const importBuildFileContentFixed = importBuildFileContent.replace(ASSETS_MAP, assetsJsonString);
+    (0, utils_js_1.assert)(importBuildFileContentFixed !== importBuildFileContent);
+    await promises_1.default.writeFile(importBuildFilePath, importBuildFileContentFixed);
+}
+function getImportPath(config) {
+    // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
+    const filePathAbsolute = (0, utils_js_1.toPosixPath)(
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
+    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
+    if (
+    // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal/loadImportBuild' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
+    true) {
+        return 'vike/__internal/loadImportBuild';
+    }
+    else {
+        const { outDirServer } = (0, utils_js_1.getOutDirs)(config);
+        const filePathRelative = path_1.default.posix.relative(outDirServer, filePathAbsolute);
+        return filePathRelative;
+    }
+}

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -111,7 +111,9 @@ function handleHotUpdate(ctx, config, configVike) {
         return;
     }
     if (isVikeConfig) {
-        (0, utils_js_1.assert)(!isViteModule);
+        /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
+        assert(!isViteModule)
+        */
         reloadConfig(file, config, configVike, 'modified');
         const virtualModules = getVirtualModules(server);
         return virtualModules;

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

@@ -37,6 +37,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 }
     },
@@ -77,6 +80,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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

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

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

@@ -40,3 +40,4 @@ __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/mergeCumulativeValues.js"), exports);
 __exportStar(require("../../utils/deepEqual.js"), exports);
 __exportStar(require("../../utils/assertKeys.js"), exports);
+__exportStar(require("../../utils/injectRollupInputs.js"), exports);

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

@@ -20,7 +20,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/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/index-deprecated.js

@@ -20,6 +20,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RenderErrorPage = void 0;
+const isBrowser_js_1 = require("../../utils/isBrowser.js");
+const assert_js_1 = require("../../utils/assert.js");
+(0, assert_js_1.assertUsage)(!(0, isBrowser_js_1.isBrowser)(), "It's forbidden to `import { something } from 'vike'` on the client-side: the module 'vike' is a server-only module.", { showStackTrace: true });
 __exportStar(require("./index-common.js"), exports);
 __exportStar(require("../../types/index-dreprecated.js"), exports);
 const utils_js_1 = require("./utils.js");
@@ -57,5 +60,3 @@ exports.RenderErrorPage = RenderErrorPage;
     picocolors_1.default.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 });
-const utils_js_2 = require("./utils.js");
-(0, utils_js_2.assertUsage)(!(0, utils_js_2.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/cjs/node/runtime/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const isBrowser_js_1 = require("../../utils/isBrowser.js");
+const assert_js_1 = require("../../utils/assert.js");
+(0, assert_js_1.assertUsage)(!(0, isBrowser_js_1.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 });
 __exportStar(require("./index-common.js"), exports);
-const utils_js_1 = require("./utils.js");
-(0, utils_js_1.assertUsage)(!(0, utils_js_1.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/cjs/node/runtime/renderPage/executeOnBeforeRenderAndDataHooks.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeOnBeforeRenderAndDataHooks = void 0;
+const getHook_js_1 = require("../../../shared/hooks/getHook.js");
+const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
+const utils_js_1 = require("../utils.js");
+const assertOnBeforeRenderHookReturn_js_1 = require("../../../shared/assertOnBeforeRenderHookReturn.js");
+async function executeOnBeforeRenderAndDataHooks(pageContext) {
+    if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
+        return;
+    }
+    const dataHook = (0, getHook_js_1.getHook)(pageContext, 'data');
+    const onBeforeRenderHook = (0, getHook_js_1.getHook)(pageContext, 'onBeforeRender');
+    if (!dataHook && !onBeforeRenderHook) {
+        return;
+    }
+    (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
+    if (dataHook) {
+        const hookResult = await (0, utils_js_1.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 (0, utils_js_1.executeHook)(() => onBeforeRenderHook.hookFn(pageContext), onBeforeRenderHook);
+        (0, assertOnBeforeRenderHookReturn_js_1.assertOnBeforeRenderHookReturn)(hookResult, onBeforeRenderHook.hookFilePath);
+        const pageContextFromHook = hookResult?.pageContext;
+        Object.assign(pageContext, pageContextFromHook);
+    }
+}
+exports.executeOnBeforeRenderAndDataHooks = executeOnBeforeRenderAndDataHooks;

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'));
                 }
             }