@solidjs/start 2.0.0-alpha.3 → 2.0.0-beta.1

package/dist/fns/serialization.js

@@ -1,208 +0,0 @@
-import { crossSerializeStream, deserialize, Feature, fromCrossJSON, getCrossReferenceHeader, toCrossJSONStream, } from "seroval";
-import { AbortSignalPlugin, CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin, } from "seroval-plugins/web";
-// TODO(Alexis): if we can, allow providing an option to extend these.
-const DEFAULT_PLUGINS = [
-    AbortSignalPlugin,
-    CustomEventPlugin,
-    DOMExceptionPlugin,
-    EventPlugin,
-    FormDataPlugin,
-    HeadersPlugin,
-    ReadableStreamPlugin,
-    RequestPlugin,
-    ResponsePlugin,
-    URLSearchParamsPlugin,
-    URLPlugin,
-];
-const MAX_SERIALIZATION_DEPTH_LIMIT = 64;
-const DISABLED_FEATURES = Feature.RegExp;
-/**
- * Alexis:
- *
- * A "chunk" is a piece of data emitted by the streaming serializer.
- * Each chunk is represented by a 32-bit value (encoded in hexadecimal),
- * followed by the encoded string (8-bit representation). This format
- * is important so we know how much of the chunk being streamed we
- * are expecting before parsing the entire string data.
- *
- * This is sort of a bootleg "multipart/form-data" except it's bad at
- * handling File/Blob LOL
- *
- * The format is as follows:
- * ;0xFFFFFFFF;<string data>
- */
-function createChunk(data) {
-    const encodeData = new TextEncoder().encode(data);
-    const bytes = encodeData.length;
-    const baseHex = bytes.toString(16);
-    const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex; // 32-bit
-    const head = new TextEncoder().encode(`;0x${totalHex};`);
-    const chunk = new Uint8Array(12 + bytes);
-    chunk.set(head);
-    chunk.set(encodeData, 12);
-    return chunk;
-}
-export function serializeToJSStream(id, value) {
-    return new ReadableStream({
-        start(controller) {
-            crossSerializeStream(value, {
-                scopeId: id,
-                plugins: DEFAULT_PLUGINS,
-                onSerialize(data, initial) {
-                    controller.enqueue(createChunk(initial ? `(${getCrossReferenceHeader(id)},${data})` : data));
-                },
-                onDone() {
-                    controller.close();
-                },
-                onError(error) {
-                    controller.error(error);
-                },
-            });
-        },
-    });
-}
-export function serializeToJSONStream(value) {
-    return new ReadableStream({
-        start(controller) {
-            toCrossJSONStream(value, {
-                disabledFeatures: DISABLED_FEATURES,
-                depthLimit: MAX_SERIALIZATION_DEPTH_LIMIT,
-                plugins: DEFAULT_PLUGINS,
-                onParse(node) {
-                    controller.enqueue(createChunk(JSON.stringify(node)));
-                },
-                onDone() {
-                    controller.close();
-                },
-                onError(error) {
-                    controller.error(error);
-                },
-            });
-        },
-    });
-}
-class SerovalChunkReader {
-    reader;
-    buffer;
-    done;
-    constructor(stream) {
-        this.reader = stream.getReader();
-        this.buffer = new Uint8Array(0);
-        this.done = false;
-    }
-    async readChunk() {
-        // if there's no chunk, read again
-        const chunk = await this.reader.read();
-        if (!chunk.done) {
-            // repopulate the buffer
-            const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
-            newBuffer.set(this.buffer);
-            newBuffer.set(chunk.value, this.buffer.length);
-            this.buffer = newBuffer;
-        }
-        else {
-            this.done = true;
-        }
-    }
-    async next() {
-        // Check if the buffer is empty
-        if (this.buffer.length === 0) {
-            // if we are already done...
-            if (this.done) {
-                return {
-                    done: true,
-                    value: undefined,
-                };
-            }
-            // Otherwise, read a new chunk
-            await this.readChunk();
-            return await this.next();
-        }
-        // Read the "byte header"
-        // The byte header tells us how big the expected data is
-        // so we know how much data we should wait before we
-        // deserialize the data
-        const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
-        const bytes = Number.parseInt(head, 16); // ;0x00000000;
-        if (Number.isNaN(bytes)) {
-            throw new Error("Malformed server function stream.");
-        }
-        // Check if the buffer has enough bytes to be parsed
-        while (bytes > this.buffer.length - 12) {
-            // If it's not enough, and the reader is done
-            // then the chunk is invalid.
-            if (this.done) {
-                throw new Error("Malformed server function stream.");
-            }
-            // Otherwise, we read more chunks
-            await this.readChunk();
-        }
-        // Extract the exact chunk as defined by the byte header
-        const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
-        // The rest goes to the buffer
-        this.buffer = this.buffer.subarray(12 + bytes);
-        // Deserialize the chunk
-        return {
-            done: false,
-            value: partial,
-        };
-    }
-    async drain(interpret) {
-        while (true) {
-            const result = await this.next();
-            if (result.done) {
-                break;
-            }
-            else {
-                interpret(result.value);
-            }
-        }
-    }
-}
-export async function serializeToJSONString(value) {
-    const response = new Response(serializeToJSONStream(value));
-    return await response.text();
-}
-export async function deserializeFromJSONString(json) {
-    const blob = new Response(json);
-    return await deserializeJSONStream(blob);
-}
-export async function deserializeJSONStream(response) {
-    if (!response.body) {
-        throw new Error("missing body");
-    }
-    const reader = new SerovalChunkReader(response.body);
-    const result = await reader.next();
-    if (!result.done) {
-        const refs = new Map();
-        function interpretChunk(chunk) {
-            const value = fromCrossJSON(JSON.parse(chunk), {
-                refs,
-                disabledFeatures: DISABLED_FEATURES,
-                depthLimit: MAX_SERIALIZATION_DEPTH_LIMIT,
-                plugins: DEFAULT_PLUGINS,
-            });
-            return value;
-        }
-        void reader.drain(interpretChunk);
-        return interpretChunk(result.value);
-    }
-    return undefined;
-}
-export async function deserializeJSStream(id, response) {
-    if (!response.body) {
-        throw new Error("missing body");
-    }
-    const reader = new SerovalChunkReader(response.body);
-    const result = await reader.next();
-    if (!result.done) {
-        reader.drain(deserialize).then(() => {
-            // @ts-ignore
-            delete $R[id];
-        }, () => {
-            // no-op
-        });
-        return deserialize(result.value);
-    }
-    return undefined;
-}

package/dist/fns/server.d.ts

@@ -1,7 +0,0 @@
-interface Registration<T extends any[], R> {
-    id: string;
-    fn: (...args: T) => Promise<R>;
-}
-export declare function createServerReference<T extends any[], R>(id: string, fn: (...args: T) => Promise<R>): Registration<T, R>;
-export declare function cloneServerReference<T extends any[], R>({ id, fn }: Registration<T, R>): (...args: T) => Promise<R>;
-export {};

package/dist/fns/server.js

@@ -1,38 +0,0 @@
-import { getRequestEvent } from "solid-js/web";
-import { provideRequestEvent } from "solid-js/web/storage";
-import { registerServerFunction } from "./registration.js";
-export function createServerReference(id, fn) {
-    const registration = { id, fn };
-    registerServerFunction(id, fn);
-    return registration;
-}
-export function cloneServerReference({ id, fn }) {
-    if (typeof fn !== "function")
-        throw new Error("Export from a 'use server' module must be a function");
-    let baseURL = import.meta.env.BASE_URL ?? "/";
-    if (!baseURL.endsWith("/"))
-        baseURL += "/";
-    return new Proxy(fn, {
-        get(target, prop, receiver) {
-            if (prop === "url") {
-                return `${baseURL}_server?id=${encodeURIComponent(id)}`;
-            }
-            if (prop === "GET")
-                return receiver;
-            return target[prop];
-        },
-        apply(target, thisArg, args) {
-            const ogEvt = getRequestEvent();
-            if (!ogEvt)
-                throw new Error("Cannot call server function outside of a request");
-            const evt = { ...ogEvt };
-            evt.locals.serverFunctionMeta = {
-                id,
-            };
-            evt.serverOnly = true;
-            return provideRequestEvent(evt, () => {
-                return fn.apply(thisArg, args);
-            });
-        },
-    });
-}

package/dist/fns/shared.d.ts

@@ -1,17 +0,0 @@
-export declare const BODY_FORMAT_KEY = "X-Start-Type";
-export declare const BODY_FORMAL_FILE = "__START__";
-export declare const enum BodyFormat {
-    Seroval = "0",
-    String = "1",
-    FormData = "2",
-    URLSearchParams = "3",
-    Blob = "4",
-    File = "5",
-    ArrayBuffer = "6",
-    Uint8Array = "7"
-}
-export declare function getHeadersAndBody(body: any): {
-    headers?: HeadersInit;
-    body: BodyInit;
-} | undefined;
-export declare function extractBody(instance: string, client: boolean, source: Request | Response): Promise<unknown>;

package/dist/fns/shared.js

@@ -1,105 +0,0 @@
-import { deserializeJSONStream, deserializeJSStream } from "./serialization.js";
-export const BODY_FORMAT_KEY = "X-Start-Type";
-export const BODY_FORMAL_FILE = "__START__";
-export var BodyFormat;
-(function (BodyFormat) {
-    BodyFormat["Seroval"] = "0";
-    BodyFormat["String"] = "1";
-    BodyFormat["FormData"] = "2";
-    BodyFormat["URLSearchParams"] = "3";
-    BodyFormat["Blob"] = "4";
-    BodyFormat["File"] = "5";
-    BodyFormat["ArrayBuffer"] = "6";
-    BodyFormat["Uint8Array"] = "7";
-})(BodyFormat || (BodyFormat = {}));
-export function getHeadersAndBody(body) {
-    switch (true) {
-        case typeof body === "string":
-            return {
-                headers: {
-                    "Content-Type": "text/plain",
-                    [BODY_FORMAT_KEY]: BodyFormat.String,
-                },
-                body,
-            };
-        case body instanceof FormData:
-            return {
-                headers: {
-                    [BODY_FORMAT_KEY]: BodyFormat.FormData,
-                },
-                body,
-            };
-        case body instanceof URLSearchParams:
-            return {
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                    [BODY_FORMAT_KEY]: BodyFormat.URLSearchParams,
-                },
-                body,
-            };
-        case body instanceof File: {
-            const formData = new FormData();
-            formData.append(BODY_FORMAL_FILE, body, body.name);
-            return {
-                headers: {
-                    [BODY_FORMAT_KEY]: BodyFormat.File,
-                },
-                body: formData,
-            };
-        }
-        case body instanceof Blob:
-            return {
-                headers: {
-                    [BODY_FORMAT_KEY]: BodyFormat.Blob,
-                },
-                body,
-            };
-        case body instanceof ArrayBuffer:
-            return {
-                headers: {
-                    [BODY_FORMAT_KEY]: BodyFormat.ArrayBuffer,
-                },
-                body,
-            };
-        case body instanceof Uint8Array:
-            return {
-                headers: {
-                    [BODY_FORMAT_KEY]: BodyFormat.Uint8Array,
-                },
-                body: new Uint8Array(body),
-            };
-        default:
-            return undefined;
-    }
-}
-export async function extractBody(instance, client, source) {
-    const contentType = source.headers.get("content-type");
-    const startType = source.headers.get(BODY_FORMAT_KEY);
-    const clone = source.clone();
-    switch (true) {
-        case startType === BodyFormat.Seroval:
-            if (client && import.meta.env.SEROVAL_MODE === "js") {
-                return await deserializeJSStream(instance, clone);
-            }
-            return await deserializeJSONStream(clone);
-        case startType === BodyFormat.String:
-            return await clone.text();
-        case startType === BodyFormat.File: {
-            const formData = await clone.formData();
-            return formData.get(BODY_FORMAL_FILE);
-        }
-        case startType === BodyFormat.FormData:
-        case contentType?.startsWith("multipart/form-data"):
-            return await clone.formData();
-        case startType === BodyFormat.URLSearchParams:
-        case contentType?.startsWith("application/x-www-form-urlencoded"):
-            return new URLSearchParams(await clone.text());
-        case startType === BodyFormat.Blob:
-            return await clone.blob();
-        case startType === BodyFormat.ArrayBuffer:
-            return await clone.arrayBuffer();
-        case startType === BodyFormat.Uint8Array:
-            return new Uint8Array(await clone.arrayBuffer());
-    }
-    return undefined;
-}

package/dist/http/index.d.ts

@@ -1,81 +0,0 @@
-import type { H3Event, HTTPEvent, InferEventInput } from "h3";
-import * as h3 from "h3";
-declare function _setContext(event: H3Event, key: string, value: any): void;
-declare function _getContext(event: H3Event, key: string): unknown;
-export declare function getWebRequest(): Request;
-export declare const HTTPEventSymbol: unique symbol;
-export declare function isEvent(obj: any): obj is h3.H3Event | {
-    [HTTPEventSymbol]: h3.H3Event;
-};
-type Tail<T> = T extends [any, ...infer U] ? U : never;
-type PrependOverload<TOriginal extends (...args: Array<any>) => any, TOverload extends (...args: Array<any>) => any> = TOverload & TOriginal;
-type WrapFunction<TFn extends (...args: Array<any>) => any> = PrependOverload<TFn, (...args: Parameters<TFn> extends [h3.HTTPEvent<any> | h3.H3Event<any>, ...infer TArgs] ? TArgs : Parameters<TFn>) => ReturnType<TFn>>;
-type WrappedReadBody = <T, TEventInput = InferEventInput<"body", H3Event, T>>(...args: Tail<Parameters<typeof h3.readBody<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.readBody<T, h3.H3Event, TEventInput>>;
-export declare const readBody: PrependOverload<typeof h3.readBody, WrappedReadBody>;
-type WrappedGetQuery = <T, TEventInput = Exclude<InferEventInput<"query", H3Event, T>, undefined>>(...args: Tail<Parameters<typeof h3.getQuery<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getQuery<T, H3Event, TEventInput>>;
-export declare const getQuery: PrependOverload<typeof h3.getQuery, WrappedGetQuery>;
-export declare const isMethod: WrapFunction<typeof h3.isMethod>;
-export declare const isPreflightRequest: WrapFunction<typeof h3.isPreflightRequest>;
-type WrappedGetValidatedQuery = <T extends HTTPEvent, TEventInput = InferEventInput<"query", H3Event, T>>(...args: Tail<Parameters<typeof h3.getValidatedQuery<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getValidatedQuery<T, H3Event, TEventInput>>;
-export declare const getValidatedQuery: PrependOverload<typeof h3.getValidatedQuery, WrappedGetValidatedQuery>;
-export declare const getRouterParams: WrapFunction<typeof h3.getRouterParams>;
-export declare const getRouterParam: WrapFunction<typeof h3.getRouterParam>;
-type WrappedGetValidatedRouterParams = <T extends HTTPEvent, TEventInput = InferEventInput<"routerParams", H3Event, T>>(...args: Tail<Parameters<typeof h3.getValidatedRouterParams<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.getValidatedRouterParams<T, H3Event, TEventInput>>;
-export declare const getValidatedRouterParams: PrependOverload<typeof h3.getValidatedRouterParams, WrappedGetValidatedRouterParams>;
-export declare const assertMethod: WrapFunction<typeof h3.assertMethod>;
-export declare const getRequestHeaders: WrapFunction<typeof h3.getRequestHeaders>;
-export declare const getRequestHeader: WrapFunction<typeof h3.getRequestHeader>;
-export declare const getRequestURL: WrapFunction<typeof h3.getRequestURL>;
-export declare const getRequestHost: WrapFunction<typeof h3.getRequestHost>;
-export declare const getRequestProtocol: WrapFunction<typeof h3.getRequestProtocol>;
-export declare const getRequestIP: WrapFunction<typeof h3.getRequestIP>;
-export declare const setResponseStatus: (code?: number, text?: string) => void;
-export declare const getResponseStatus: () => number | undefined;
-export declare const getResponseStatusText: () => string | undefined;
-export declare const getResponseHeaders: () => {
-    [k: string]: string;
-};
-export declare const getResponseHeader: (name: string) => string | null;
-export declare const setResponseHeaders: (values: Record<string, string>) => void;
-export declare const setResponseHeader: (name: string, value: string | string[]) => void;
-export declare const appendResponseHeaders: (values: Record<string, string>) => void;
-export declare const appendResponseHeader: (name: string, value: string | string[]) => void;
-export declare const defaultContentType: (type: string) => void;
-export declare const proxyRequest: WrapFunction<typeof h3.proxyRequest>;
-export declare const fetchWithEvent: WrapFunction<typeof h3.fetchWithEvent>;
-export declare const getProxyRequestHeaders: WrapFunction<typeof h3.getProxyRequestHeaders>;
-export declare const parseCookies: WrapFunction<typeof h3.parseCookies>;
-export declare const getCookie: WrapFunction<typeof h3.getCookie>;
-export declare const setCookie: WrapFunction<typeof h3.setCookie>;
-export declare const deleteCookie: WrapFunction<typeof h3.deleteCookie>;
-type SessionDataT = Record<string, any>;
-type WrappedUseSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.useSession<T>>>) => ReturnType<typeof h3.useSession<T>>;
-export declare const useSession: WrappedUseSession;
-type WrappedGetSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.getSession<T>>>) => ReturnType<typeof h3.getSession<T>>;
-export declare const getSession: WrappedGetSession;
-type WrappedUpdateSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.updateSession<T>>>) => ReturnType<typeof h3.updateSession<T>>;
-export declare const updateSession: WrappedUpdateSession;
-type WrappedSealSession = <T extends SessionDataT>(...args: Tail<Parameters<typeof h3.sealSession<T>>>) => ReturnType<typeof h3.sealSession<T>>;
-export declare const sealSession: WrappedSealSession;
-export declare const unsealSession: WrapFunction<typeof h3.unsealSession>;
-export declare const clearSession: WrapFunction<typeof h3.clearSession>;
-export declare const handleCacheHeaders: WrapFunction<typeof h3.handleCacheHeaders>;
-export declare const handleCors: WrapFunction<typeof h3.handleCors>;
-export declare const appendCorsHeaders: WrapFunction<typeof h3.appendCorsHeaders>;
-export declare const appendCorsPreflightHeaders: WrapFunction<typeof h3.appendCorsPreflightHeaders>;
-export declare const appendHeader: (name: string, value: string | string[]) => void;
-export declare const appendHeaders: (values: Record<string, string>) => void;
-export declare const setHeader: (name: string, value: string | string[]) => void;
-export declare const setHeaders: (values: Record<string, string>) => void;
-export declare const getHeader: WrapFunction<typeof h3.getRequestHeader>;
-export declare const getHeaders: WrapFunction<typeof h3.getRequestHeaders>;
-export declare const getRequestFingerprint: WrapFunction<typeof h3.getRequestFingerprint>;
-export declare const getRequestWebStream: () => ReadableStream<Uint8Array<ArrayBuffer>> | null;
-export declare const readFormData: () => Promise<FormData>;
-type WrappedReadValidatedBody = <T extends HTTPEvent, TEventInput = InferEventInput<"body", H3Event, T>>(...args: Tail<Parameters<typeof h3.readValidatedBody<T, H3Event, TEventInput>>>) => ReturnType<typeof h3.readValidatedBody<T, H3Event, TEventInput>>;
-export declare const readValidatedBody: PrependOverload<typeof h3.readValidatedBody, WrappedReadValidatedBody>;
-export declare const getContext: WrapFunction<typeof _getContext>;
-export declare const setContext: WrapFunction<typeof _setContext>;
-export declare const removeResponseHeader: (name: string) => void;
-export declare const clearResponseHeaders: (headerNames?: string[]) => void;
-export {};

package/dist/http/index.js

@@ -1,129 +0,0 @@
-import * as h3 from "h3";
-import { getRequestEvent } from "solid-js/web";
-function _setContext(event, key, value) {
-    event.context[key] = value;
-}
-function _getContext(event, key) {
-    return event.context[key];
-}
-function getEvent() {
-    return getRequestEvent().nativeEvent;
-}
-export function getWebRequest() {
-    return getEvent().req;
-}
-export const HTTPEventSymbol = Symbol("$HTTPEvent");
-export function isEvent(obj) {
-    return (typeof obj === "object" &&
-        (obj instanceof h3.H3Event ||
-            obj?.[HTTPEventSymbol] instanceof h3.H3Event ||
-            obj?.__is_event__ === true));
-    // Implement logic to check if obj is an H3Event
-}
-function createWrapperFunction(h3Function) {
-    return ((...args) => {
-        const event = args[0];
-        if (!isEvent(event)) {
-            args.unshift(getEvent());
-        }
-        else {
-            args[0] =
-                event instanceof h3.H3Event || event.__is_event__ ? event : event[HTTPEventSymbol];
-        }
-        return h3Function(...args);
-    });
-}
-export const readBody = createWrapperFunction(h3.readBody);
-export const getQuery = createWrapperFunction(h3.getQuery);
-export const isMethod = createWrapperFunction(h3.isMethod);
-export const isPreflightRequest = createWrapperFunction(h3.isPreflightRequest);
-export const getValidatedQuery = createWrapperFunction(h3.getValidatedQuery);
-export const getRouterParams = createWrapperFunction(h3.getRouterParams);
-export const getRouterParam = createWrapperFunction(h3.getRouterParam);
-export const getValidatedRouterParams = createWrapperFunction(h3.getValidatedRouterParams);
-export const assertMethod = createWrapperFunction(h3.assertMethod);
-export const getRequestHeaders = createWrapperFunction(h3.getRequestHeaders);
-export const getRequestHeader = createWrapperFunction(h3.getRequestHeader);
-export const getRequestURL = createWrapperFunction(h3.getRequestURL);
-export const getRequestHost = createWrapperFunction(h3.getRequestHost);
-export const getRequestProtocol = createWrapperFunction(h3.getRequestProtocol);
-export const getRequestIP = createWrapperFunction(h3.getRequestIP);
-export const setResponseStatus = (code, text) => {
-    const e = getEvent();
-    if (e.res.status !== undefined)
-        e.res.status = code;
-    if (e.res.statusText !== undefined)
-        e.res.statusText = text;
-};
-export const getResponseStatus = () => getEvent().res.status;
-export const getResponseStatusText = () => getEvent().res.statusText;
-export const getResponseHeaders = () => Object.fromEntries(getEvent().res.headers.entries());
-export const getResponseHeader = (name) => getEvent().res.headers.get(name);
-export const setResponseHeaders = (values) => {
-    const headers = getEvent().res.headers;
-    for (const [name, value] of Object.entries(values)) {
-        headers.set(name, value);
-    }
-};
-export const setResponseHeader = (name, value) => {
-    const headers = getEvent().res.headers;
-    (Array.isArray(value) ? value : [value]).forEach(value => {
-        headers.set(name, value);
-    });
-};
-export const appendResponseHeaders = (values) => {
-    const headers = getEvent().res.headers;
-    for (const [name, value] of Object.entries(values)) {
-        headers.append(name, value);
-    }
-};
-export const appendResponseHeader = (name, value) => {
-    const headers = getEvent().res.headers;
-    (Array.isArray(value) ? value : [value]).forEach(value => {
-        headers.append(name, value);
-    });
-};
-export const defaultContentType = (type) => getEvent().res.headers.set("content-type", type);
-export const proxyRequest = createWrapperFunction(h3.proxyRequest);
-export const fetchWithEvent = createWrapperFunction(h3.fetchWithEvent);
-export const getProxyRequestHeaders = createWrapperFunction(h3.getProxyRequestHeaders);
-export const parseCookies = createWrapperFunction(h3.parseCookies);
-export const getCookie = createWrapperFunction(h3.getCookie);
-export const setCookie = createWrapperFunction(h3.setCookie);
-export const deleteCookie = createWrapperFunction(h3.deleteCookie);
-export const useSession = createWrapperFunction(h3.useSession);
-export const getSession = createWrapperFunction(h3.getSession);
-export const updateSession = createWrapperFunction(h3.updateSession);
-export const sealSession = createWrapperFunction(h3.sealSession);
-export const unsealSession = createWrapperFunction(h3.unsealSession);
-export const clearSession = createWrapperFunction(h3.clearSession);
-export const handleCacheHeaders = createWrapperFunction(h3.handleCacheHeaders);
-export const handleCors = createWrapperFunction(h3.handleCors);
-export const appendCorsHeaders = createWrapperFunction(h3.appendCorsHeaders);
-export const appendCorsPreflightHeaders = createWrapperFunction(h3.appendCorsPreflightHeaders);
-export const appendHeader = appendResponseHeader;
-export const appendHeaders = appendResponseHeaders;
-export const setHeader = setResponseHeader;
-export const setHeaders = setResponseHeaders;
-export const getHeader = getRequestHeader;
-export const getHeaders = getRequestHeaders;
-export const getRequestFingerprint = createWrapperFunction(h3.getRequestFingerprint);
-export const getRequestWebStream = () => getEvent().req.body;
-export const readFormData = () => getEvent().req.formData();
-export const readValidatedBody = createWrapperFunction(h3.readValidatedBody);
-export const getContext = createWrapperFunction(_getContext);
-export const setContext = createWrapperFunction(_setContext);
-export const removeResponseHeader = (name) => getEvent().res.headers.delete(name);
-export const clearResponseHeaders = (headerNames) => {
-    const headers = getEvent().res.headers;
-    if (headerNames && headerNames.length > 0) {
-        for (const name of headerNames) {
-            headers.delete(name);
-        }
-    }
-    else {
-        for (const name of headers.keys()) {
-            headers.delete(name);
-        }
-    }
-};

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export { default as clientOnly } from "./shared/clientOnly.ts";
-export { GET } from "./shared/GET.ts";
-export { HttpHeader } from "./shared/HttpHeader.tsx";
-export { HttpStatusCode } from "./shared/HttpStatusCode.ts";
-export { getServerFunctionMeta } from "./shared/serverFunction.ts";

package/dist/index.jsx

@@ -1,6 +0,0 @@
-// @refresh skip
-export { default as clientOnly } from "./shared/clientOnly.js";
-export { GET } from "./shared/GET.js";
-export { HttpHeader } from "./shared/HttpHeader.jsx";
-export { HttpStatusCode } from "./shared/HttpStatusCode.js";
-export { getServerFunctionMeta } from "./shared/serverFunction.js";

package/dist/middleware/index.d.ts

@@ -1,38 +0,0 @@
-import type { Middleware } from "h3";
-import type { FetchEvent } from "../server/types.ts";
-/** Function responsible for receiving an observable [operation]{@link Operation} and returning a [result]{@link OperationResult}. */
-export type MiddlewareFn = (event: FetchEvent) => Promise<unknown> | unknown;
-/** This composes an array of Exchanges into a single ExchangeIO function */
-export type RequestMiddleware = (event: FetchEvent) => Response | Promise<Response> | void | Promise<void> | Promise<void | Response>;
-type EventHandlerResponse<T = any> = T | Promise<T>;
-type ResponseMiddlewareResponseParam = {
-    body?: Awaited<EventHandlerResponse>;
-};
-export type ResponseMiddleware = (event: FetchEvent, response: ResponseMiddlewareResponseParam) => Response | Promise<Response> | void | Promise<void>;
-/**
- * Creates middleware for handling requests and responses.
- *
- * @see https://docs.solidjs.com/solid-start/reference/server/create-middleware
-/**
- * Creates request/response middlewares via H3.
- *
- * Accepts an array of H3 {@link Middleware}
- *
- * @tip To run your middleware before response, `await next()` in your function block.
- *@example
- * const middleware = createMiddleware([
- *   async (event, next) => {
- *     const resp = await next();
- *     if (resp instanceof Response) return resp;
- *     return new Response("Not found", { status: 404 });
- *   },
- * ]);
- *
- */
-export declare function createMiddleware(args: {
-    /** @deprecated Use H3 `Middleware` */
-    onRequest?: RequestMiddleware | RequestMiddleware[] | undefined;
-    /** @deprecated Use H3 `Middleware` */
-    onBeforeResponse?: ResponseMiddleware | ResponseMiddleware[] | undefined;
-} | Middleware[]): Middleware[];
-export {};