vike 0.4.267 → 0.4.268-commit-ca58695

package/dist/client/shared/streamedValues/registry.d.ts

@@ -0,0 +1,21 @@
+export { createReceiver };
+export type { StreamedValueType };
+import { type Reviver } from '@brillout/json-serializer/parse';
+import type { Line } from '../../../shared-server-client/streamedValues.js';
+import '../../assertEnvClient.js';
+type StreamedValueType = {
+    marker: string;
+    /** `parseValue()` parses the value of a `v` line, which can contain further streamed values */
+    revive: (parseValue: (value: unknown) => unknown) => StreamedValue;
+};
+type StreamedValue = {
+    value: unknown;
+    push: (line: Line) => void;
+    fail: (err: unknown) => void;
+};
+declare function createReceiver(): {
+    reviver: Reviver;
+    onLine(lineStr: string): void;
+    /** The response failed, ended or was cancelled: the values that didn't end fail */
+    fail(err: unknown): void;
+};

package/dist/client/shared/streamedValues/registry.js

@@ -0,0 +1,40 @@
+// The types of streamed pageContext values (see shared-server-client/streamedValues.ts), and the receiver: its reviver
+// replaces the markers with values, which it then feeds with their lines.
+export { createReceiver };
+import { parseTransform } from '@brillout/json-serializer/parse';
+import { assert } from '../../../utils/assert.js';
+import { readableStream } from './readableStream.js';
+import { promise } from './promise.js';
+import { asyncIterable } from './asyncIterable.js';
+import '../../assertEnvClient.js';
+const types = [readableStream, promise, asyncIterable];
+function createReceiver() {
+    const streamedValues = new Map();
+    const parseValue = (value) => parseTransform(value, { reviver });
+    const reviver = (_path, value) => {
+        const type = types.find((type) => value.startsWith(type.marker));
+        if (!type)
+            return undefined;
+        const id = value.slice(type.marker.length);
+        assert(/^\d+$/.test(id));
+        // The same value referenced twice
+        let streamedValue = streamedValues.get(Number(id));
+        if (!streamedValue) {
+            streamedValue = type.revive(parseValue);
+            streamedValues.set(Number(id), streamedValue);
+        }
+        return { replacement: streamedValue.value };
+    };
+    return {
+        reviver,
+        onLine(lineStr) {
+            const line = JSON.parse(lineStr);
+            // Unknown if contained in a chunk nobody read
+            streamedValues.get(line.s)?.push(line);
+        },
+        /** The response failed, ended or was cancelled: the values that didn't end fail */
+        fail(err) {
+            streamedValues.forEach((streamedValue) => streamedValue.fail(err));
+        },
+    };
+}

package/dist/client/shared/streamedValues.d.ts

@@ -0,0 +1,7 @@
+export { parsePageContextHtml };
+export { readPageContextJsonStreamed };
+export { cancelStreamedValues };
+import '../assertEnvClient.js';
+declare function parsePageContextHtml(pageContextJson: string): unknown;
+declare function readPageContextJsonStreamed(response: Response): Promise<Record<string, unknown>>;
+declare function cancelStreamedValues(pageContext: object, isRendered: boolean): void;

package/dist/client/shared/streamedValues.js

@@ -0,0 +1,82 @@
+// Streamed pageContext values, client-side (see shared-server-client/streamedValues.ts): the lines that follow the
+// serialized pageContext feed the values of a receiver (see ./streamedValues/registry.ts).
+//
+// Loaded only if the pageContext has streamed values (see getJsonSerializedInHtml.ts and
+// ../runtime-client-routing/streamedValues.ts).
+export { parsePageContextHtml };
+export { readPageContextJsonStreamed };
+export { cancelStreamedValues };
+import { parse } from '@brillout/json-serializer/parse';
+import { assert } from '../../utils/assert.js';
+import { isObject } from '../../utils/isObject.js';
+import { createReceiver } from './streamedValues/registry.js';
+import '../assertEnvClient.js';
+// First render: the `<script>` tags that follow `<script id="vike_pageContext">` push the lines to `self.__vike_streamed`,
+// before and after Vike's client runtime is loaded.
+function parsePageContextHtml(pageContextJson) {
+    const receiver = createReceiver();
+    const [pageContext] = parse(pageContextJson, { reviver: receiver.reviver });
+    const g = self;
+    const linesQueued = Array.isArray(g.__vike_streamed) ? g.__vike_streamed : [];
+    g.__vike_streamed = { push: receiver.onLine };
+    linesQueued.forEach(receiver.onLine);
+    return pageContext;
+}
+// Client-side navigation: the `.pageContext.json` response (see server/runtime/renderPageServer/getPageContextJson.ts),
+// `[pageContext` then one `,line` per line then `]`. The pageContext is returned as soon as its line arrives.
+async function readPageContextJsonStreamed(response) {
+    const reader = response.body.getReader();
+    const lines = readLines(reader);
+    const { done, value: lineFirst } = await lines.next();
+    assert(!done && lineFirst[0] === '[');
+    const receiver = createReceiver();
+    const pageContextFromServer = parse(lineFirst.slice(1), { reviver: receiver.reviver });
+    assert(isObject(pageContextFromServer));
+    responsesStreaming.push(reader);
+    (async () => {
+        try {
+            for await (const line of lines) {
+                if (line !== ']')
+                    receiver.onLine(line.slice(1));
+            }
+            receiver.fail(new Error('The pageContext.json response ended before the streamed pageContext values ended'));
+        }
+        catch (err) {
+            // E.g. the server aborted the response
+            receiver.fail(err);
+        }
+    })();
+    return { ...pageContextFromServer, _streamedValuesReader: reader };
+}
+async function* readLines(reader) {
+    const decoder = new TextDecoder();
+    // Joined once per line: joining upon each chunk would be quadratic
+    let parts = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            return;
+        const chunk = decoder.decode(value, { stream: true });
+        let lineStart = 0;
+        let lineEnd;
+        while ((lineEnd = chunk.indexOf('\n', lineStart)) !== -1) {
+            yield parts.join('') + chunk.slice(lineStart, lineEnd);
+            parts = [];
+            lineStart = lineEnd + 1;
+        }
+        parts.push(chunk.slice(lineStart));
+    }
+}
+// Once a page is rendered, the streamed values fetched before it are cancelled (the previous page's, and superseded
+// navigations'): the previous page keeps its values while it's shown.
+let responsesStreaming = [];
+// Cancels the streamed values of `pageContext` (a superseded navigation), or, once `pageContext` is rendered, all the others
+function cancelStreamedValues(pageContext, isRendered) {
+    const { _streamedValuesReader } = pageContext;
+    responsesStreaming = responsesStreaming.filter((reader) => {
+        if ((reader === _streamedValuesReader) === isRendered)
+            return true;
+        reader.cancel().catch(() => { });
+        return false;
+    });
+}

package/dist/node/api/dev.js

@@ -5,6 +5,7 @@ import { assert } from '../../utils/assert.js';
 import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
 import './assertEnvApiDev.js';
 import { startupLog } from './startupLog.js';
+import { startServerEntry_parent, startServerEntry_child, getServerEntryFilePath_ifDevCli, isServerChildProcess, } from './serverEntryDev.js';
 assertIsNotProductionRuntime();
 /**
  * Programmatically trigger `$ vike dev`
@@ -13,7 +14,15 @@ assertIsNotProductionRuntime();
  */
 async function dev(options = {}) {
     const { viteConfigUser } = await prepareViteApiCall(options, 'dev');
-    const server = await createServer(viteConfigUser);
+    // `$ vike dev` runs +serverEntry.js if there isn't +server.js — https://vike.dev/serverEntry
+    const serverEntryFilePath = await getServerEntryFilePath_ifDevCli();
+    const serverEntryIsChildProcess = isServerChildProcess();
+    if (serverEntryFilePath && !serverEntryIsChildProcess)
+        return await startServerEntry_parent();
+    const server = await createServer(serverEntryFilePath
+        ? // +serverEntry.js creates the server: it uses Vite's development server as middleware
+            setMiddlewareMode(viteConfigUser)
+        : viteConfigUser);
     const viteServer = server;
     const viteConfig = server.config;
     const viteVersion = viteConfig._viteVersionResolved;
@@ -22,9 +31,14 @@ async function dev(options = {}) {
         await viteServer.listen();
     if (options.startupLog)
         startupLog(viteConfig, viteServer);
+    if (serverEntryFilePath && serverEntryIsChildProcess)
+        await startServerEntry_child(viteServer, serverEntryFilePath);
     return {
         viteServer,
         viteConfig,
         viteVersion,
     };
 }
+function setMiddlewareMode(viteConfig) {
+    return { ...viteConfig, server: { ...viteConfig.server, middlewareMode: true } };
+}

package/dist/node/api/resolveViteConfigUser.js

@@ -15,7 +15,7 @@ import { toPosixPath } from '../../utils/path.js';
 import pc from '@brillout/picocolors';
 import { getEnvVarObject } from '../../utils/getEnvVarObject.js';
 import { getVikeApiOperation, isVikeCliOrApi } from '../../shared-server-node/api-context.js';
-import { getViteCliCommand, getViteCliArgs } from '../vite/shared/isViteCli.js';
+import { getViteCliCommand, getViteCliArgsMinimal } from '../vite/shared/isViteCli.js';
 import './assertEnvApiDevAndProd.js';
 const globalObject = getGlobalObject('resolveViteConfigUser.ts', {});
 const debug = createDebug('vike:vite-config-user');
@@ -83,7 +83,7 @@ async function resolve(viteContext) {
     // Vite CLI args (when invoked via Vite's CLI rather than Vike's API).
     // - Without this, Vike loads vite.config.js blind to `vite [root]` / `-c <file>` and ends up with the wrong root when those Vite CLI args are used.
     {
-        const viteConfigFromViteCli = getViteCliArgs();
+        const viteConfigFromViteCli = getViteCliArgsMinimal();
         addConfig(viteConfigFromViteCli);
         if (debug.isActivated)
             debug('viteConfigFromViteCli', viteConfigFromViteCli);

package/dist/node/api/serverEntryDev.d.ts

@@ -0,0 +1,10 @@
+export { startServerEntry_parent };
+export { startServerEntry_child };
+export { getServerEntryFilePath_ifDevCli };
+export { isServerChildProcess };
+import { type ViteDevServer } from 'vite';
+import './assertEnvApiDev.js';
+declare function startServerEntry_parent(): Promise<never>;
+declare function startServerEntry_child(viteServer: ViteDevServer, serverEntryFilePath: string): Promise<void>;
+declare function getServerEntryFilePath_ifDevCli(): Promise<string | null>;
+declare function isServerChildProcess(): boolean;

package/dist/node/api/serverEntryDev.js

@@ -0,0 +1,125 @@
+export { startServerEntry_parent };
+export { startServerEntry_child };
+export { getServerEntryFilePath_ifDevCli };
+export { isServerChildProcess };
+// `$ vike dev` runs +serverEntry.js (if there isn't +server.js) — https://vike.dev/serverEntry
+// - The parent process (`$ vike dev`) runs +serverEntry.js in a child process, and restarts the child process whenever a file imported by +serverEntry.js changes
+// - The child process creates Vite's development server (in middleware mode) and runs +serverEntry.js using Vite's module runner
+import { fork } from 'node:child_process';
+import path from 'node:path';
+import { normalizePath } from 'vite';
+import pc from '@brillout/picocolors';
+import { getVikeConfigInternal } from '../vite/shared/resolveVikeConfigInternal.js';
+import { getServerEntryFilePath_ifDev } from '../vite/plugins/pluginUniversalDeploy/getServerConfig.js';
+import { isVikeCli } from '../cli/context.js';
+import { assert, assertInfo, assertUsage } from '../../utils/assert.js';
+import { isRunnableDevEnvironment } from '../../utils/isRunnableDevEnvironment.js';
+import './assertEnvApiDev.js';
+const IS_SERVER_CHILD_PROCESS = '__VIKE_IS_SERVER_CHILD_PROCESS';
+// The child process exits with this code to tell the parent process to restart it
+const EXIT_CODE_RESTART = 33;
+// Parent process — child_process.fork()
+function startServerEntry_parent() {
+    const [scriptPath, ...args] = process.argv.slice(1);
+    assert(scriptPath);
+    let child;
+    let signalReceived;
+    const forkChild = () => {
+        child = fork(scriptPath, args, { stdio: 'inherit', env: { ...process.env, [IS_SERVER_CHILD_PROCESS]: '1' } });
+        child.on('exit', (code, signal) => {
+            if (code === EXIT_CODE_RESTART && !signalReceived)
+                forkChild();
+            else
+                exitLikeChild(code, signal ?? signalReceived ?? null);
+        });
+    };
+    const onSignal = (signal) => {
+        signalReceived = signal;
+        child.kill(signal);
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    forkChild();
+    // The parent process exits when the child process exits
+    return new Promise(() => { });
+}
+// Exit with the same exit code or signal as the child process
+function exitLikeChild(code, signal) {
+    if (signal) {
+        process.removeAllListeners(signal);
+        process.kill(process.pid, signal);
+    }
+    else {
+        process.exit(code ?? 1);
+    }
+}
+// Child process — viteServer.ssrLoadModule()
+async function startServerEntry_child(viteServer, serverEntryFilePath) {
+    const { ssr } = viteServer.environments;
+    assertUsage(isRunnableDevEnvironment(ssr), `${pc.cyan('$ vike dev')} cannot run +serverEntry.js because Vite's ${pc.cyan('ssr')} environment isn't runnable`);
+    // Restart when +serverEntry.js or a file it imports changes
+    restartOnFileChange(viteServer, (filePath) => isImportedBy(ssr.moduleGraph.getModulesByFile(filePath), serverEntryFilePath));
+    // The user's server uses the current Vite development server (e.g. `app.use(devMiddleware)`) => we restart the process instead of letting Vite restart itself (e.g. upon vite.config.js changes)
+    viteServer.restart = async () => restart('Vite needs to restart');
+    closeOnSignal(viteServer);
+    try {
+        // Same module runner as the one Vike uses to load pages (`ssrLoadModule()`) => a module imported by both +serverEntry.js and a page is instantiated only once (like in production)
+        await viteServer.ssrLoadModule(serverEntryFilePath);
+    }
+    catch (err) {
+        console.error(err);
+        assertInfo(false, 'Waiting for file changes before restarting server...', { onlyOnce: false });
+        restartOnFileChange(viteServer, () => true);
+    }
+}
+function restartOnFileChange(viteServer, isRestartNeeded) {
+    const onFileChange = (filePath) => {
+        filePath = normalizePath(filePath);
+        if (isRestartNeeded(filePath))
+            restart(`${pc.cyan(path.relative(viteServer.config.root, filePath))} changed`);
+    };
+    viteServer.watcher.on('change', onFileChange);
+    viteServer.watcher.on('unlink', onFileChange);
+}
+// The user's server may handle SIGINT/SIGTERM without exiting the process (e.g. graceful shutdown: close the server and let the process exit once it's idle) => close Vite's development server, otherwise it keeps the process alive
+function closeOnSignal(viteServer) {
+    for (const signal of ['SIGINT', 'SIGTERM']) {
+        process.once(signal, () => {
+            void viteServer.close();
+            // Listening to a signal disables Node.js's default behavior of terminating the process => if the user's server doesn't listen to it, then we terminate the process ourselves
+            if (process.listenerCount(signal) === 0)
+                process.kill(process.pid, signal);
+        });
+    }
+}
+function restart(reason) {
+    assertInfo(false, `${reason}, restarting server...`, { onlyOnce: false });
+    process.exit(EXIT_CODE_RESTART);
+}
+// Only `$ vike dev` runs +serverEntry.js, not the programmatic API `dev()`: the parent process re-runs the command (process.argv) in the child process
+async function getServerEntryFilePath_ifDevCli() {
+    if (!isVikeCli())
+        return null;
+    const vikeConfig = await getVikeConfigInternal();
+    const serverEntryFilePath = getServerEntryFilePath_ifDev(vikeConfig);
+    return serverEntryFilePath;
+}
+// Whether one of the modules is +serverEntry.js or (transitively) imported by +serverEntry.js
+// - Pages aren't imported by +serverEntry.js: Vike loads them over its own virtual entries => changing a page doesn't restart the server (Vite's HMR handles it)
+function isImportedBy(modules, serverEntryFilePath) {
+    const visited = new Set();
+    const stack = [...(modules ?? [])];
+    while (stack.length > 0) {
+        const mod = stack.pop();
+        if (visited.has(mod))
+            continue;
+        visited.add(mod);
+        if (mod.file === serverEntryFilePath)
+            return true;
+        stack.push(...mod.importers);
+    }
+    return false;
+}
+function isServerChildProcess() {
+    return process.env[IS_SERVER_CHILD_PROCESS] === '1';
+}

package/dist/node/createDevMiddleware.js

@@ -1,12 +1,24 @@
 export { createDevMiddleware };
 import { createServer } from 'vite';
 import { prepareViteApiCall } from './api/prepareViteApiCall.js';
+import { getViteDevServer } from '../server/runtime/globalContext.js';
+import { assertWarning } from '../utils/assert.js';
+import pc from '@brillout/picocolors';
 /*
  * Create server middleware for development with HMR and lazy-transpiling.
  *
  * https://vike.dev/createDevMiddleware
  */
 async function createDevMiddleware(options = {}) {
+    {
+        const viteServer = getViteDevServer();
+        if (viteServer) {
+            assertWarning(false, 
+            // E.g. `$ vike dev` already created it (+serverEntry.js, +server.js), or createDevMiddleware() was already called
+            `Development middleware already created: use ${pc.cyan('globalContext.devMiddleware')} to access it instead of calling ${pc.cyan('createDevMiddleware()')}`, { onlyOnce: true });
+            return { devMiddleware: viteServer.middlewares, viteServer, viteConfig: viteServer.config };
+        }
+    }
     const optionsMod = {
         ...options,
         viteConfig: {

package/dist/node/prerender/resolvePrerenderConfig.d.ts

@@ -21,4 +21,4 @@ declare function resolvePrerenderConfigLocal(pageConfig: PageConfigBuildTime): P
 declare function isDistServerRemoved(prerenderConfigGlobal: {
     isPrerenderingEnabledForAllPages: boolean;
     keepDistServer: boolean;
-}): boolean;
+}, vikeConfig: Pick<VikeConfigInternal, '_pageConfigGlobal'>): boolean;

package/dist/node/prerender/resolvePrerenderConfig.js

@@ -70,9 +70,12 @@ async function resolvePrerenderConfigLocal(pageConfig) {
 }
 // Whether pre-rendering removes dist/server/ once it's done
 // https://vike.dev/prerender#keepDistServer
-function isDistServerRemoved(prerenderConfigGlobal) {
+function isDistServerRemoved(prerenderConfigGlobal, vikeConfig) {
     if (!prerenderConfigGlobal.isPrerenderingEnabledForAllPages)
         return false;
+    // +serverEntry.js => dist/server/index.mjs is the user's server entry
+    if (vikeConfig._pageConfigGlobal.configValueSources.serverEntry)
+        return false;
     return !prerenderConfigGlobal.keepDistServer;
 }
 function isObject2(value) {

package/dist/node/prerender/runPrerender.d.ts

@@ -32,13 +32,17 @@ type PrerenderContext = {
     _userRootDir: string;
     _outDirClient: string;
 };
-type Output<PageContext = PageContextPrerendered> = {
+type Output<PageContext = PageContextPrerendered> = ({
     filePath: string;
-    fileType: FileType;
+    fileType: 'HTML' | 'JSON';
     fileContent: string;
     pageContext: PageContext;
-}[];
-type FileType = 'HTML' | 'JSON';
+} | {
+    filePath: string;
+    fileType: 'CONTENT';
+    fileContent: string | Uint8Array;
+    pageContext: PageContext;
+})[];
 type PageContext = Awaited<ReturnType<typeof createPageContextPrerendering>> & {
     _urlOriginalBeforeHook?: string;
 };
@@ -72,12 +76,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     isPrerendering: boolean;
     _requestId: number;
 } & import("../../types/PageContext.js").PageContextInit & {
-    _nodeDev?: {
-        req: import("http").IncomingMessage;
-        res: import("http").ServerResponse;
-    };
-    _reqWeb?: Request;
-} & {
     _globalContext: ({
         config: import("../../types/index.js").ConfigResolved;
         _source: import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
@@ -101,6 +99,10 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _pageFilesAll: PageFile[];
         _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
         _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _environmentEntries: Record<string, {
+            pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+            pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
+        } | null>;
         _allPageIds: string[];
     } & (({
         isClientSide: false;
@@ -110,6 +112,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _isPrerendering: false;
         assetsManifest: null;
         _viteDevServer: import("vite").ViteDevServer | undefined;
+        devMiddleware: import("vite").Connect.Server | null;
         viteConfig: import("vite").ResolvedConfig | undefined;
     } | {
         isClientSide: false;
@@ -118,6 +121,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: true;
         viteConfig: import("vite").ResolvedConfig;
@@ -128,12 +132,11 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
         _isProduction: true;
         assetsManifest: import("../../types/ViteManifest.js").ViteManifest;
         _viteDevServer: null;
+        devMiddleware: null;
         _usesClientRouter: boolean;
         _isPrerendering: false;
         viteConfig: null;
     }) & {
-        baseServer: string;
-        baseAssets: string;
         viteConfigRuntime: {
             root: string;
             build: {
@@ -144,6 +147,9 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
                 inject: boolean | undefined;
             };
         };
+        baseServer: string;
+        baseAssets: string;
+        middlewares: import("../../server/runtime/universal-middleware/core.js").Middleware[];
     })) & {
         prerenderContext: PrerenderContextPublic | undefined;
     };
@@ -151,12 +157,6 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _baseServer: string;
     _baseAssets: string;
     _pageContextInit: import("../../types/PageContext.js").PageContextInit & {
-        _nodeDev?: {
-            req: import("http").IncomingMessage;
-            res: import("http").ServerResponse;
-        };
-        _reqWeb?: Request;
-    } & {
         headers?: Record<string, unknown>;
     };
     _urlHandler: ((url: string) => string) | null;