@solidjs/start 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/directives/xxhash32.js

@@ -0,0 +1,193 @@
+// @ts-nocheck
+/**
+ * Copyright (c) 2019 Jason Dent
+ * https://github.com/Jason3S/xxhash
+ */
+const PRIME32_1 = 2654435761;
+const PRIME32_2 = 2246822519;
+const PRIME32_3 = 3266489917;
+const PRIME32_4 = 668265263;
+const PRIME32_5 = 374761393;
+function toUtf8(text) {
+    const bytes = [];
+    for (let i = 0, n = text.length; i < n; ++i) {
+        const c = text.charCodeAt(i);
+        if (c < 0x80) {
+            bytes.push(c);
+        }
+        else if (c < 0x800) {
+            bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        }
+        else if (c < 0xd800 || c >= 0xe000) {
+            bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+        else {
+            const cp = 0x10000 + (((c & 0x3ff) << 10) | (text.charCodeAt(++i) & 0x3ff));
+            bytes.push(0xf0 | ((cp >> 18) & 0x7), 0x80 | ((cp >> 12) & 0x3f), 0x80 | ((cp >> 6) & 0x3f), 0x80 | (cp & 0x3f));
+        }
+    }
+    return new Uint8Array(bytes);
+}
+/**
+ *
+ * @param buffer - byte array or string
+ * @param seed - optional seed (32-bit unsigned);
+ */
+export default function xxHash32(buffer, seed = 0) {
+    buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
+    const b = buffer;
+    /*
+      Step 1. Initialize internal accumulators
+      Each accumulator gets an initial value based on optional seed input.
+      Since the seed is optional, it can be 0.
+      ```
+        u32 acc1 = seed + PRIME32_1 + PRIME32_2;
+        u32 acc2 = seed + PRIME32_2;
+        u32 acc3 = seed + 0;
+        u32 acc4 = seed - PRIME32_1;
+      ```
+      Special case : input is less than 16 bytes
+      When input is too small (< 16 bytes), the algorithm will not process any stripe.
+      Consequently, it will not make use of parallel accumulators.
+      In which case, a simplified initialization is performed, using a single accumulator :
+      u32 acc  = seed + PRIME32_5;
+      The algorithm then proceeds directly to step 4.
+    */
+    let acc = (seed + PRIME32_5) & 0xffffffff;
+    let offset = 0;
+    if (b.length >= 16) {
+        const accN = [
+            (seed + PRIME32_1 + PRIME32_2) & 0xffffffff,
+            (seed + PRIME32_2) & 0xffffffff,
+            (seed + 0) & 0xffffffff,
+            (seed - PRIME32_1) & 0xffffffff,
+        ];
+        /*
+          Step 2. Process stripes
+          A stripe is a contiguous segment of 16 bytes. It is evenly divided into 4 lanes,
+          of 4 bytes each. The first lane is used to update accumulator 1, the second lane
+          is used to update accumulator 2, and so on. Each lane read its associated 32-bit
+          value using little-endian convention. For each {lane, accumulator}, the update
+          process is called a round, and applies the following formula :
+          ```
+          accN = accN + (laneN * PRIME32_2);
+          accN = accN <<< 13;
+          accN = accN * PRIME32_1;
+          ```
+          This shuffles the bits so that any bit from input lane impacts several bits in
+          output accumulator. All operations are performed modulo 2^32.
+          Input is consumed one full stripe at a time. Step 2 is looped as many times as
+          necessary to consume the whole input, except the last remaining bytes which cannot
+          form a stripe (< 16 bytes). When that happens, move to step 3.
+        */
+        const b = buffer;
+        const limit = b.length - 16;
+        let lane = 0;
+        for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
+            const i = offset;
+            const laneN0 = b[i + 0] + (b[i + 1] << 8);
+            const laneN1 = b[i + 2] + (b[i + 3] << 8);
+            const laneNP = laneN0 * PRIME32_2 + ((laneN1 * PRIME32_2) << 16);
+            let acc = (accN[lane] + laneNP) & 0xffffffff;
+            acc = (acc << 13) | (acc >>> 19);
+            const acc0 = acc & 0xffff;
+            const acc1 = acc >>> 16;
+            accN[lane] = (acc0 * PRIME32_1 + ((acc1 * PRIME32_1) << 16)) & 0xffffffff;
+            lane = (lane + 1) & 0x3;
+        }
+        /*
+          Step 3. Accumulator convergence
+          All 4 lane accumulators from previous steps are merged to produce a
+          single remaining accumulator
+          of same width (32-bit). The associated formula is as follows :
+          ```
+          acc = (acc1 <<< 1) + (acc2 <<< 7) + (acc3 <<< 12) + (acc4 <<< 18);
+          ```
+        */
+        acc =
+            (((accN[0] << 1) | (accN[0] >>> 31)) +
+                ((accN[1] << 7) | (accN[1] >>> 25)) +
+                ((accN[2] << 12) | (accN[2] >>> 20)) +
+                ((accN[3] << 18) | (accN[3] >>> 14))) &
+                0xffffffff;
+    }
+    /*
+      Step 4. Add input length
+      The input total length is presumed known at this stage.
+      This step is just about adding the length to
+      accumulator, so that it participates to final mixing.
+      ```
+      acc = acc + (u32)inputLength;
+      ```
+    */
+    acc = (acc + buffer.length) & 0xffffffff;
+    /*
+      Step 5. Consume remaining input
+      There may be up to 15 bytes remaining to consume from the input.
+      The final stage will digest them according
+      to following pseudo-code :
+      ```
+      while (remainingLength >= 4) {
+          lane = read_32bit_little_endian(input_ptr);
+          acc = acc + lane * PRIME32_3;
+          acc = (acc <<< 17) * PRIME32_4;
+          input_ptr += 4; remainingLength -= 4;
+      }
+      ```
+      This process ensures that all input bytes are present in the final mix.
+    */
+    const limit = buffer.length - 4;
+    for (; offset <= limit; offset += 4) {
+        const i = offset;
+        const laneN0 = b[i + 0] + (b[i + 1] << 8);
+        const laneN1 = b[i + 2] + (b[i + 3] << 8);
+        const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
+        acc = (acc + laneP) & 0xffffffff;
+        acc = (acc << 17) | (acc >>> 15);
+        acc =
+            ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) &
+                0xffffffff;
+    }
+    /*
+          ```
+          while (remainingLength >= 1) {
+              lane = read_byte(input_ptr);
+              acc = acc + lane * PRIME32_5;
+              acc = (acc <<< 11) * PRIME32_1;
+              input_ptr += 1; remainingLength -= 1;
+          }
+          ```
+      */
+    for (; offset < b.length; ++offset) {
+        const lane = b[offset];
+        acc += lane * PRIME32_5;
+        acc = (acc << 11) | (acc >>> 21);
+        acc =
+            ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) &
+                0xffffffff;
+    }
+    /*
+          Step 6. Final mix (avalanche)
+          The final mix ensures that all input bits have a chance to impact any bit in
+          the output digest, resulting in an unbiased distribution. This is also called
+          avalanche effect.
+          ```
+          acc = acc xor (acc >> 15);
+          acc = acc * PRIME32_2;
+          acc = acc xor (acc >> 13);
+          acc = acc * PRIME32_3;
+          acc = acc xor (acc >> 16);
+          ```
+      */
+    acc ^= acc >>> 15;
+    acc =
+        (((acc & 0xffff) * PRIME32_2) & 0xffffffff) +
+            (((acc >>> 16) * PRIME32_2) << 16);
+    acc ^= acc >>> 13;
+    acc =
+        (((acc & 0xffff) * PRIME32_3) & 0xffffffff) +
+            (((acc >>> 16) * PRIME32_3) << 16);
+    acc ^= acc >>> 16;
+    // turn any negatives back into a positive number;
+    return acc < 0 ? acc + 4294967296 : acc;
+}

package/dist/fns/client.d.ts

@@ -0,0 +1,3 @@
+import { type Component } from "solid-js";
+export declare function cloneServerReference(id: string): (...args: any[]) => Promise<unknown>;
+export declare function createClientReference(Component: Component<any>, id: string): Component<any>;

package/dist/fns/client.js

@@ -0,0 +1,106 @@
+import { 
+// serializeToJSONStream,
+serializeToJSONString, } from "./serialization.js";
+import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody, } from "./shared.js";
+let INSTANCE = 0;
+function createRequest(base, id, instance, options) {
+    return fetch(base, {
+        method: "POST",
+        ...options,
+        headers: {
+            ...options.headers,
+            "X-Server-Id": id,
+            "X-Server-Instance": instance,
+        },
+    });
+}
+async function initializeResponse(base, id, instance, options, args) {
+    // No args, skip serialization
+    if (args.length === 0) {
+        return createRequest(base, id, instance, options);
+    }
+    // For single arguments, we can directly encode as body
+    if (args.length === 1) {
+        const body = args[0];
+        const result = getHeadersAndBody(body);
+        if (result) {
+            return createRequest(base, id, instance, {
+                ...options,
+                body: result.body,
+                headers: {
+                    ...options.headers,
+                    ...result.headers,
+                },
+            });
+        }
+    }
+    // Fallback to seroval
+    return createRequest(base, id, instance, {
+        ...options,
+        // TODO(Alexis): move to serializeToJSONStream
+        body: await serializeToJSONString(args),
+        // duplex: 'half',
+        // body: serializeToJSONStream(args),
+        headers: {
+            ...options.headers,
+            "Content-Type": "text/plain",
+            [BODY_FORMAT_KEY]: BodyFormat.Seroval,
+        },
+    });
+}
+async function fetchServerFunction(base, id, options, args) {
+    const instance = `server-fn:${INSTANCE++}`;
+    const response = await initializeResponse(base, id, instance, options, args);
+    if (response.headers.has("Location") ||
+        response.headers.has("X-Revalidate") ||
+        response.headers.has("X-Single-Flight")) {
+        if (response.body) {
+            /* @ts-ignore-next-line */
+            response.customBody = async () => {
+                return await extractBody(instance, true, response.clone());
+            };
+        }
+        return response;
+    }
+    const result = await extractBody(instance, true, response.clone());
+    if (response.headers.has("X-Error")) {
+        throw result;
+    }
+    return result;
+}
+export function cloneServerReference(id) {
+    let baseURL = import.meta.env.BASE_URL ?? "/";
+    if (!baseURL.endsWith("/"))
+        baseURL += "/";
+    const fn = (...args) => fetchServerFunction(`${baseURL}_server`, id, {}, args);
+    return new Proxy(fn, {
+        get(target, prop, receiver) {
+            if (prop === "url") {
+                return `${baseURL}_server?id=${encodeURIComponent(id)}`;
+            }
+            if (prop === "GET") {
+                return receiver.withOptions({ method: "GET" });
+            }
+            if (prop === "withOptions") {
+                const url = `${baseURL}_server?id=${encodeURIComponent(id)}`;
+                return (options) => {
+                    const fn = async (...args) => {
+                        const encodeArgs = options.method && options.method.toUpperCase() === "GET";
+                        return fetchServerFunction(encodeArgs
+                            ? url +
+                                (args.length
+                                    ? `&args=${encodeURIComponent(await serializeToJSONString(args))}`
+                                    : "")
+                            : `${baseURL}_server`, id, options, encodeArgs ? [] : args);
+                    };
+                    fn.url = url;
+                    return fn;
+                };
+            }
+            return target[prop];
+        },
+    });
+}
+export function createClientReference(Component, id) {
+    return Component;
+}

package/dist/fns/handler.d.ts

@@ -0,0 +1,5 @@
+import { type H3Event } from "h3";
+import "solid-start:server-fn-manifest";
+import type { FetchEvent } from "../server/types.ts";
+export declare function handleServerFunction(h3Event: H3Event): Promise<unknown>;
+export declare function createSingleFlightHeaders(sourceEvent: FetchEvent): Headers;

package/dist/fns/handler.js

@@ -0,0 +1,305 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { parseSetCookie } from "cookie-es";
+import { parseCookies } from "h3";
+import { sharedConfig } from "solid-js";
+import { renderToString } from "solid-js/web";
+import { provideRequestEvent } from "solid-js/web/storage";
+import { getFetchEvent, mergeResponseHeaders } from "../server/fetchEvent.js";
+import { createPageEvent } from "../server/handler.js";
+import { deserializeFromJSONString, serializeToJSONStream, serializeToJSStream, } from "./serialization.js";
+import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody } from "./shared.js";
+import "solid-start:server-fn-manifest";
+import { getServerFunction, hasServerFunction } from "./registration.js";
+import { getExpectedRedirectStatus } from "../server/util.js";
+export async function handleServerFunction(h3Event) {
+    const event = getFetchEvent(h3Event);
+    const request = event.request;
+    const serverReference = request.headers.get("X-Server-Id");
+    const instance = request.headers.get("X-Server-Instance");
+    const singleFlight = request.headers.has("X-Single-Flight");
+    const url = new URL(request.url);
+    let functionId;
+    if (serverReference) {
+        // invariant(typeof serverReference === "string", "Invalid server function");
+        [functionId] = serverReference.split("#");
+    }
+    else {
+        functionId = url.searchParams.get("id");
+        if (!functionId) {
+            return process.env.NODE_ENV === "development"
+                ? new Response("Server function not found", { status: 404 })
+                : new Response(null, { status: 404 });
+        }
+    }
+    if (import.meta.env.DEV && !hasServerFunction(functionId)) {
+        // The module that owns this function has not been evaluated in the server
+        // environment yet (e.g. the route was reached by client-side navigation, so
+        // it was only ever loaded in the browser). Ask the dev server to resolve the
+        // function id back to its owning module and import it, which registers it.
+        // Resolved by the "solid-start:server-functions/preload" plugin.
+        try {
+            // the /@id/ prefix routes the request through the plugin container so the
+            // virtual module can be resolved (bare ids get node-resolved by the runner)
+            await import(__rewriteRelativeImportExtension(
+            /* @vite-ignore */ `/@id/solid-start:server-fn-lookup?id=${encodeURIComponent(functionId)}`, true));
+        }
+        catch (error) {
+            // fall through to getServerFunction, which reports the missing function
+            console.error("[solid-start] server function lookup failed:", error);
+        }
+    }
+    const serverFunction = getServerFunction(functionId);
+    let parsed = [];
+    // grab bound arguments from url when no JS
+    if (!instance || request.method === "GET") {
+        const args = url.searchParams.get("args");
+        if (args) {
+            const result = (await deserializeFromJSONString(args));
+            for (const arg of result) {
+                parsed.push(arg);
+            }
+        }
+    }
+    if (request.method === "POST" && request.body !== null) {
+        const bodyFormat = request.headers.get(BODY_FORMAT_KEY);
+        const decoded = await extractBody("", false, request.clone());
+        if (bodyFormat === BodyFormat.Seroval) {
+            parsed = decoded;
+        }
+        else {
+            parsed.push(decoded);
+        }
+    }
+    try {
+        let result = await provideRequestEvent(event, async () => {
+            /* @ts-expect-error */
+            sharedConfig.context = { event };
+            event.locals.serverFunctionMeta = {
+                id: functionId,
+            };
+            return serverFunction(...parsed);
+        });
+        if (singleFlight && instance) {
+            result = await handleSingleFlight(event, result);
+        }
+        // handle responses
+        if (result instanceof Response) {
+            if (result.headers && result.headers.has("X-Content-Raw"))
+                return result;
+            if (instance) {
+                // forward headers
+                if (result.headers)
+                    mergeResponseHeaders(h3Event, result.headers);
+                // forward non-redirect statuses
+                if (result.status && (result.status < 300 || result.status >= 400))
+                    h3Event.res.status = result.status;
+                if (result.customBody) {
+                    result = await result.customBody();
+                }
+                else if (result.body == null)
+                    result = null;
+            }
+        }
+        // handle no JS success case
+        if (!instance)
+            return handleNoJS(result, request, parsed);
+        const body = getHeadersAndBody(result);
+        if (body) {
+            return new Response(body.body, {
+                headers: body.headers,
+            });
+        }
+        h3Event.res.headers.set(BODY_FORMAT_KEY, BodyFormat.Seroval);
+        if (import.meta.env.SEROVAL_MODE === "js") {
+            h3Event.res.headers.set("content-type", "text/javascript");
+            return serializeToJSStream(instance, result);
+        }
+        h3Event.res.headers.set("content-type", "text/plain");
+        return serializeToJSONStream(result);
+    }
+    catch (x) {
+        if (x instanceof Response) {
+            if (singleFlight && instance) {
+                x = await handleSingleFlight(event, x);
+            }
+            // forward headers
+            if (x.headers)
+                mergeResponseHeaders(h3Event, x.headers);
+            // forward non-redirect statuses
+            if (x.status && (!instance || x.status < 300 || x.status >= 400))
+                h3Event.res.status = x.status;
+            if (x.customBody) {
+                x = await x.customBody();
+            }
+            else if (x.body == null)
+                x = null;
+            h3Event.res.headers.set("X-Error", "true");
+        }
+        else if (instance) {
+            const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
+            h3Event.res.headers.set("X-Error", toHeaderValue(error));
+        }
+        else {
+            x = handleNoJS(x, request, parsed, true);
+        }
+        if (instance) {
+            const body = getHeadersAndBody(x);
+            if (body) {
+                const headers = new Headers(body.headers);
+                const errorHeader = h3Event.res.headers.get("X-Error");
+                if (errorHeader !== null) {
+                    headers.set("X-Error", errorHeader);
+                }
+                return new Response(body.body, {
+                    headers,
+                });
+            }
+            h3Event.res.headers.set(BODY_FORMAT_KEY, BodyFormat.Seroval);
+            if (import.meta.env.SEROVAL_MODE === "js") {
+                h3Event.res.headers.set("content-type", "text/javascript");
+                return serializeToJSStream(instance, x);
+            }
+            h3Event.res.headers.set("content-type", "text/plain");
+            return serializeToJSONStream(x);
+        }
+        return x;
+    }
+}
+// header values must be ByteString-safe (no chars > 0xFF), otherwise Headers.set throws
+function toHeaderValue(value) {
+    const stripped = value.replace(/[\r\n]+/g, "");
+    try {
+        return /[^\x00-\xFF]/.test(stripped) ? encodeURIComponent(stripped) : stripped;
+    }
+    catch {
+        // encodeURIComponent throws on lone surrogates
+        return "true";
+    }
+}
+function handleNoJS(result, request, parsed, thrown) {
+    const url = new URL(request.url);
+    const isError = result instanceof Error;
+    let statusCode = 302;
+    let headers;
+    if (result instanceof Response) {
+        headers = new Headers(result.headers);
+        if (result.headers.has("Location")) {
+            headers.set(`Location`, new URL(result.headers.get("Location"), url.origin + import.meta.env.BASE_URL).toString());
+            statusCode = getExpectedRedirectStatus(result);
+        }
+    }
+    else
+        headers = new Headers({
+            Location: new URL(request.headers.get("referer")).toString(),
+        });
+    if (result) {
+        headers.append("Set-Cookie", `flash=${encodeURIComponent(JSON.stringify({
+            url: url.pathname + url.search,
+            result: isError ? result.message : result,
+            thrown: thrown,
+            error: isError,
+            input: [...parsed.slice(0, -1), [...parsed[parsed.length - 1].entries()]],
+        }))}; Secure; HttpOnly;`);
+    }
+    return new Response(null, {
+        status: statusCode,
+        headers,
+    });
+}
+let App;
+export function createSingleFlightHeaders(sourceEvent) {
+    // cookie handling logic is pretty simplistic so this might be imperfect
+    // unclear if h3 internals are available on all platforms but we need a way to
+    // update request headers on the underlying H3 event.
+    const headers = new Headers(sourceEvent.request.headers);
+    const cookies = parseCookies(sourceEvent.nativeEvent);
+    const SetCookies = sourceEvent.response.headers.getSetCookie();
+    headers.delete("cookie");
+    // let useH3Internals = false;
+    // if (sourceEvent.nativeEvent.node?.req) {
+    // 	useH3Internals = true;
+    // 	sourceEvent.nativeEvent.node.req.headers.cookie = "";
+    // }
+    SetCookies.forEach(cookie => {
+        if (!cookie)
+            return;
+        const { maxAge, expires, name, value } = parseSetCookie(cookie);
+        if (maxAge != null && maxAge <= 0) {
+            delete cookies[name];
+            return;
+        }
+        if (expires != null && expires.getTime() <= Date.now()) {
+            delete cookies[name];
+            return;
+        }
+        cookies[name] = value;
+    });
+    Object.entries(cookies).forEach(([key, value]) => {
+        headers.append("cookie", `${key}=${value}`);
+        // useH3Internals &&
+        // 	(sourceEvent.nativeEvent.node.req.headers.cookie += `${key}=${value};`);
+    });
+    return headers;
+}
+async function handleSingleFlight(sourceEvent, result) {
+    let revalidate;
+    let url = new URL(sourceEvent.request.headers.get("referer")).toString();
+    if (result instanceof Response) {
+        if (result.headers.has("X-Revalidate"))
+            revalidate = result.headers.get("X-Revalidate").split(",");
+        if (result.headers.has("Location"))
+            url = new URL(result.headers.get("Location"), new URL(sourceEvent.request.url).origin + import.meta.env.BASE_URL).toString();
+    }
+    const event = { ...sourceEvent };
+    event.request = new Request(url, {
+        headers: createSingleFlightHeaders(sourceEvent),
+    });
+    return await provideRequestEvent(event, async () => {
+        await createPageEvent(event);
+        App || (App = (await import("solid-start:app")).default);
+        /* @ts-expect-error */
+        event.router.dataOnly = revalidate || true;
+        /* @ts-expect-error */
+        event.router.previousUrl = sourceEvent.request.headers.get("referer");
+        try {
+            renderToString(() => {
+                /* @ts-expect-error */
+                sharedConfig.context.event = event;
+                App();
+            });
+        }
+        catch (e) {
+            console.log(e);
+        }
+        /* @ts-expect-error */
+        const body = event.router.data;
+        if (!body)
+            return result;
+        let containsKey = false;
+        for (const key in body) {
+            if (body[key] === undefined)
+                delete body[key];
+            else
+                containsKey = true;
+        }
+        if (!containsKey)
+            return result;
+        if (!(result instanceof Response)) {
+            body["_$value"] = result;
+            result = new Response(null, { status: 200 });
+        }
+        else if (result.customBody) {
+            body["_$value"] = result.customBody();
+        }
+        result.customBody = () => body;
+        result.headers.set("X-Single-Flight", "true");
+        return result;
+    });
+}

package/dist/fns/registration.d.ts

@@ -0,0 +1,3 @@
+export declare function registerServerFunction<T extends any[], R>(id: string, callback: (...args: T) => Promise<R>): (...args: T) => Promise<R>;
+export declare function hasServerFunction(id: string): boolean;
+export declare function getServerFunction<T extends any[], R>(id: string): (...args: T) => Promise<R>;

package/dist/fns/registration.js

@@ -0,0 +1,15 @@
+const REGISTRATIONS = new Map();
+export function registerServerFunction(id, callback) {
+    REGISTRATIONS.set(id, callback);
+    return callback;
+}
+export function hasServerFunction(id) {
+    return REGISTRATIONS.has(id);
+}
+export function getServerFunction(id) {
+    const fn = REGISTRATIONS.get(id);
+    if (fn) {
+        return fn;
+    }
+    throw new Error("invalid server function: " + id);
+}

package/dist/fns/serialization.d.ts

@@ -0,0 +1,6 @@
+export declare function serializeToJSStream(id: string, value: any): ReadableStream<any>;
+export declare function serializeToJSONStream(value: any): ReadableStream<any>;
+export declare function serializeToJSONString(value: any): Promise<string>;
+export declare function deserializeFromJSONString(json: string): Promise<unknown>;
+export declare function deserializeJSONStream(response: Response | Request): Promise<unknown>;
+export declare function deserializeJSStream(id: string, response: Request | Response): Promise<unknown>;