doover-js 0.1.0

package/dist/test/doover-data-provider.test.js

@@ -0,0 +1,228 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const chai_as_promised_1 = __importDefault(require("chai-as-promised"));
+const mocha_1 = require("mocha");
+const sinon_1 = __importDefault(require("sinon"));
+const errors_1 = require("../http/errors");
+const doover_data_provider_1 = require("../viewer/doover-data-provider");
+const snowflake_1 = require("../utils/snowflake");
+const helpers_1 = require("./helpers");
+(0, chai_1.use)(chai_as_promised_1.default);
+(0, mocha_1.describe)("DooverDataProvider", () => {
+    (0, mocha_1.beforeEach)(() => {
+        (0, helpers_1.installSessionStorageMock)();
+        helpers_1.MockWebSocket.reset();
+        Object.defineProperty(globalThis, "WebSocket", {
+            value: helpers_1.MockWebSocket,
+            configurable: true,
+            writable: true,
+        });
+    });
+    (0, mocha_1.it)("calls control endpoints for getMe and getAgents", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)((url) => {
+            if (url.endsWith("/users/me")) {
+                return (0, helpers_1.createJsonResponse)({ id: "u1" });
+            }
+            return (0, helpers_1.createJsonResponse)({ agents: [] });
+        });
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        await (0, chai_1.expect)(provider.getMe()).to.eventually.deep.equal({ id: "u1" });
+        await (0, chai_1.expect)(provider.getAgents()).to.eventually.deep.equal({ agents: [] });
+        (0, chai_1.expect)(fetchMock.getCall(0).args[0]).to.equal("https://control.example.com/users/me");
+        (0, chai_1.expect)(fetchMock.getCall(1).args[0]).to.equal("https://control.example.com/agents");
+    });
+    (0, mocha_1.it)("returns undefined for missing identifiers where expected", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)();
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        await (0, chai_1.expect)(provider.getChannels({})).to.eventually.equal(undefined);
+        await (0, chai_1.expect)(provider.getChannel({ agentId: "a1" })).to.eventually.equal(undefined);
+        await (0, chai_1.expect)(provider.getAggregate({ channelName: "c1" })).to.eventually.equal(undefined);
+        await (0, chai_1.expect)(provider.getMessages({})).to.eventually.equal(undefined);
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(0);
+    });
+    (0, mocha_1.it)("creates channels with public and private options", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)({ name: "c1", owner_id: "a1", is_private: false }));
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        await provider.createChannel({ agentId: "a1", channelName: "ignored" }, "c1");
+        await provider.createChannel({ agentId: "a1" }, "c2", { is_private: true });
+        const firstBody = JSON.parse(fetchMock.getCall(0).args[1]?.body);
+        const secondBody = JSON.parse(fetchMock.getCall(1).args[1]?.body);
+        (0, chai_1.expect)(firstBody).to.deep.equal({ is_private: false });
+        (0, chai_1.expect)(secondBody).to.deep.equal({ is_private: true });
+    });
+    (0, mocha_1.it)("fetches messages with the compatibility limit and reverses them", async () => {
+        const oldId = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00.000Z"));
+        const newId = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:10.000Z"));
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)([
+            {
+                id: newId,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: { v: 2 },
+                attachments: [],
+            },
+            {
+                id: oldId,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: { v: 1 },
+                attachments: [],
+            },
+        ]));
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        const messages = await provider.getMessages({ agentId: "a1", channelName: "c1" }, "cursor");
+        (0, chai_1.expect)(messages?.map((message) => message.id)).to.deep.equal([oldId, newId]);
+        (0, chai_1.expect)(fetchMock.getCall(0).args[0]).to.equal("https://api.example.com/agents/a1/channels/c1/messages?before=cursor&limit=10");
+    });
+    (0, mocha_1.it)("prefers channel aggregate data and falls back to the aggregate endpoint", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)((url) => {
+            if (url.endsWith("/channels/c1")) {
+                return (0, helpers_1.createJsonResponse)({ name: "c1", owner_id: "a1", is_private: false, aggregate: { data: { x: 1 }, attachments: [] } });
+            }
+            return (0, helpers_1.createJsonResponse)({ data: { y: 2 }, attachments: [] });
+        });
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        await (0, chai_1.expect)(provider.getAggregate({ agentId: "a1", channelName: "c1" })).to.eventually.deep.equal({ data: { x: 1 }, attachments: [] });
+        const fallbackFetch = (0, helpers_1.createFetchMock)((url) => {
+            if (url.endsWith("/channels/c1")) {
+                return (0, helpers_1.createJsonResponse)({ name: "c1", owner_id: "a1", is_private: false });
+            }
+            return (0, helpers_1.createJsonResponse)({ data: { y: 2 }, attachments: [] });
+        });
+        const fallbackProvider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fallbackFetch,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        await (0, chai_1.expect)(fallbackProvider.getAggregate({ agentId: "a1", channelName: "c1" })).to.eventually.deep.equal({ data: { y: 2 }, attachments: [] });
+    });
+    (0, mocha_1.it)("maps websocket events to subscription callbacks and unsubscribes when the last listener is removed", async () => {
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)({}));
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        const onMessage = sinon_1.default.spy();
+        const onAggregate = sinon_1.default.spy();
+        await provider.subscribeToChannel({ agentId: "a1", channelName: "c1" }, onMessage, onAggregate);
+        const ws = helpers_1.MockWebSocket.instances[0];
+        ws.open();
+        ws.receive({ op: 0, t: "Hello", d: {} });
+        ws.receive({
+            op: 0,
+            t: "Ready",
+            d: { session_id: "s1", session_token: "t1", subscriptions: [] },
+        });
+        const id = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00.000Z"));
+        ws.receive({
+            op: 0,
+            t: "MessageCreate",
+            d: {
+                id,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: {},
+                attachments: [],
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "ChannelSync",
+            d: {
+                channel: { agent_id: "a1", name: "c1" },
+                aggregate: { data: { x: 1 }, attachments: [] },
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "AggregateUpdate",
+            d: {
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                aggregate: { data: { x: 2 }, attachments: [] },
+                request_data: { data: {}, attachments: [] },
+                organisation_id: "org-1",
+            },
+        });
+        (0, chai_1.expect)(onMessage.calledWithMatch({ agentId: "a1", channelName: "c1" }, sinon_1.default.match({ id }))).to.equal(true);
+        (0, chai_1.expect)(onAggregate.callCount).to.equal(2);
+        await provider.unsubscribeFromChannel({ agentId: "a1", channelName: "c1" }, onMessage);
+        (0, chai_1.expect)(JSON.parse(ws.sent[ws.sent.length - 1])).to.deep.include({ op: 13 });
+    });
+    (0, mocha_1.it)("throws validation errors for required channel operations", async () => {
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: (0, helpers_1.createFetchMock)(),
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        (0, chai_1.expect)(() => provider.createChannel({}, "c1")).to.throw(errors_1.DooverValidationError);
+        (0, chai_1.expect)(() => provider.archiveChannel({ agentId: "a1" })).to.throw(errors_1.DooverValidationError);
+        await (0, chai_1.expect)(provider.unsubscribeFromChannel({ agentId: "a1", channelName: "c1" }, sinon_1.default.spy())).to.be.rejectedWith(errors_1.DooverValidationError);
+    });
+    (0, mocha_1.it)("returns the compatibility agent info shim and path parsing result", async () => {
+        const provider = new doover_data_provider_1.DooverDataProvider({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: (0, helpers_1.createFetchMock)(),
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        await (0, chai_1.expect)(provider.getAgentInfo("a1")).to.eventually.deep.equal({
+            id: "a1",
+            name: "a1",
+            display_name: "a1",
+            type: "device",
+            fa_icon: "fa-solid fa-robot",
+            organisation: "Organisation",
+            group: "group",
+            archived: false,
+            fixed_location: { latitude: 0, longitude: 0 },
+            extra_config: {},
+        });
+        (0, chai_1.expect)(provider.getIdentifierFromPath("/a1/c1/path/to/value", new URLSearchParams())).to.deep.equal({
+            identifier: { agentId: "a1", channelName: "c1" },
+            aggregatePath: "path/to/value",
+        });
+    });
+});

package/dist/test/gateway-client.test.d.ts

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

package/dist/test/gateway-client.test.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const mocha_1 = require("mocha");
+const sinon_1 = __importDefault(require("sinon"));
+const gateway_client_1 = require("../gateway/gateway-client");
+const snowflake_1 = require("../utils/snowflake");
+const helpers_1 = require("./helpers");
+(0, mocha_1.describe)("GatewayClient", () => {
+    (0, mocha_1.beforeEach)(() => {
+        helpers_1.MockWebSocket.reset();
+        sinon_1.default.useFakeTimers(new Date("2026-01-01T00:00:00.000Z"));
+        Object.defineProperty(globalThis, "WebSocket", {
+            value: helpers_1.MockWebSocket,
+            configurable: true,
+            writable: true,
+        });
+    });
+    (0, mocha_1.afterEach)(() => {
+        sinon_1.default.restore();
+    });
+    (0, mocha_1.it)("identifies on hello and resumes after a stored session", () => {
+        const client = new gateway_client_1.GatewayClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        client.connect();
+        const ws = helpers_1.MockWebSocket.instances[0];
+        ws.open();
+        ws.receive({ op: 0, t: "Hello", d: {} });
+        (0, chai_1.expect)(JSON.parse(ws.sent[0])).to.deep.include({ op: 10 });
+        ws.receive({
+            op: 0,
+            t: "Ready",
+            d: { session_id: "s1", session_token: "token", subscriptions: [] },
+        });
+        client.disconnect();
+        client.connect();
+        const ws2 = helpers_1.MockWebSocket.instances[1];
+        ws2.open();
+        ws2.receive({ op: 0, t: "Hello", d: {} });
+        const resumePayload = JSON.parse(ws2.sent[0]);
+        (0, chai_1.expect)(resumePayload.op).to.equal(11);
+        (0, chai_1.expect)(resumePayload.d).to.deep.include({
+            session_id: "s1",
+            session_token: "token",
+        });
+    });
+    (0, mocha_1.it)("dispatches websocket events and supports channel operations", () => {
+        const client = new gateway_client_1.GatewayClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            organisationId: "org-1",
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        const channelSync = sinon_1.default.spy();
+        const messageCreate = sinon_1.default.spy();
+        const messageUpdate = sinon_1.default.spy();
+        const aggregateUpdate = sinon_1.default.spy();
+        const alarmTrigger = sinon_1.default.spy();
+        const oneShot = sinon_1.default.spy();
+        const subscribed = sinon_1.default.spy();
+        const unsubscribed = sinon_1.default.spy();
+        const wssError = sinon_1.default.spy();
+        client.on("channelSync", channelSync);
+        client.on("messageCreate", messageCreate);
+        client.on("messageUpdate", messageUpdate);
+        client.on("aggregateUpdate", aggregateUpdate);
+        client.on("alarmTrigger", alarmTrigger);
+        client.on("oneShotMessage", oneShot);
+        client.on("channelSubscription", subscribed);
+        client.on("channelUnsubscription", unsubscribed);
+        client.on("wssError", wssError);
+        client.connect();
+        const ws = helpers_1.MockWebSocket.instances[0];
+        ws.open();
+        ws.receive({ op: 0, t: "Hello", d: {} });
+        ws.receive({
+            op: 0,
+            t: "Ready",
+            d: { session_id: "s1", session_token: "token", subscriptions: [] },
+        });
+        client.subscribe({ agent_id: "a1", name: "c1" });
+        client.syncChannel({ agent_id: "a1", name: "c1" });
+        client.sendOneShotMessage({ agent_id: "a1", name: "c1" }, { hello: "world" });
+        client.unsubscribe({ agent_id: "a1", name: "c1" });
+        (0, chai_1.expect)(ws.sent.map((message) => JSON.parse(message).op)).to.deep.equal([10, 12, 14, 15, 13]);
+        const id = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00.000Z"));
+        ws.receive({
+            op: 0,
+            t: "ChannelSync",
+            d: {
+                channel: { agent_id: "a1", name: "c1" },
+                aggregate: { data: {}, attachments: [] },
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "MessageCreate",
+            d: {
+                id,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: {},
+                attachments: [],
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "MessageUpdate",
+            d: {
+                id,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: {},
+                attachments: [],
+                request_data: {},
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "AggregateUpdate",
+            d: {
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                aggregate: { data: {}, attachments: [] },
+                request_data: { data: {}, attachments: [] },
+                organisation_id: "org-1",
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "AlarmTrigger",
+            d: {
+                channel: { agent_id: "a1", name: "c1" },
+                alarm: {
+                    id: "al1",
+                    name: "alarm",
+                    description: "",
+                    enabled: true,
+                    key: "temp",
+                    operator: "gt",
+                    value: 1,
+                    state: "Alarm",
+                    expiry_mins: null,
+                    entered_state_ts: 1,
+                },
+                old_state: "OK",
+                new_state: "Alarm",
+                aggregate: { data: {}, attachments: [] },
+                request_data: { data: {}, attachments: [] },
+                organisation_id: "org-1",
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "OneShotMessage",
+            d: {
+                id: null,
+                author_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                data: { hello: "world" },
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "ChannelSubscription",
+            d: {
+                agent_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                session_id: "s2",
+                default_session: true,
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "ChannelUnsubscription",
+            d: {
+                agent_id: "u1",
+                channel: { agent_id: "a1", name: "c1" },
+                session_id: "s2",
+                default_session: true,
+            },
+        });
+        ws.receive({
+            op: 0,
+            t: "WSSErrorEvent",
+            d: { message: "boom" },
+        });
+        (0, chai_1.expect)(channelSync.calledOnce).to.equal(true);
+        (0, chai_1.expect)(messageCreate.calledWithMatch(sinon_1.default.match({ id, timestamp: sinon_1.default.match.number }))).to.equal(true);
+        (0, chai_1.expect)(messageUpdate.calledWithMatch(sinon_1.default.match({ id, timestamp: sinon_1.default.match.number }))).to.equal(true);
+        (0, chai_1.expect)(aggregateUpdate.calledOnce).to.equal(true);
+        (0, chai_1.expect)(alarmTrigger.calledOnce).to.equal(true);
+        (0, chai_1.expect)(oneShot.calledOnce).to.equal(true);
+        (0, chai_1.expect)(subscribed.calledOnce).to.equal(true);
+        (0, chai_1.expect)(unsubscribed.calledOnce).to.equal(true);
+        (0, chai_1.expect)(wssError.calledWith({ message: "boom" })).to.equal(true);
+    });
+    (0, mocha_1.it)("sends heartbeats, measures latency, and handles session cancellation", () => {
+        const client = new gateway_client_1.GatewayClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            webSocketImpl: helpers_1.MockWebSocket,
+        });
+        const ack = sinon_1.default.spy();
+        const cancelled = sinon_1.default.spy();
+        client.on("heartbeatAck", ack);
+        client.on("sessionCancelled", cancelled);
+        client.connect();
+        const ws = helpers_1.MockWebSocket.instances[0];
+        ws.open();
+        ws.receive({ op: 0, t: "Hello", d: {} });
+        ws.receive({
+            op: 0,
+            t: "Ready",
+            d: { session_id: "s1", session_token: "token", subscriptions: [] },
+        });
+        sinon_1.default.clock.tick(20000);
+        (0, chai_1.expect)(JSON.parse(ws.sent[ws.sent.length - 1])).to.deep.equal({ op: 1, d: {} });
+        sinon_1.default.clock.tick(10);
+        ws.receive({ op: 2, d: {} });
+        (0, chai_1.expect)(ack.calledWith(10)).to.equal(true);
+        ws.receive({ op: 3, d: {} });
+        (0, chai_1.expect)(cancelled.calledOnce).to.equal(true);
+        (0, chai_1.expect)(client.getSession()).to.equal(null);
+    });
+});

package/dist/test/helpers.d.ts

@@ -0,0 +1,32 @@
+import sinon from "sinon";
+export declare function createJsonResponse(body: unknown, init?: ResponseInit): Response;
+export declare function createTextResponse(body: string, init?: ResponseInit): Response;
+export declare function createBlobResponse(body: string, init?: ResponseInit): Response;
+export declare function createFetchMock(responseFactory?: (url: string, init?: RequestInit) => Response | Promise<Response>): sinon.SinonStub<any[], any>;
+export declare function installSessionStorageMock(): void;
+type MessageHandler = ((event: MessageEvent<string>) => void) | null;
+type CloseHandler = ((event: CloseEvent) => void) | null;
+type OpenHandler = (() => void) | null;
+type ErrorHandler = ((event: Event) => void) | null;
+export declare class MockWebSocket {
+    static instances: MockWebSocket[];
+    static CONNECTING: number;
+    static OPEN: number;
+    static CLOSING: number;
+    static CLOSED: number;
+    readonly url: string;
+    readyState: number;
+    sent: string[];
+    onmessage: MessageHandler;
+    onclose: CloseHandler;
+    onopen: OpenHandler;
+    onerror: ErrorHandler;
+    constructor(url: string);
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    open(): void;
+    receive(payload: unknown): void;
+    error(): void;
+    static reset(): void;
+}
+export {};

package/dist/test/helpers.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWebSocket = void 0;
+exports.createJsonResponse = createJsonResponse;
+exports.createTextResponse = createTextResponse;
+exports.createBlobResponse = createBlobResponse;
+exports.createFetchMock = createFetchMock;
+exports.installSessionStorageMock = installSessionStorageMock;
+const sinon_1 = __importDefault(require("sinon"));
+function createJsonResponse(body, init) {
+    return new Response(JSON.stringify(body), {
+        status: init?.status ?? 200,
+        headers: {
+            "content-type": "application/json",
+            ...(init?.headers ?? {}),
+        },
+    });
+}
+function createTextResponse(body, init) {
+    return new Response(body, {
+        status: init?.status ?? 200,
+        headers: init?.headers,
+    });
+}
+function createBlobResponse(body, init) {
+    return new Response(new Blob([body]), {
+        status: init?.status ?? 200,
+        headers: {
+            "content-type": "application/octet-stream",
+            ...(init?.headers ?? {}),
+        },
+    });
+}
+function createFetchMock(responseFactory) {
+    return sinon_1.default.stub().callsFake(async (input, init) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        if (responseFactory) {
+            return responseFactory(url, init);
+        }
+        return createJsonResponse({ ok: true });
+    });
+}
+class StorageMock {
+    constructor() {
+        this.store = new Map();
+    }
+    get length() {
+        return this.store.size;
+    }
+    clear() {
+        this.store.clear();
+    }
+    getItem(key) {
+        return this.store.get(key) ?? null;
+    }
+    key(index) {
+        return Array.from(this.store.keys())[index] ?? null;
+    }
+    removeItem(key) {
+        this.store.delete(key);
+    }
+    setItem(key, value) {
+        this.store.set(key, value);
+    }
+}
+function installSessionStorageMock() {
+    Object.defineProperty(globalThis, "sessionStorage", {
+        value: new StorageMock(),
+        configurable: true,
+        writable: true,
+    });
+}
+class MockWebSocket {
+    constructor(url) {
+        this.readyState = MockWebSocket.CONNECTING;
+        this.sent = [];
+        this.onmessage = null;
+        this.onclose = null;
+        this.onopen = null;
+        this.onerror = null;
+        this.url = url;
+        MockWebSocket.instances.push(this);
+    }
+    send(data) {
+        this.sent.push(data);
+    }
+    close(code, reason) {
+        this.readyState = MockWebSocket.CLOSED;
+        this.onclose?.({ code: code ?? 1000, reason: reason ?? "" });
+    }
+    open() {
+        this.readyState = MockWebSocket.OPEN;
+        this.onopen?.();
+    }
+    receive(payload) {
+        this.onmessage?.(new MessageEvent("message", {
+            data: JSON.stringify(payload),
+        }));
+    }
+    error() {
+        this.onerror?.(new Event("error"));
+    }
+    static reset() {
+        MockWebSocket.instances = [];
+    }
+}
+exports.MockWebSocket = MockWebSocket;
+MockWebSocket.instances = [];
+MockWebSocket.CONNECTING = 0;
+MockWebSocket.OPEN = 1;
+MockWebSocket.CLOSING = 2;
+MockWebSocket.CLOSED = 3;

package/dist/test/rest-client.test.d.ts

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