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

package/dist/directives/remove-unused-variables.js

@@ -1,66 +0,0 @@
-import * as t from "@babel/types";
-import { isPathValid } from "./paths.js";
-function isInvalidForRemoval(path) {
-    if (isPathValid(path, t.isCatchClause)) {
-        // This case is for `catch (error)` blocks
-        return true;
-    }
-    // This one is for destructured variables
-    let target = path;
-    if (isPathValid(path, t.isVariableDeclarator)) {
-        target = path.get('id');
-    }
-    return isPathValid(target, t.isObjectPattern) || isPathValid(target, t.isArrayPattern);
-}
-export function removeUnusedVariables(program) {
-    // TODO(Alexis):
-    // This implementation is simple but slow
-    // We repeat removing unused variables from each pass
-    // until no potential unused variables are left.
-    // There might be a simpler implementation.
-    let dirty = true;
-    while (dirty) {
-        dirty = false;
-        program.traverse({
-            BindingIdentifier(path) {
-                const binding = path.scope.getBinding(path.node.name);
-                if (binding) {
-                    switch (binding.kind) {
-                        case "const":
-                        case "let":
-                        case "var":
-                        case "hoisted":
-                        case "module":
-                            if (binding.references === 0 && !binding.path.removed) {
-                                const parent = binding.path.parentPath;
-                                if (isPathValid(parent, t.isImportDeclaration)) {
-                                    if (parent.node.specifiers.length === 1) {
-                                        parent.remove();
-                                    }
-                                    else {
-                                        binding.path.remove();
-                                    }
-                                    dirty = true;
-                                }
-                                else if (!(isInvalidForRemoval(binding.path))) {
-                                    binding.path.remove();
-                                    dirty = true;
-                                }
-                            }
-                            break;
-                        case "local":
-                        case "param":
-                        case "unknown":
-                            break;
-                    }
-                }
-            },
-            VariableDeclaration(path) {
-                if (path.node.declarations.length === 0) {
-                    path.remove();
-                }
-            },
-        });
-        program.scope.crawl();
-    }
-}

package/dist/directives/types.d.ts

@@ -1,10 +0,0 @@
-export interface NamedImportDefinition {
-    kind: "named";
-    name: string;
-    source: string;
-}
-export interface DefaultImportDefinition {
-    kind: "default";
-    source: string;
-}
-export type ImportDefinition = DefaultImportDefinition | NamedImportDefinition;

package/dist/directives/types.js

@@ -1 +0,0 @@
-export {};

package/dist/directives/xxhash32.d.ts

@@ -1,6 +0,0 @@
-/**
- *
- * @param buffer - byte array or string
- * @param seed - optional seed (32-bit unsigned);
- */
-export default function xxHash32(buffer: Uint8Array | string, seed?: number): number;

package/dist/directives/xxhash32.js

@@ -1,193 +0,0 @@
-// @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

@@ -1,3 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,269 +0,0 @@
-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 } 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 });
-        }
-    }
-    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", error.replace(/[\r\n]+/g, ""));
-        }
-        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: 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;
-    }
-}
-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

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

package/dist/fns/registration.js

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