vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

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

@@ -0,0 +1,111 @@
+export { serializePageContextClientSide };
+export { serializePageContextAbort };
+import { stringify } from '@brillout/json-serializer/stringify';
+import { assert, assertWarning, hasProp, unique } from '../utils.js';
+import { isErrorPage } from '../../../shared/error-page.js';
+import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
+import pc from '@brillout/picocolors';
+import { notSerializable } from '../../../shared/notSerializable.js';
+const PASS_TO_CLIENT = [
+    'abortReason',
+    '_urlRewrite',
+    '_urlRedirect',
+    'abortStatusCode',
+    '_abortCall',
+    /* Not needed on the client-side
+    '_abortCaller',
+    */
+    '_pageContextInitHasClientData',
+    '_pageId'
+];
+const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', '_isError'];
+function serializePageContextClientSide(pageContext) {
+    const passToClient = getPassToClient(pageContext);
+    const pageContextClient = {};
+    passToClient.forEach((prop) => {
+        // We set non-existing props to `undefined`, in order to pass the list of passToClient values to the client-side
+        pageContextClient[prop] = pageContext[prop];
+    });
+    if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
+        pageContextClient._pageContextInitHasClientData = true;
+    }
+    let pageContextSerialized;
+    try {
+        pageContextSerialized = serialize(pageContextClient);
+    }
+    catch (err) {
+        const h = (s) => pc.cyan(s);
+        let hasWarned = false;
+        const propsNonSerializable = [];
+        passToClient.forEach((prop) => {
+            const propName = JSON.stringify(prop);
+            const varName = h(`pageContext[${propName}]`);
+            try {
+                serialize(pageContext[prop], varName);
+            }
+            catch (err) {
+                hasWarned = true;
+                propsNonSerializable.push(prop);
+                assert(hasProp(err, 'messageCore', 'string'));
+                assertWarning(false, [
+                    `${varName} cannot be serialized and, therefore, cannot be passed to the client.`,
+                    `Make sure that ${varName} is serializable, or remove ${h(propName)} from ${h('passToClient')}.`,
+                    `Serialization error: ${err.messageCore}.`
+                ].join(' '), { onlyOnce: false });
+            }
+        });
+        assert(hasWarned);
+        propsNonSerializable.forEach((prop) => {
+            pageContextClient[prop] = notSerializable;
+        });
+        pageContextSerialized = serialize(pageContextClient);
+    }
+    return pageContextSerialized;
+}
+function serialize(value, varName) {
+    return stringify(value, { forbidReactElements: true, valueName: varName });
+}
+function getPassToClient(pageContext) {
+    let passToClient = [...pageContext._passToClient, ...PASS_TO_CLIENT];
+    if (isErrorPage(pageContext._pageId, pageContext._pageConfigs)) {
+        assert(hasProp(pageContext, 'is404', 'boolean'));
+        addIs404ToPageProps(pageContext);
+        passToClient.push(...PASS_TO_CLIENT_ERROR_PAGE);
+    }
+    passToClient = unique(passToClient);
+    return passToClient;
+}
+function serializePageContextAbort(pageContext) {
+    assert(pageContext._urlRedirect || pageContext._urlRewrite || pageContext.abortStatusCode);
+    assert(pageContext._abortCall);
+    assert(pageContext._abortCaller);
+    // Not needed on the client-side
+    delete pageContext._abortCaller;
+    const unknownProps = Object.keys(pageContext).filter((prop) => ![
+        // prettier-ignore
+        '_abortCall',
+        /* Not needed on the client-side
+        '_abortCaller',
+        */
+        '_urlRedirect',
+        '_urlRewrite',
+        'abortStatusCode',
+        'abortReason',
+        'is404',
+        'pageProps'
+    ].includes(prop));
+    if (!pageContext._isLegacyRenderErrorPage) {
+        assert(unknownProps.length === 0);
+    }
+    else {
+        // TODO/v1-release: remove
+        assertWarning(unknownProps.length === 0, [
+            "The following pageContext values won't be available on the client-side:",
+            unknownProps.map((p) => `  pageContext[${JSON.stringify(p)}]`),
+            'Use `throw render()` instead of `throw RenderErrorPage()`'
+        ].join('\n'), {
+            onlyOnce: false
+        });
+    }
+    return serialize(pageContext);
+}

package/dist/esm/node/runtime/html/stream/react-streaming.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+export { isStreamReactStreaming };
+export { streamReactStreamingToString };
+export { getStreamFromReactStreaming };
+export type { StreamReactStreaming };
+export type { InjectToStream };
+import { StreamReadableWeb, StreamWritableNode } from '../stream.js';
+type InjectToStream = (chunk: unknown, options?: {
+    flush?: boolean;
+}) => void;
+type StreamReactStreaming = {
+    injectToStream: InjectToStream;
+    disabled?: boolean;
+} & ({
+    pipe: (writable: StreamWritableNode) => void;
+    readable: null;
+} | {
+    pipe: null;
+    readable: StreamReadableWeb;
+});
+declare function streamReactStreamingToString(stream: StreamReactStreaming): Promise<string>;
+declare function isStreamReactStreaming(thing: unknown): thing is StreamReactStreaming;
+declare function getStreamFromReactStreaming(stream: StreamReactStreaming): StreamReadableWeb | {
+    __streamPipeNode: (writable: import("stream").Writable) => void;
+};

package/dist/esm/node/runtime/html/stream/react-streaming.js

@@ -0,0 +1,33 @@
+// Zero-config support for https://www.npmjs.com/package/react-streaming
+export { isStreamReactStreaming };
+export { streamReactStreamingToString };
+export { getStreamFromReactStreaming };
+import { assert, hasProp } from '../../utils.js';
+import { streamPipeNodeToString, streamReadableWebToString } from '../stream.js';
+function streamReactStreamingToString(stream) {
+    if (stream.pipe) {
+        return streamPipeNodeToString(stream.pipe);
+    }
+    if (stream.readable) {
+        return streamReadableWebToString(stream.readable);
+    }
+    assert(false);
+}
+function isStreamReactStreaming(thing) {
+    if (hasProp(thing, 'injectToStream', 'function')) {
+        return true;
+    }
+    // TODO
+    //if( isStreamPipeNode
+    return false;
+}
+function getStreamFromReactStreaming(stream) {
+    if (stream.pipe) {
+        // TODO
+        return { __streamPipeNode: stream.pipe };
+    }
+    if (stream.readable) {
+        return stream.readable;
+    }
+    assert(false);
+}

package/dist/esm/node/runtime/html/stream.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" resolution-mode="require"/>
+export { processStream };
+export { streamToString };
+export { stampPipe };
+export { pipeStream };
+export { pipeWebStream };
+export { pipeNodeStream };
+export { getStreamReadableNode };
+export { getStreamReadableWeb };
+export { pipeToStreamWritableNode };
+export { pipeToStreamWritableWeb };
+export { isStream };
+export { isStreamPipeWeb };
+export { isStreamPipeNode };
+export { isStreamReadableWeb };
+export { isStreamReadableNode };
+export { getStreamName };
+export { inferStreamName };
+export { streamReadableWebToString };
+export { streamPipeNodeToString };
+export { isStreamWritableWeb };
+export { isStreamWritableNode };
+export type { StreamProviderAny };
+export type { StreamProviderNormalized };
+export type { StreamTypePatch };
+export type { StreamReadableWeb };
+export type { StreamReadableNode };
+export type { StreamWritableWeb };
+export type { StreamWritableNode };
+export type { StreamPipeWeb };
+export type { StreamPipeNode };
+import { HtmlRender } from './renderHtml.js';
+import { StreamReactStreaming } from './stream/react-streaming.js';
+import type { Readable as Readable_, Writable as Writable_ } from 'node:stream';
+type StreamReadableWeb = ReadableStream;
+type StreamReadableNode = Readable_;
+type StreamWritableWeb = WritableStream;
+type StreamWritableNode = Writable_;
+type StreamPipeWeb = (writable: StreamWritableWeb) => void;
+type StreamPipeNode = (writable: StreamWritableNode) => void;
+type StreamProviderNormalized = StreamReadableWeb | StreamReadableNode | StreamPipeWeb | StreamPipeNode;
+type StreamProviderAny = StreamProviderNormalized | StreamReactStreaming | StreamPipeWebWrapped | StreamPipeNodeWrapped;
+type StreamTypePatch = NodeJS.ReadableStream;
+declare function isStreamReadableWeb(thing: unknown): thing is StreamReadableWeb;
+declare function isStreamWritableWeb(thing: unknown): thing is StreamWritableWeb;
+declare function isStreamReadableNode(thing: unknown): thing is StreamReadableNode;
+declare function isStreamWritableNode(thing: unknown): thing is StreamWritableNode;
+declare function streamReadableWebToString(readableWeb: ReadableStream): Promise<string>;
+declare function streamPipeNodeToString(streamPipeNode: StreamPipeNode): Promise<string>;
+declare function getStreamReadableNode(htmlRender: HtmlRender): Promise<null | StreamReadableNode>;
+declare function getStreamReadableWeb(htmlRender: HtmlRender): null | StreamReadableWeb;
+declare function pipeToStreamWritableWeb(htmlRender: HtmlRender, writable: StreamWritableWeb): boolean;
+declare function pipeToStreamWritableNode(htmlRender: HtmlRender, writable: StreamWritableNode): boolean;
+declare function processStream(streamOriginal: StreamProviderAny, { injectStringAtBegin, injectStringAtEnd, onErrorWhileStreaming, enableEagerStreaming }: {
+    injectStringAtBegin?: () => Promise<string>;
+    injectStringAtEnd?: () => Promise<string>;
+    onErrorWhileStreaming: (err: unknown) => void;
+    enableEagerStreaming?: boolean;
+}): Promise<StreamProviderNormalized>;
+declare function isStream(something: unknown): something is StreamProviderAny;
+declare const __streamPipeWeb = "__streamPipeWeb";
+type StreamPipeWebWrapped = {
+    [__streamPipeWeb]: StreamPipeWeb;
+};
+/** @deprecated */
+declare function pipeWebStream(pipe: StreamPipeWeb): StreamPipeWebWrapped;
+declare function isStreamPipeWeb(thing: unknown): thing is StreamPipeWebWrapped | StreamPipeWeb;
+declare const __streamPipeNode = "__streamPipeNode";
+type StreamPipeNodeWrapped = {
+    [__streamPipeNode]: StreamPipeNode;
+};
+/** @deprecated */
+declare function pipeNodeStream(pipe: StreamPipeNode): StreamPipeNodeWrapped;
+declare function isStreamPipeNode(thing: unknown): thing is StreamPipeNodeWrapped | StreamPipeNode;
+declare function stampPipe(pipe: StreamPipeNode | StreamPipeWeb, pipeType: 'web-stream' | 'node-stream'): void;
+type StreamPipe = (writable: StreamWritableNode | StreamWritableWeb) => void;
+declare const __streamPipe = "__streamPipe";
+type StreamPipeWrapped = {
+    [__streamPipe]: StreamPipe;
+};
+declare function pipeStream(pipe: StreamPipe): StreamPipeWrapped;
+declare function streamToString(stream: StreamProviderAny): Promise<string>;
+declare function getStreamName(type: 'pipe' | 'readable' | 'writable', standard: 'web' | 'node'): `a ${string} Stream` | `a ${string} Stream Pipe`;
+declare function inferStreamName(stream: StreamProviderNormalized): `a ${string} Stream` | `a ${string} Stream Pipe`;