vitest-websocket-mock 0.2.1 → 0.2.2

package/dist/index.d.ts

@@ -1,5 +1,27 @@
-import { RawMatcherFn } from '@vitest/expect';
 import { Server, Client, CloseOptions, ServerOptions } 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;
+
+/**
+ * @copyright Romain Bertrand 2018
+ * @copyright Akiomi Kamakura 2023
+ */
+interface ReceiveMessageOptions {
+    timeout?: number;
+}
 
 /**
  * @copyright Romain Bertrand 2018
@@ -46,20 +68,21 @@ declare class WS {
  * @copyright Akiomi Kamakura 2023
  */
 
-type ReceiveMessageOptions = {
-    timeout?: number;
-};
 interface CustomMatchers<R = unknown> {
     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
+ */
+
 declare module 'vitest' {
     interface Assertion<T = any> extends CustomMatchers<T> {
     }
     interface AsymmetricMatchersContaining extends CustomMatchers {
     }
 }
-declare const deriveToReceiveMessage: (name: string, fn: RawMatcherFn) => RawMatcherFn;
-declare const deriveToHaveReceivedMessage: (name: string, fn: RawMatcherFn) => RawMatcherFn;
 
-export { WS, WS as default, deriveToHaveReceivedMessage, deriveToReceiveMessage };
+export { ReceiveMessageOptions, WS, WS as default, deriveToHaveReceivedMessage, deriveToReceiveMessage };

package/dist/index.js

@@ -1,3 +1,4 @@
+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) {
@@ -5,11 +6,21 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw new 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/matchers.ts
-import { diff } from "jest-diff";
+// src/extend-expect.ts
 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";
 
@@ -135,17 +146,34 @@ var WS = class _WS {
   }
 };
 
-// src/matchers.ts
-var WAIT_DELAY = 1e3;
-var TIMEOUT = Symbol("timeout");
-var makeInvalidWsMessage = function makeInvalidWsMessage2(ws, matcher) {
+// src/derivers/makeInvalidWsMessage.ts
+function makeInvalidWsMessage(ws, matcher) {
   return this.utils.matcherHint(this.isNot ? `.not.${matcher}` : `.${matcher}`, "WS", "expected") + `
 
 Expected the websocket object to be a valid WS mock.
 Received: ${typeof ws}
   ${this.utils.printReceived(ws)}`;
-};
-var deriveToReceiveMessage = (name, fn) => {
+}
+
+// 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);
+  };
+}
+
+// src/derivers/deriveToReceiveMessage.ts
+var WAIT_DELAY = 1e3;
+var TIMEOUT = Symbol("timeout");
+function deriveToReceiveMessage(name, fn) {
   return async function(ws, expected, options) {
     const isWS = ws instanceof WS;
     if (!isWS) {
@@ -171,52 +199,12 @@ but it didn't receive anything in ${waitDelay}ms.`
       };
     } else {
       const received = messageOrTimeout;
-      const result = await Promise.resolve(fn.call(this, received, expected, options));
-      return { name, ...result };
+      return Promise.resolve(fn.call(this, received, expected, options));
     }
   };
-};
-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
-  };
-});
-var 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)
-      };
-    }
-    const result = fn.call(this, ws.messages, expected, options);
-    return { name, ...result };
-  };
-};
+// src/matchers/toHaveReceivedMessages.ts
 var toHaveReceivedMessages = deriveToHaveReceivedMessage(
   "toHaveReceivedMessages",
   function(received, expected) {
@@ -250,10 +238,41 @@ Received:
     };
   }
 );
-expect.extend({
-  toReceiveMessage,
-  toHaveReceivedMessages
+var toHaveReceivedMessages_default = toHaveReceivedMessages;
+
+// src/matchers/toReceiveMessage.ts
+import { diff } from "jest-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
+  };
 });
+var toReceiveMessage_default = toReceiveMessage;
+
+// src/extend-expect.ts
+expect.extend(matchers_exports);
 export {
   WS,
   WS as default,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-websocket-mock",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Mock websockets and assert complex websocket interactions with Vitest",
   "type": "module",
   "repository": {
@@ -51,7 +51,7 @@
     "vitest": "^0.32.0"
   },
   "peerDependencies": {
-    "vitest": "^0.32.0"
+    "vitest": ">=0.31.0 <1"
   },
   "dependencies": {
     "jest-diff": "^29.2.0",