@crossauth/sveltekit 1.0.1 → 1.1.1

package/dist/tests/sveltekituserclientendpoints.test.js

@@ -0,0 +1,244 @@
+// Copyright (c) 2026 Matthew Baker.  All rights reserved.  Licenced under the Apache Licence 2.0.  See LICENSE file
+import { MockRequestEvent } from './sveltemocks';
+import { test, expect } from 'vitest';
+import { makeServer, getCsrfToken, login } from './testshared';
+export var passwordResetData;
+test('SvelteKitUserClientEndpoints.selectClients', async () => {
+    const { server, resolver, handle, } = await makeServer();
+    // log in
+    let resp = await login(server, resolver, handle);
+    let loginEvent = resp.event;
+    loginEvent = resp.event;
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    let sessionCookieValue = loginEvent.cookies.get("SESSIONID");
+    let sessionId = server.sessionServer?.sessionManager.getSessionId(sessionCookieValue ?? "");
+    // select clients
+    let getRequest = new Request("http://ex.com/oauth/clients", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken,
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    let event = new MockRequestEvent("1", getRequest, { id: "bob" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    let resp1 = await server.sessionServer?.userClientEndpoints.searchClients(event);
+    expect(resp1?.ok).toBe(true);
+    expect(resp1?.clients?.length).toBe(1);
+});
+test('SvelteKitUserClientEndpoints.updateClient', async () => {
+    const { server, resolver, handle } = await makeServer();
+    // log in
+    let resp = await login(server, resolver, handle);
+    let loginEvent = resp.event;
+    loginEvent = resp.event;
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    let sessionCookieValue = loginEvent.cookies.get("SESSIONID");
+    let sessionId = server.sessionServer?.sessionManager.getSessionId(sessionCookieValue ?? "");
+    let getRequest = new Request("http://ex.com/oauth/clients", {
+        method: "GET",
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    let event = new MockRequestEvent("1", getRequest, { client_id: "ABC" });
+    event.locals.csrfToken = csrfToken;
+    let status = 200;
+    let resp1 = {};
+    try {
+        resp1 = await server.sessionServer?.userClientEndpoints.updateClientEndpoint.load(event);
+    }
+    catch (e) {
+        if (e && typeof (e) == "object" && "status" in e && typeof (e.status) == "number")
+            status = e.status;
+    }
+    expect(status).toBe(302);
+    event = new MockRequestEvent("1", getRequest, { client_id: "ABC" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    status = 200;
+    try {
+        resp1 = await server.sessionServer?.userClientEndpoints.updateClientEndpoint.load(event);
+    }
+    catch (e) {
+        if (e && typeof (e) == "object" && "status" in e && typeof (e.status) == "number")
+            status = e.status;
+    }
+    expect(status).toBe(401);
+    event = new MockRequestEvent("1", getRequest, { client_id: "bob_ABC" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    resp1 = await server.sessionServer?.userClientEndpoints.updateClientEndpoint.load(event);
+    expect(resp1?.ok).toBe(true);
+    let postRequest = new Request("http://ex.com/oauth/clients", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&client_name=newName&confidential=on&redirect_uri=http://uri1.com/redirect&authorizationCode=on",
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    event = new MockRequestEvent("1", postRequest, { client_id: "bob_ABC" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    resp1 = await server.sessionServer?.userClientEndpoints.updateClientEndpoint.actions.default(event);
+    expect(resp1?.ok).toBe(true);
+    expect(resp1?.client?.client_name).toBe("newName");
+    expect(resp1?.plaintextSecret).toBeUndefined();
+    expect(resp1?.client?.client_secret).toContain("pbkdf2:sha256");
+    postRequest = new Request("http://ex.com/oauth/clients", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&client_name=newName&confidential=on&redirect_uri=http://uri1.com/redirect&authorizationCode=on&resetSecret=on",
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    event = new MockRequestEvent("1", postRequest, { client_id: "bob_ABC" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    resp1 = await server.sessionServer?.userClientEndpoints.updateClientEndpoint.actions.default(event);
+    expect(resp1?.ok).toBe(true);
+    expect(resp1?.plaintextSecret).toBeDefined();
+    expect(resp1?.client?.client_secret).not.toContain("pbkdf2:sha256");
+});
+test('SvelteKitUserClientEndpoints.deleteClient', async () => {
+    const { server, resolver, handle } = await makeServer();
+    // log in
+    let resp = await login(server, resolver, handle);
+    let loginEvent = resp.event;
+    loginEvent = resp.event;
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    let sessionCookieValue = loginEvent.cookies.get("SESSIONID");
+    let sessionId = server.sessionServer?.sessionManager.getSessionId(sessionCookieValue ?? "");
+    let getRequest = new Request("http://ex.com/oauth/clients", {
+        method: "GET",
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    let event = new MockRequestEvent("1", getRequest, { client_id: "ABC" });
+    event.locals.csrfToken = csrfToken;
+    let status = 200;
+    let resp1 = {};
+    try {
+        resp1 = await server.sessionServer?.userClientEndpoints.deleteClientEndpoint.load(event);
+    }
+    catch (e) {
+        if (e && typeof (e) == "object" && "status" in e && typeof (e.status) == "number")
+            status = e.status;
+    }
+    expect(status).toBe(302);
+    event = new MockRequestEvent("1", getRequest, { client_id: "ABC" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    status = 200;
+    try {
+        resp1 = await server.sessionServer?.userClientEndpoints.deleteClientEndpoint.load(event);
+    }
+    catch (e) {
+        if (e && typeof (e) == "object" && "status" in e && typeof (e.status) == "number")
+            status = e.status;
+    }
+    expect(status).toBe(401);
+    event = new MockRequestEvent("1", getRequest, { client_id: "bob_ABC" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    resp1 = await server.sessionServer?.userClientEndpoints.deleteClientEndpoint.load(event);
+    expect(resp1?.ok).toBe(true);
+    let postRequest = new Request("http://ex.com/oauth/clients", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken,
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    event = new MockRequestEvent("1", postRequest, { client_id: "bob_ABC" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    resp1 = await server.sessionServer?.userClientEndpoints.deleteClientEndpoint.actions.default(event);
+    expect(resp1?.ok).toBe(true);
+});
+test('SvelteKitUserClientEndpoints.createClient', async () => {
+    const { server, resolver, handle } = await makeServer();
+    // log in
+    let resp = await login(server, resolver, handle);
+    let loginEvent = resp.event;
+    loginEvent = resp.event;
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    let sessionCookieValue = loginEvent.cookies.get("SESSIONID");
+    let sessionId = server.sessionServer?.sessionManager.getSessionId(sessionCookieValue ?? "");
+    let getRequest = new Request("http://ex.com/oauth/clients", {
+        method: "GET",
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    let event = new MockRequestEvent("1", getRequest, {});
+    event.locals.csrfToken = csrfToken;
+    let status = 302;
+    let resp1 = {};
+    try {
+        resp1 = await server.sessionServer?.userClientEndpoints.createClientEndpoint.load(event);
+    }
+    catch (e) {
+        if (e && typeof (e) == "object" && "status" in e && typeof (e.status) == "number")
+            status = e.status;
+    }
+    expect(status).toBe(302);
+    event = new MockRequestEvent("1", getRequest, {});
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    resp1 = await server.sessionServer?.userClientEndpoints.createClientEndpoint.load(event);
+    expect(resp1?.ok).toBe(true);
+    let postRequest = new Request("http://ex.com/oauth/clients", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&client_name=newName&confidential=on&redirect_uri=http://uri1.com/redirect&authorizationCode=on",
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    event = new MockRequestEvent("1", postRequest, { client_id: "bob_ABC" });
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    resp1 = await server.sessionServer?.userClientEndpoints.createClientEndpoint.actions.default(event);
+    expect(resp1?.ok).toBe(true);
+    expect(resp1?.client?.client_name).toBe("newName");
+    expect(resp1?.plaintextSecret).toBeUndefined();
+    expect(resp1?.client?.client_secret).not.toContain("pbkdf2:sha256");
+});

package/dist/tests/sveltekituserendpoints.test.js

@@ -0,0 +1,152 @@
+// Copyright (c) 2026 Matthew Baker.  All rights reserved.  Licenced under the Apache Licence 2.0.  See LICENSE file
+import { MockRequestEvent } from './sveltemocks';
+import { test, expect } from 'vitest';
+import { makeServer, getCsrfToken, login } from './testshared';
+export var passwordResetData;
+test('SvelteKitUserEndpoints.login', async () => {
+    const { server, resolver, handle } = await makeServer();
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    const postRequest = new Request("http://ex.com/test", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&username=bob&password=bobPass123",
+        headers: {
+            "cookie": "CSRFTOKEN=" + csrfCookieValue,
+            "content-type": "application/x-www-form-urlencoded",
+        }
+    });
+    let event = new MockRequestEvent("1", postRequest, { "param1": "value1" });
+    event.locals.csrfToken = csrfToken;
+    const ret = await server.sessionServer?.userEndpoints.login(event);
+    expect(ret?.user?.username).toBe("bob");
+    expect(event.cookies.get("SESSIONID")).toBeDefined();
+});
+test('SvelteKitUserEndpoints.logout', async () => {
+    const { server, resolver, handle } = await makeServer();
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    let postRequest = new Request("http://ex.com/test", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&username=bob&password=bobPass123",
+        headers: {
+            "cookie": "CSRFTOKEN=" + csrfCookieValue,
+            "content-type": "application/x-www-form-urlencoded",
+        }
+    });
+    let event = new MockRequestEvent("1", postRequest, { "param1": "value1" });
+    event.locals.csrfToken = csrfToken;
+    let ret = await server.sessionServer?.userEndpoints.login(event);
+    expect(ret?.user?.username).toBe("bob");
+    expect(event.cookies.get("SESSIONID")).toBeDefined();
+    postRequest = new Request("http://ex.com/test", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&username=bob&password=bobPass123",
+        headers: {
+            "cookie": "CSRFTOKEN=" + csrfCookieValue,
+            "content-type": "application/x-www-form-urlencoded",
+        }
+    });
+    event = new MockRequestEvent("1", postRequest, { "param1": "value1" });
+    event.locals.csrfToken = csrfToken;
+    ret = await server.sessionServer?.userEndpoints.logout(event);
+    expect(ret?.user).toBeUndefined();
+    expect(event.cookies.get("SESSIONID")).toBeUndefined();
+});
+test('SvelteKitUserEndpoints.resetPassword', async () => {
+    const { server, resolver, handle } = await makeServer();
+    // log in
+    await login(server, resolver, handle, "alice", "alicePass123");
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    // @ts-ignore
+    server["sessionServer"]["sessionManager"]["tokenEmailer"]["_sendPasswordResetToken"] = async function (token, email, extraData) {
+        passwordResetData = { token, extraData };
+    };
+    // request password reset
+    let postRequest = new Request("http://ex.com/passwordreset", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&email=bob@bob.com",
+        headers: {
+            "cookie": "CSRFTOKEN=" + csrfCookieValue,
+            "content-type": "application/x-www-form-urlencoded",
+        }
+    });
+    let event = new MockRequestEvent("1", postRequest, {});
+    event.locals.csrfToken = csrfToken;
+    event.cookies.set("CSRFTOKEN", csrfCookieValue, { path: "/" });
+    let resp1 = await server.sessionServer?.userEndpoints.requestPasswordReset(event);
+    expect(resp1?.ok).toBe(true);
+    const token = passwordResetData.token;
+    // submit password reset
+    postRequest = new Request("http://ex.com/passwordreset/" + token, {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&new_password='ABCabc123'&repeat_password='ABCabc123'",
+        headers: {
+            "cookie": "CSRFTOKEN=" + csrfCookieValue,
+            "content-type": "application/x-www-form-urlencoded",
+        }
+    });
+    event = new MockRequestEvent("1", postRequest, { token: token });
+    event.locals.csrfToken = csrfToken;
+    event.cookies.set("CSRFTOKEN", csrfCookieValue, { path: "/" });
+    resp1 = await server.sessionServer?.userEndpoints.resetPassword(event);
+    expect(resp1?.ok).toBe(true);
+});
+test('SvelteKitUserEndpoints.changePassword', async () => {
+    const { server, resolver, handle } = await makeServer();
+    // log in
+    let resp = await login(server, resolver, handle, "bob", "bobPass123");
+    let loginEvent = resp.event;
+    loginEvent = resp.event;
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    let sessionCookieValue = loginEvent.cookies.get("SESSIONID");
+    let sessionId = server.sessionServer?.sessionManager.getSessionId(sessionCookieValue ?? "");
+    // change password
+    let postRequest = new Request("http://ex.com/changepassword", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken + "&old_password=bobPass123&new_password=bobPass12&repeat_password=bobPass12",
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    let event = new MockRequestEvent("1", postRequest, {});
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    let resp1 = await server.sessionServer?.userEndpoints.changePassword(event);
+    expect(resp1?.ok).toBe(true);
+});
+test('SvelteKitUserEndpoints.deleteUser', async () => {
+    const { server, resolver, handle, userStorage } = await makeServer();
+    // log in
+    let resp = await login(server, resolver, handle, "bob", "bobPass123");
+    let loginEvent = resp.event;
+    loginEvent = resp.event;
+    const { csrfToken, csrfCookieValue } = await getCsrfToken(server, resolver, handle);
+    let sessionCookieValue = loginEvent.cookies.get("SESSIONID");
+    let sessionId = server.sessionServer?.sessionManager.getSessionId(sessionCookieValue ?? "");
+    // delete user
+    let postRequest = new Request("http://ex.com/deleteuser", {
+        method: "POST",
+        body: "csrfToken=" + csrfToken,
+        headers: [
+            ["cookie", "CSRFTOKEN=" + csrfCookieValue],
+            ["cookie", "SESSIONID=" + sessionCookieValue],
+            ["content-type", "application/x-www-form-urlencoded"],
+        ]
+    });
+    let event = new MockRequestEvent("1", postRequest, {});
+    event.locals.csrfToken = csrfToken;
+    event.locals.sessionId = sessionId;
+    event.locals.authType = "cookie";
+    event.locals.user = loginEvent.locals.user;
+    let resp1 = await server.sessionServer?.userEndpoints.deleteUser(event);
+    expect(resp1?.ok).toBe(true);
+    let found = false;
+    try {
+        await userStorage.getUserByUsername("bob");
+        found = true;
+    }
+    catch (e) { }
+    expect(found).toBe(false);
+});

package/dist/tests/sveltemock.test.js

@@ -0,0 +1,36 @@
+// Copyright (c) 2026 Matthew Baker.  All rights reserved.  Licenced under the Apache Licence 2.0.  See LICENSE file
+import { MockRequestEvent, MockCookies } from './sveltemocks';
+import { test, expect } from 'vitest';
+test('SvelteMocks.Request', async () => {
+    const request = new Request("http://ex.com/test", { method: "POST", body: "This is the body" });
+    expect(request.body).not.toBe(null);
+    if (request.body)
+        expect(await (new Response(request.body).text())).toBe("This is the body");
+});
+test('SvelteMocks.MockRequestEvent', async () => {
+    const request = new Request("http://ex.com/test", { method: "POST", body: "This is the body" });
+    const requestEvent = new MockRequestEvent("1", request, { "param1": "value1" });
+    expect(requestEvent.route.id).toBe("1");
+    expect(requestEvent.params["param1"]).toBe("value1");
+});
+test('SvelteMocks.MockCookies', async () => {
+    const cookies = new MockCookies({
+        "cookie1": { value: "value1", opts: { maxAge: 120, domain: "http://example1.com" } },
+        "cookie2": { value: "value&2", opts: { maxAge: 140, domain: "http://example2.com" } },
+    });
+    // get cookie
+    let value1 = await cookies.get("cookie1");
+    expect(value1).toBe("value1");
+    let value2 = await cookies.get("cookie2");
+    expect(value2).toBe("value&2");
+    // get all
+    let values = await cookies.getAll();
+    expect(values.length).toBe(2);
+    // set cookie
+    await cookies.set("cookie1", "value3", { maxAge: 120, domain: "http://example3.com", path: "/" });
+    value1 = await cookies.get("cookie1");
+    expect(value1).toBe("value3");
+    await cookies.delete("cookie1", { path: "/" });
+    value1 = await cookies.get("cookie1");
+    expect(value1).toBe(undefined);
+});

package/dist/tests/sveltemocks.d.ts

@@ -1,6 +1,16 @@
-import { Cookies, RequestEvent, MaybePromise, ResolveOptions } from '@sveltejs/kit';
-import { CookieParseOptions, CookieSerializeOptions } from 'cookie';
-
+import { type Cookies, type ResolveOptions } from '@sveltejs/kit';
+import { type CookieParseOptions, type CookieSerializeOptions } from 'cookie';
+export interface AppTypes {
+    RouteId(): string;
+    RouteParams(): Record<string, Record<string, string>>;
+    LayoutParams(): Record<string, Record<string, string>>;
+    Pathname(): string;
+    ResolvedPathname(): string;
+    Asset(): string;
+}
+declare type RouteId1 = string;
+export type LayoutParams<T extends RouteId1> = T extends keyof ReturnType<AppTypes['LayoutParams']> ? ReturnType<AppTypes['LayoutParams']>[T] : Record<string, never>;
+export type MaybePromise<T> = T | Promise<T>;
 export declare class MockCookies implements Cookies {
     cookies: {
         [key: string]: {
@@ -29,9 +39,7 @@ export declare class MockCookies implements Cookies {
         path: string;
     }): string;
 }
-export declare class MockRequestEvent<Params extends Partial<Record<string, string>> = {
-    [key: string]: string;
-}, RouteId extends string | null = string> implements RequestEvent<Params, RouteId> {
+export declare class MockRequestEvent<Params extends LayoutParams<'/'> = LayoutParams<'/'>, RouteId extends RouteId1 | null = RouteId1 | null> {
     constructor(id: RouteId, request: Request, params: Params, { isDataRequest, isSubRequest, cookies, baseUrl }?: {
         isDataRequest?: boolean;
         isSubRequest?: boolean;
@@ -53,20 +61,26 @@ export declare class MockRequestEvent<Params extends Partial<Record<string, stri
     route: {
         id: RouteId;
     };
-    headers: {
+    headers?: {
         [key: string]: string;
     } | undefined;
     setHeaders(headers: Record<string, string>): void;
     url: URL;
     isDataRequest: boolean;
     isSubRequest: boolean;
+    tracing: {
+        enabled: boolean;
+        root: any;
+        current: any;
+    };
+    isRemoteRequest: boolean;
 }
 export interface MockResolveOptions extends ResolveOptions {
     body?: string;
     status?: number;
     statusText?: string;
 }
-type MockResolve = (event: MockRequestEvent, _opts?: ResolveOptions) => MaybePromise<Response>;
+type MockResolve = (event: MockRequestEvent<Record<string, string>, string | null>, _opts?: ResolveOptions | undefined) => MaybePromise<Response>;
 export declare class MockResolver {
     body: string | undefined;
     status: number;

package/dist/tests/sveltemocks.js

@@ -0,0 +1,114 @@
+// Copyright (c) 2026 Matthew Baker.  All rights reserved.  Licenced under the Apache Licence 2.0.  See LICENSE file
+import {} from '@sveltejs/kit';
+import cookie, {} from 'cookie';
+export class MockCookies {
+    cookies;
+    constructor(cookies, req) {
+        this.cookies = cookies;
+        if (req) {
+            const reqCookiesString = req.headers.get("cookie");
+            if (reqCookiesString) {
+                const reqCookies = reqCookiesString.split(";");
+                for (let reqCookie of reqCookies) {
+                    const pair = reqCookie.trim().split("=", 2);
+                    if (pair.length == 2) {
+                        const name = decodeURIComponent(pair[0]);
+                        const value = decodeURIComponent(pair[1]);
+                        this.cookies[name] = { value: value };
+                    }
+                }
+            }
+        }
+    }
+    get(name, opts) {
+        // opts is ignored on the assumption 
+        const decoder = opts?.decode ?? "decodeURIComponent";
+        if (name in this.cookies)
+            return eval(decoder + "('" + this.cookies[name].value + "')");
+        return undefined;
+    }
+    getAll(opts) {
+        const decoder = opts?.decode ?? "decodeURIComponent";
+        let ret = [];
+        for (let name in this.cookies)
+            ret.push({ name: name, value: eval(decoder + "('" + this.cookies[name].value + "')") });
+        return ret;
+    }
+    set(name, value, opts) {
+        this.cookies[name] = { value, opts };
+    }
+    delete(name, _opts) {
+        if (name in this.cookies)
+            delete this.cookies[name];
+    }
+    serialize(name, value, opts) {
+        return cookie.serialize(name, value, opts);
+    }
+}
+export class MockRequestEvent {
+    constructor(id, request, params, { isDataRequest = false, isSubRequest = false, cookies = {}, baseUrl = "http://example.com" } = {}) {
+        this.cookies = new MockCookies(cookies, request);
+        this.fetch = fetch;
+        this.locals = { authType: undefined };
+        this.params = params;
+        this.request = request;
+        try {
+            this.url = new URL(request.url);
+        }
+        catch (e) {
+            this.url = new URL(request.url, baseUrl);
+        }
+        this.isDataRequest = isDataRequest;
+        this.isSubRequest = isSubRequest;
+        this.route = { id: id };
+        this.tracing = { enabled: false, root: "", current: "" };
+        this.isRemoteRequest = false;
+    }
+    cookies;
+    fetch;
+    getClientAddress() {
+        throw new Error('Method not implemented.');
+    }
+    locals;
+    params;
+    platform;
+    request;
+    route;
+    headers = undefined;
+    setHeaders(headers) {
+        this.headers = headers;
+    }
+    url;
+    isDataRequest;
+    isSubRequest;
+    tracing;
+    isRemoteRequest;
+}
+export class MockResolver {
+    body;
+    status;
+    statusText;
+    constructor(body, status = 200, statusText = "OK") {
+        this.body = body;
+        this.status = status;
+        this.statusText = statusText;
+        this.mockResolve = (event, _opts) => {
+            let headers = [];
+            for (let header in event.headers) {
+                headers.push([header, event.headers[header]]);
+            }
+            let cookies = event.cookies.getAll();
+            if (cookies && cookies.length > 0) {
+                for (let cookie of cookies) {
+                    headers.push(["set-cookie", cookie.name + "=" + cookie.value]);
+                }
+            }
+            return new Response(this.body, {
+                headers: headers,
+                status: this.status ?? 200,
+                statusText: this.statusText ?? "OK",
+            });
+        };
+    }
+    mockResolve;
+}