vitest-websocket-mock 0.6.0 → 0.7.0

package/README.md

@@ -80,6 +80,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
 
@@ -102,6 +107,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 +127,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 +203,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 +226,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 +282,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 +318,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
@@ -306,7 +332,7 @@ adding `require('setimmediate');` to your `setupTests.js`.
 ## 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,

package/dist/index.d.ts

@@ -1,88 +1,67 @@
-import { Server, ServerOptions, Client, CloseOptions } from 'mock-socket';
-import { RawMatcherFn } from '@vitest/expect';
-
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- */
-
+import { Client, CloseOptions, Server, ServerOptions } from "mock-socket";
+import { RawMatcherFn } from "@vitest/expect";
+//#region src/derivers/deriveToHaveReceivedMessage.d.ts
 declare function deriveToHaveReceivedMessage(name: string, fn: RawMatcherFn): RawMatcherFn;
-
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- */
-
+//#endregion
+//#region src/derivers/deriveToReceiveMessage.d.ts
 declare function deriveToReceiveMessage(name: string, fn: RawMatcherFn): RawMatcherFn;
-
+//#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;
+  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<R>;
+  toHaveReceivedMessages<TMessage = object>(messages: Array<DeserializedMessage<TMessage>>): R;
 }
-
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- */
-
+//#endregion
+//#region src/extend-expect.d.ts
 declare module '@vitest/expect' {
-    interface Assertion<T = any> extends CustomMatchers<T> {
-    }
-    interface AsymmetricMatchersContaining extends CustomMatchers {
-    }
+  interface Assertion<T = any> extends CustomMatchers<T> {}
+  interface AsymmetricMatchersContaining extends CustomMatchers {}
 }
-
-export { type ReceiveMessageOptions, WS, WS as default, deriveToHaveReceivedMessage, deriveToReceiveMessage };
+//#endregion
+export { type ReceiveMessageOptions, WS, WS as default, 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.7.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",
+    "@biomejs/biome": "^2.5.3",
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.10",
     "rimraf": "^4.1.2",
-    "tsup": "^8.5.1",
-    "typescript": "^4.0.2",
+    "tsdown": "^0.22.5",
+    "typescript": "^7.0.2",
     "vite": "^8.1.4",
-    "vitest": "4.1.1"
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "vitest": ">=4"
   },
   "dependencies": {
-    "@vitest/utils": "4.1.1",
     "mock-socket": "^9.2.1"
   },
   "files": [