vitest-websocket-mock 0.6.0 → 0.8.0

package/README.md

@@ -1,11 +1,15 @@
-# Vitest websocket mock
+# vitest-websocket-mock
 
 [![npm version](https://badge.fury.io/js/vitest-websocket-mock.svg)](https://badge.fury.io/js/vitest-websocket-mock)
 [![Build Status](https://github.com/akiomik/vitest-websocket-mock/actions/workflows/ci.yml/badge.svg)](https://github.com/akiomik/vitest-websocket-mock/actions)
 [![codecov](https://codecov.io/gh/akiomik/vitest-websocket-mock/branch/main/graph/badge.svg?token=40OVYIT90L)](https://codecov.io/gh/akiomik/vitest-websocket-mock)
 
-A set of utilities and Vitest matchers to help testing complex websocket interactions.
-A patched fork of [romgain/jest-websocket-mock](https://github.com/romgain/jest-websocket-mock).
+A set of utilities and Vitest matchers to help testing complex websocket interactions:
+mock websocket servers, wait for connections and messages, and assert on them
+with dedicated matchers.
+
+Originally forked from [romgain/jest-websocket-mock](https://github.com/romgain/jest-websocket-mock),
+and since developed independently as a Vitest-first library.
 
 **Examples:**
 Several examples are provided in the [examples folder](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/).
@@ -15,8 +19,31 @@ In particular:
 - [testing a component using the saga above](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/redux-saga/src/__tests__/App.test.tsx)
 - [testing a component that manages a websocket connection using react hooks](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/hooks/src/App.test.tsx)
 
+## When to use this vs. MSW
+
+[Vitest recommends](https://vitest.dev/guide/mocking/requests) [Mock Service Worker (MSW)](https://mswjs.io)
+for mocking network requests, and MSW has first-class
+[WebSocket support](https://mswjs.io/docs/websocket/). The two address different
+layers of the problem:
+
+- **MSW** provides declarative, network-level mocking (`ws.link()` handlers).
+  It shines when you want to share handlers between your app, Storybook, and
+  tests, or when you also need to mock HTTP or GraphQL.
+- **`vitest-websocket-mock`** provides imperative test-flow ergonomics that MSW
+  does not: a `WS` mock-server object, `await server.connected`, a synchronous
+  record of received messages in `server.messages`, and custom matchers such as
+  `.toReceiveMessage` and `.toHaveReceivedMessages`.
+
+If your test reads best as a step-by-step conversation with a mock server
+("wait for the connection, assert on the next message, reply, assert again"),
+this library is the better fit. Running this library on top of MSW's
+interceptor, which would make the two complementary rather than alternatives,
+is being explored in [#77](https://github.com/akiomik/vitest-websocket-mock/issues/77).
+
 ## Install
 
+`vitest-websocket-mock` requires Vitest 5 as a peer dependency.
+
 ```bash
 npm install -D vitest-websocket-mock
 ```
@@ -65,7 +92,7 @@ const server = new WS('ws://localhost:1234', { jsonProtocol: true });
 server.send({ type: 'GREETING', payload: 'hello' });
 ```
 
-- The `mock-server` options `verifyClient` and `selectProtocol` are directly passed-through to the mock-server's constructor.
+- The [`mock-socket`](https://github.com/thoov/mock-socket) server options `verifyClient` and `selectProtocol` are directly passed through to the underlying mock server's constructor.
 
 ### Attributes of a `WS` instance
 
@@ -80,6 +107,11 @@ A `WS` instance has the following attributes:
   new message. The resolved value is the received message (deserialized as a
   JavaScript Object if the `WS` was instantiated with the `{ jsonProtocol: true }`
   option).
+- `messages`: an array that synchronously and cumulatively records every
+  message received by the `WS` instance, in the order they were received.
+  Since it's updated synchronously, it can be used to assert that no message
+  has been received without waiting on a timeout (see
+  [Run assertions on received messages](#run-assertions-on-received-messages)).
 
 ### Methods on a `WS` instance
 
@@ -93,8 +125,9 @@ A `WS` instance has the following attributes:
 
 ## Run assertions on received messages
 
-`vitest-websocket-mock` registers custom vitest matchers to make assertions
-on received messages easier:
+`vitest-websocket-mock` registers custom Vitest matchers to make assertions
+on received messages easier. They are registered automatically when
+`vitest-websocket-mock` is imported, so no extra setup file is needed:
 
 - `.toReceiveMessage`: async matcher that waits for the next message received
   by the mock websocket server, and asserts its content. It will time out
@@ -102,6 +135,12 @@ on received messages easier:
 - `.toHaveReceivedMessages`: synchronous matcher that checks that all the
   expected messages have been received by the mock websocket server.
 
+**Note**: `.toHaveReceivedMessages([])` always passes, since it only checks
+that every expected message is included in the received messages, and an
+empty list of expected messages is trivially satisfied. To assert that _no_
+message has been received, check `server.messages` directly instead (see
+below).
+
 ### Run assertions on messages as they are received by the mock server
 
 ```js
@@ -116,6 +155,21 @@ test('the server keeps track of received messages, and yields them as they come
 });
 ```
 
+### Assert that a message has not been received
+
+`server.messages` is updated synchronously, so it can be checked immediately
+without waiting for a timeout:
+
+```js
+test('asserts that no message has been received', async () => {
+  const server = new WS('ws://localhost:1234');
+  const client = new WebSocket('ws://localhost:1234');
+
+  await server.connected;
+  expect(server.messages).toEqual([]);
+});
+```
+
 ### Send messages to the connected clients
 
 ```js
@@ -177,7 +231,7 @@ This can be used to test behaviour for a client that connects to a WebSocket ser
 ```js
 test('rejects connections that fail the verifyClient option', async () => {
   new WS('ws://localhost:1234', { verifyClient: () => false });
-  const errorCallback = vitest.fn();
+  const errorCallback = vi.fn();
 
   await expect(
     new Promise((resolve, reject) => {
@@ -200,7 +254,7 @@ This can be used to test behaviour for a client that connects to a WebSocket ser
 test('rejects connections that fail the selectProtocol option', async () => {
   const selectProtocol = () => null;
   new WS('ws://localhost:1234', { selectProtocol });
-  const errorCallback = vitest.fn();
+  const errorCallback = vi.fn();
 
   await expect(
     new Promise((resolve, reject) => {
@@ -256,7 +310,7 @@ it('the server can refuse connections', async () => {
   });
 
   const client = new WebSocket('ws://localhost:1234');
-  client.onclose = (event: CloseEvent) => {
+  client.onclose = (event) => {
     expect(event.code).toBe(1003);
     expect(event.wasClean).toBe(false);
     expect(event.reason).toBe('NOPE');
@@ -292,7 +346,7 @@ afterEach(() => {
 
 `mock-socket` has a strong usage of delays (`setTimeout` to be more specific). This means using `vi.useFakeTimers();` will cause issues such as the client appearing to never connect to the server.
 
-While running the websocket server from tests within the vitest-dom environment (as opposed to node)
+While running the websocket server from tests within the jsdom environment (as opposed to node)
 you may see errors of the nature:
 
 ```bash
@@ -303,10 +357,23 @@ You can work around this by installing the setImmediate shim from
 [https://github.com/YuzuJS/setImmediate](https://github.com/YuzuJS/setImmediate) and
 adding `require('setimmediate');` to your `setupTests.js`.
 
+### The custom matchers are not recognized by TypeScript
+
+```
+Property 'toReceiveMessage' does not exist on type 'Assertion<void, WS>'.
+```
+
+The matchers are contributed with [module augmentation][augmentation], which
+only merges into the copy of `vitest` the augmentation resolves to. Deduplicate
+`vitest` if your project resolves more than one, for example a monorepo where a
+nested package pins its own.
+
+[augmentation]: https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
+
 ## Testing React applications
 
 When testing React applications, `vitest-websocket-mock` will look for
-`@testing-library/react`'s implementation of [`act`](https://reactjs.org/docs/test-utils.html#act).
+`@testing-library/react`'s implementation of [`act`](https://react.dev/reference/react/act).
 If it is available, it will wrap all the necessary calls in `act`, so you don't have to.
 
 If `@testing-library/react` is not available, we will assume that you're not testing a React application,
@@ -351,9 +418,3 @@ the `mock-socket` library that `vitest-websocket-mock` uses under the hood only
 implements the browser API.
 As a result, `vitest-websocket-mock` will only work with the `ws` library if you
 restrict yourself to the browser APIs!
-
-## Examples
-
-For a real life example, see the
-[examples directory](https://github.com/akiomik/vitest-websocket-mock/tree/main/examples),
-and in particular the saga tests.

package/dist/index.d.ts

@@ -1,88 +1,66 @@
-import { Server, ServerOptions, Client, CloseOptions } from 'mock-socket';
-import { RawMatcherFn } from '@vitest/expect';
-
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- */
-
-declare function deriveToHaveReceivedMessage(name: string, fn: RawMatcherFn): RawMatcherFn;
-
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- */
-
-declare function deriveToReceiveMessage(name: string, fn: RawMatcherFn): RawMatcherFn;
-
+import { Matcher } from "vitest";
+import { Client, CloseOptions, Server, ServerOptions } from "mock-socket";
+//#region src/derivers/deriveToHaveReceivedMessage.d.ts
+declare function deriveToHaveReceivedMessage(name: string, fn: Matcher): Matcher;
+//#endregion
+//#region src/derivers/deriveToReceiveMessage.d.ts
+declare function deriveToReceiveMessage(name: string, fn: Matcher): Matcher;
+//#endregion
+//#region src/derivers/types.d.ts
 /**
  * @copyright Romain Bertrand 2018
  * @copyright Akiomi Kamakura 2023
  */
 interface ReceiveMessageOptions {
-    timeout?: number;
+  timeout?: number;
 }
-
+//#endregion
+//#region src/queue.d.ts
 /**
  * @copyright Romain Bertrand 2018
  */
 declare class Queue<ItemT> {
-    pendingItems: Array<ItemT>;
-    nextItemResolver: () => void;
-    nextItem: Promise<void>;
-    put(item: ItemT): void;
-    get(): Promise<ItemT>;
+  pendingItems: Array<ItemT>;
+  nextItemResolver: () => void;
+  nextItem: Promise<void>;
+  put(item: ItemT): void;
+  get(): Promise<ItemT>;
 }
-
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- */
-
+//#endregion
+//#region src/websocket.d.ts
 interface WSOptions extends ServerOptions {
-    jsonProtocol?: boolean;
+  jsonProtocol?: boolean;
 }
 type DeserializedMessage<TMessage = object> = string | TMessage;
-declare class WS {
-    server: Server;
-    serializer: (deserializedMessage: DeserializedMessage) => string;
-    deserializer: (message: string) => DeserializedMessage;
-    static instances: Array<WS>;
-    messages: Array<DeserializedMessage>;
-    messagesToConsume: Queue<unknown>;
-    private _isConnected;
-    private _isClosed;
-    static clean(): void;
-    constructor(url: string, opts?: WSOptions);
-    get connected(): Promise<Client>;
-    get closed(): Promise<void>;
-    get nextMessage(): Promise<unknown>;
-    on(eventName: 'connection' | 'message' | 'close', callback: (socket: Client) => void): void;
-    send(message: DeserializedMessage): void;
-    close(options?: CloseOptions): void;
-    error(options?: CloseOptions): void;
+export default class WS {
+  server: Server;
+  serializer: (deserializedMessage: DeserializedMessage) => string;
+  deserializer: (message: string) => DeserializedMessage;
+  static instances: Array<WS>;
+  messages: Array<DeserializedMessage>;
+  messagesToConsume: Queue<unknown>;
+  private _isConnected;
+  private _isClosed;
+  static clean(): void;
+  constructor(url: string, opts?: WSOptions);
+  get connected(): Promise<Client>;
+  get closed(): Promise<void>;
+  get nextMessage(): Promise<unknown>;
+  on(eventName: 'connection' | 'message' | 'close', callback: (socket: Client) => void): void;
+  send(message: DeserializedMessage): void;
+  close(options?: CloseOptions): void;
+  error(options?: CloseOptions): void;
 }
-
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- */
-
+//#endregion
+//#region src/matchers/index.d.ts
 interface CustomMatchers<R = unknown> {
-    toReceiveMessage<TMessage = object>(message: DeserializedMessage<TMessage>, options?: ReceiveMessageOptions): Promise<R>;
-    toHaveReceivedMessages<TMessage = object>(messages: Array<DeserializedMessage<TMessage>>): R;
+  toReceiveMessage<TMessage = object>(message: DeserializedMessage<TMessage>, options?: ReceiveMessageOptions): Promise<void>;
+  toHaveReceivedMessages<TMessage = object>(messages: Array<DeserializedMessage<TMessage>>): R;
 }
-
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- */
-
-declare module '@vitest/expect' {
-    interface Assertion<T = any> extends CustomMatchers<T> {
-    }
-    interface AsymmetricMatchersContaining extends CustomMatchers {
-    }
+//#endregion
+//#region src/extend-expect.d.ts
+declare module 'vitest' {
+  interface Matchers<R extends void | Promise<void> = void | Promise<void>, T = unknown> extends CustomMatchers<R> {}
 }
-
-export { type ReceiveMessageOptions, WS, WS as default, deriveToHaveReceivedMessage, deriveToReceiveMessage };
+//#endregion
+export { type ReceiveMessageOptions, WS, deriveToHaveReceivedMessage, deriveToReceiveMessage };

package/dist/index.js

@@ -1,280 +1,254 @@
-var __defProp = Object.defineProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/extend-expect.ts
+import { createRequire } from "node:module";
 import { expect } from "vitest";
-
-// src/matchers/index.ts
-var matchers_exports = {};
-__export(matchers_exports, {
-  toHaveReceivedMessages: () => toHaveReceivedMessages_default,
-  toReceiveMessage: () => toReceiveMessage_default
-});
-
-// src/websocket.ts
 import { Server } from "mock-socket";
-
-// src/act-compat.ts
-var act;
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/act-compat.ts
+let act;
 try {
-  act = __require("@testing-library/react").act;
+	act = __require("@testing-library/react").act;
 } catch (_) {
-  act = (callback) => {
-    callback();
-  };
+	act = (callback) => {
+		callback();
+	};
 }
 var act_compat_default = act;
-
-// src/queue.ts
+//#endregion
+//#region src/queue.ts
+/**
+* @copyright Romain Bertrand 2018
+*/
 var Queue = class {
-  pendingItems = [];
-  nextItemResolver;
-  nextItem = new Promise((done) => this.nextItemResolver = done);
-  put(item) {
-    this.pendingItems.push(item);
-    this.nextItemResolver();
-    this.nextItem = new Promise((done) => this.nextItemResolver = done);
-  }
-  get() {
-    const item = this.pendingItems.shift();
-    if (item) {
-      return Promise.resolve(item);
-    }
-    let resolver;
-    const nextItemPromise = new Promise((done) => resolver = done);
-    this.nextItem.then(() => {
-      resolver(this.pendingItems.shift());
-    });
-    return nextItemPromise;
-  }
+	pendingItems = [];
+	nextItemResolver;
+	nextItem = new Promise((done) => this.nextItemResolver = done);
+	put(item) {
+		this.pendingItems.push(item);
+		this.nextItemResolver();
+		this.nextItem = new Promise((done) => this.nextItemResolver = done);
+	}
+	get() {
+		const item = this.pendingItems.shift();
+		if (item) return Promise.resolve(item);
+		let resolver;
+		const nextItemPromise = new Promise((done) => resolver = done);
+		this.nextItem.then(() => {
+			resolver(this.pendingItems.shift());
+		});
+		return nextItemPromise;
+	}
 };
-
-// src/websocket.ts
-var identity = (x) => x;
-var WS = class _WS {
-  server;
-  serializer;
-  deserializer;
-  static instances = [];
-  messages = [];
-  messagesToConsume = new Queue();
-  _isConnected;
-  _isClosed;
-  static clean() {
-    _WS.instances.forEach((instance) => {
-      instance.close();
-      instance.messages = [];
-    });
-    _WS.instances = [];
-  }
-  constructor(url, opts = {}) {
-    _WS.instances.push(this);
-    const { jsonProtocol = false, ...serverOptions } = opts;
-    this.serializer = jsonProtocol ? JSON.stringify : identity;
-    this.deserializer = jsonProtocol ? JSON.parse : identity;
-    let connectionResolver;
-    let closedResolver;
-    this._isConnected = new Promise((done) => connectionResolver = done);
-    this._isClosed = new Promise((done) => closedResolver = done);
-    this.server = new Server(url, serverOptions);
-    this.server.on("close", closedResolver);
-    this.server.on("connection", (socket) => {
-      connectionResolver(socket);
-      socket.on("message", (message) => {
-        const parsedMessage = this.deserializer(message);
-        this.messages.push(parsedMessage);
-        this.messagesToConsume.put(parsedMessage);
-      });
-    });
-  }
-  get connected() {
-    let resolve;
-    const connectedPromise = new Promise((done) => resolve = done);
-    const waitForConnected = async () => {
-      await act_compat_default(async () => {
-        await this._isConnected;
-      });
-      resolve(await this._isConnected);
-    };
-    waitForConnected();
-    return connectedPromise;
-  }
-  get closed() {
-    let resolve;
-    const closedPromise = new Promise((done) => resolve = done);
-    const waitForclosed = async () => {
-      await act_compat_default(async () => {
-        await this._isClosed;
-      });
-      await this._isClosed;
-      resolve();
-    };
-    waitForclosed();
-    return closedPromise;
-  }
-  get nextMessage() {
-    return this.messagesToConsume.get();
-  }
-  on(eventName, callback) {
-    this.server.on(eventName, callback);
-  }
-  send(message) {
-    act_compat_default(() => {
-      this.server.emit("message", this.serializer(message));
-    });
-  }
-  close(options) {
-    act_compat_default(() => {
-      this.server.close(options);
-    });
-  }
-  error(options) {
-    act_compat_default(() => {
-      this.server.emit("error", null);
-    });
-    this.server.close(options);
-  }
+//#endregion
+//#region src/websocket.ts
+/**
+* @copyright Romain Bertrand 2018
+* @copyright Akiomi Kamakura 2023
+*/
+const identity = (x) => x;
+var WS = class WS {
+	server;
+	serializer;
+	deserializer;
+	static instances = [];
+	messages = [];
+	messagesToConsume = new Queue();
+	_isConnected;
+	_isClosed;
+	static clean() {
+		WS.instances.forEach((instance) => {
+			instance.close();
+			instance.messages = [];
+		});
+		WS.instances = [];
+	}
+	constructor(url, opts = {}) {
+		WS.instances.push(this);
+		const { jsonProtocol = false, ...serverOptions } = opts;
+		this.serializer = jsonProtocol ? JSON.stringify : identity;
+		this.deserializer = jsonProtocol ? JSON.parse : identity;
+		let connectionResolver;
+		let closedResolver;
+		this._isConnected = new Promise((done) => connectionResolver = done);
+		this._isClosed = new Promise((done) => closedResolver = done);
+		this.server = new Server(url, serverOptions);
+		this.server.on("close", closedResolver);
+		this.server.on("connection", (socket) => {
+			connectionResolver(socket);
+			socket.on("message", (message) => {
+				const parsedMessage = this.deserializer(message);
+				this.messages.push(parsedMessage);
+				this.messagesToConsume.put(parsedMessage);
+			});
+		});
+	}
+	get connected() {
+		let resolve;
+		const connectedPromise = new Promise((done) => resolve = done);
+		const waitForConnected = async () => {
+			await act_compat_default(async () => {
+				await this._isConnected;
+			});
+			resolve(await this._isConnected);
+		};
+		waitForConnected();
+		return connectedPromise;
+	}
+	get closed() {
+		let resolve;
+		const closedPromise = new Promise((done) => resolve = done);
+		const waitForclosed = async () => {
+			await act_compat_default(async () => {
+				await this._isClosed;
+			});
+			await this._isClosed;
+			resolve();
+		};
+		waitForclosed();
+		return closedPromise;
+	}
+	get nextMessage() {
+		return this.messagesToConsume.get();
+	}
+	on(eventName, callback) {
+		this.server.on(eventName, callback);
+	}
+	send(message) {
+		act_compat_default(() => {
+			this.server.emit("message", this.serializer(message));
+		});
+	}
+	close(options) {
+		act_compat_default(() => {
+			this.server.close(options);
+		});
+	}
+	error(options) {
+		act_compat_default(() => {
+			this.server.emit("error", null);
+		});
+		this.server.close(options);
+	}
 };
+//#endregion
+//#region src/matcherUtils.ts
+/**
+* Plain-text replacements for `this.utils.matcherHint` / `printExpected` /
+* `printReceived`. Matcher messages must not contain ANSI color codes, so
+* that color detection (e.g. AI-agent environments) cannot make them differ
+* between environments; the reporter renders its own colored diff from the
+* `actual` / `expected` returned by matchers.
+*/
+function matcherHint(matcher, isNot = false) {
+	return `expect(WS).${isNot ? "not." : ""}${matcher}(expected)`;
+}
+const SPACE_SYMBOL = "·";
+function replaceTrailingSpaces(text) {
+	return text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
+}
+function printValue(value) {
+	return replaceTrailingSpaces(this.utils.stringify(value));
+}
+function formatComparison(hint, expectedLabel, expected, receivedLabel, received) {
+	return hint + `
 
-// src/derivers/makeInvalidWsMessage.ts
+${expectedLabel}\n  ${printValue.call(this, expected)}\n${receivedLabel}\n  ${printValue.call(this, received)}`;
+}
+//#endregion
+//#region src/derivers/makeInvalidWsMessage.ts
 function makeInvalidWsMessage(ws, matcher) {
-  return this.utils.matcherHint(this.isNot ? `.not.${matcher}` : `.${matcher}`, "WS", "expected") + `
+	return matcherHint(matcher, this.isNot) + `
 
 Expected the websocket object to be a valid WS mock.
-Received: ${typeof ws}
-  ${this.utils.printReceived(ws)}`;
+Received: ${typeof ws}\n  ${printValue.call(this, ws)}`;
 }
-
-// src/derivers/deriveToHaveReceivedMessage.ts
+//#endregion
+//#region src/derivers/deriveToHaveReceivedMessage.ts
 function deriveToHaveReceivedMessage(name, fn) {
-  return function(ws, expected, options) {
-    const isWS = ws instanceof WS;
-    if (!isWS) {
-      return {
-        pass: this.isNot,
-        // always fail
-        message: makeInvalidWsMessage.bind(this, ws, name)
-      };
-    }
-    return fn.call(this, ws.messages, expected, options);
-  };
+	return function(ws, expected, options) {
+		if (!(ws instanceof WS)) return {
+			pass: this.isNot,
+			message: makeInvalidWsMessage.bind(this, ws, name)
+		};
+		return fn.call(this, ws.messages, expected, options);
+	};
 }
-
-// src/derivers/deriveToReceiveMessage.ts
-var WAIT_DELAY = 1e3;
-var TIMEOUT = /* @__PURE__ */ Symbol("timeout");
+//#endregion
+//#region src/derivers/deriveToReceiveMessage.ts
+const WAIT_DELAY = 1e3;
+const TIMEOUT = Symbol("timeout");
 function deriveToReceiveMessage(name, fn) {
-  return async function(ws, expected, options) {
-    const isWS = ws instanceof WS;
-    if (!isWS) {
-      return {
-        pass: this.isNot,
-        // always fail
-        message: makeInvalidWsMessage.bind(this, ws, name)
-      };
-    }
-    const waitDelay = options?.timeout ?? WAIT_DELAY;
-    const messageOrTimeout = await Promise.race([
-      ws.nextMessage,
-      new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), waitDelay))
-    ]);
-    if (messageOrTimeout === TIMEOUT) {
-      return {
-        pass: this.isNot,
-        // always fail
-        message: () => this.utils.matcherHint(`${this.isNot ? ".not" : ""}.${name}`, "WS", "expected") + `
+	return async function(ws, expected, options) {
+		if (!(ws instanceof WS)) return {
+			pass: this.isNot,
+			message: makeInvalidWsMessage.bind(this, ws, name)
+		};
+		const waitDelay = options?.timeout ?? WAIT_DELAY;
+		const messageOrTimeout = await Promise.race([ws.nextMessage, new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), waitDelay))]);
+		if (messageOrTimeout === TIMEOUT) return {
+			pass: this.isNot,
+			message: () => matcherHint(name, this.isNot) + `
 
 Expected the websocket server to receive a message,
 but it didn't receive anything in ${waitDelay}ms.`
-      };
-    } else {
-      const received = messageOrTimeout;
-      return Promise.resolve(fn.call(this, received, expected, options));
-    }
-  };
+		};
+		else {
+			const received = messageOrTimeout;
+			return Promise.resolve(fn.call(this, received, expected, options));
+		}
+	};
 }
-
-// src/matchers/toHaveReceivedMessages.ts
-var toHaveReceivedMessages = deriveToHaveReceivedMessage(
-  "toHaveReceivedMessages",
-  function(received, expected) {
-    const equalities = expected.map(
-      (expectedMsg) => (
-        // object comparison to handle JSON protocols
-        received.some((receivedMsg) => this.equals(receivedMsg, expectedMsg))
-      )
-    );
-    const pass = this.isNot ? equalities.some(Boolean) : equalities.every(Boolean);
-    const message = pass ? () => this.utils.matcherHint(".not.toHaveReceivedMessages", "WS", "expected") + `
-
-Expected the WS server to not have received the following messages:
-  ${this.utils.printExpected(expected)}
-But it received:
-  ${this.utils.printReceived(received)}` : () => {
-      return this.utils.matcherHint(".toHaveReceivedMessages", "WS", "expected") + `
-
-Expected the WS server to have received the following messages:
-  ${this.utils.printExpected(expected)}
-Received:
-  ${this.utils.printReceived(received)}
-
-`;
-    };
-    return {
-      actual: received,
-      expected,
-      message,
-      pass
-    };
-  }
-);
-var toHaveReceivedMessages_default = toHaveReceivedMessages;
-
-// src/matchers/toReceiveMessage.ts
-import { diff } from "@vitest/utils/diff";
-var toReceiveMessage = deriveToReceiveMessage("toReceiveMessage", function(received, expected) {
-  const pass = this.equals(received, expected);
-  const message = pass ? () => this.utils.matcherHint(".not.toReceiveMessage", "WS", "expected") + `
-
-Expected the next received message to not equal:
-  ${this.utils.printExpected(expected)}
-Received:
-  ${this.utils.printReceived(received)}` : () => {
-    const diffString = diff(expected, received, { expand: this.expand });
-    return this.utils.matcherHint(".toReceiveMessage", "WS", "expected") + `
-
-Expected the next received message to equal:
-  ${this.utils.printExpected(expected)}
-Received:
-  ${this.utils.printReceived(received)}
-
-Difference:
-
-${diffString}`;
-  };
-  return {
-    actual: received,
-    expected,
-    message,
-    pass
-  };
+//#endregion
+//#region src/derivers/index.ts
+/**
+* @copyright Romain Bertrand 2018
+* @copyright Akiomi Kamakura 2023
+*/
+//#endregion
+//#region src/matchers/toHaveReceivedMessages.ts
+const toHaveReceivedMessages = deriveToHaveReceivedMessage("toHaveReceivedMessages", function(received, expected) {
+	const equalities = expected.map((expectedMsg) => received.some((receivedMsg) => this.equals(receivedMsg, expectedMsg)));
+	const pass = this.isNot ? equalities.some(Boolean) : equalities.every(Boolean);
+	return {
+		actual: received,
+		expected,
+		message: pass ? () => formatComparison.call(this, matcherHint("toHaveReceivedMessages", true), "Expected the WS server to not have received the following messages:", expected, "But it received:", received) : () => formatComparison.call(this, matcherHint("toHaveReceivedMessages"), "Expected the WS server to have received the following messages:", expected, "Received:", received),
+		pass
+	};
 });
-var toReceiveMessage_default = toReceiveMessage;
-
-// src/extend-expect.ts
+//#endregion
+//#region src/matchers/toReceiveMessage.ts
+const toReceiveMessage = deriveToReceiveMessage("toReceiveMessage", function(received, expected) {
+	const pass = this.equals(received, expected);
+	return {
+		actual: received,
+		expected,
+		message: pass ? () => formatComparison.call(this, matcherHint("toReceiveMessage", true), "Expected the next received message to not equal:", expected, "Received:", received) : () => formatComparison.call(this, matcherHint("toReceiveMessage"), "Expected the next received message to equal:", expected, "Received:", received),
+		pass
+	};
+});
+//#endregion
+//#region src/matchers/index.ts
+var matchers_exports = /* @__PURE__ */ __exportAll({
+	toHaveReceivedMessages: () => toHaveReceivedMessages,
+	toReceiveMessage: () => toReceiveMessage
+});
+//#endregion
+//#region src/extend-expect.ts
+/**
+* @copyright Romain Bertrand 2018
+* @copyright Akiomi Kamakura 2023
+*/
 expect.extend(matchers_exports);
-export {
-  WS,
-  WS as default,
-  deriveToHaveReceivedMessage,
-  deriveToReceiveMessage
-};
+//#endregion
+export { WS, WS as default, deriveToHaveReceivedMessage, deriveToReceiveMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-websocket-mock",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Mock websockets and assert complex websocket interactions with Vitest",
   "type": "module",
   "repository": {
@@ -18,9 +18,10 @@
   "scripts": {
     "clean": "rimraf dist",
     "prebuild": "npm run clean",
-    "build": "tsup",
-    "lint": "prettier --check . && eslint .",
-    "format": "prettier --write .",
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome check --write .",
     "prepublishOnly": "npm run build",
     "test": "vitest --run",
     "test:watch": "vitest"
@@ -34,27 +35,19 @@
   "author": "Akiomi Kamakura",
   "license": "MIT",
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.59.0",
-    "@typescript-eslint/parser": "^5.59.0",
-    "@vitest/coverage-v8": "4.1.1",
-    "eslint": "^8.38.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-config-react-app": "^7.0.1",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "eslint-plugin-react-refresh": "^0.3.4",
-    "eslint-plugin-simple-import-sort": "^10.0.0",
-    "prettier": "^2.0.2",
-    "rimraf": "^4.1.2",
-    "tsup": "^8.5.1",
-    "typescript": "^4.0.2",
+    "@biomejs/biome": "^2.5.3",
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^5.0.0",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
     "vite": "^8.1.4",
-    "vitest": "4.1.1"
+    "vitest": "^5.0.0"
   },
   "peerDependencies": {
-    "vitest": ">=4"
+    "vitest": ">=5 <6"
   },
   "dependencies": {
-    "@vitest/utils": "4.1.1",
     "mock-socket": "^9.2.1"
   },
   "files": [