teckos-client 0.2.4 → 0.3.1

package/lib/index.js

@@ -0,0 +1,484 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var IsomorphicWebSocket = require('isomorphic-ws');
+
+function _interopNamespace(e) {
+if (e && e.__esModule) return e;
+var n = Object.create(null);
+if (e) {
+Object.keys(e).forEach(function (k) {
+if (k !== 'default') {
+var d = Object.getOwnPropertyDescriptor(e, k);
+Object.defineProperty(n, k, d.get ? d : {
+enumerable: true,
+get: function () { return e[k]; }
+});
+}
+});
+}
+n["default"] = e;
+return Object.freeze(n);
+}
+
+var IsomorphicWebSocket__namespace = /*#__PURE__*/_interopNamespace(IsomorphicWebSocket);
+
+/**
+ * Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js
+ *
+ * Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes
+ * during build.
+ * @param {number} code
+ */
+function formatProdErrorMessage(code) {
+  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or ` + 'use the non-minified dev environment for full errors. ';
+} // eslint-disable-next-line import/no-default-export
+
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+
+const encodePacket = packet => enc.encode(JSON.stringify(packet));
+
+const decodePacket = buffer => JSON.parse(dec.decode(buffer).toString());
+
+class SocketEventEmitter {
+  maxListeners = 50;
+  handlers = {};
+  addListener = (event, listener) => {
+    if (Object.keys(this.handlers).length === this.maxListeners) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(2) : 'Max listeners reached');
+    }
+
+    if (typeof listener !== 'function') {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(3) : 'The given listener is not a function');
+    }
+
+    this.handlers[event] = this.handlers[event] || [];
+    this.handlers[event].push(listener);
+    return this;
+  };
+  once = (event, listener) => {
+    if (Object.keys(this.handlers).length === this.maxListeners) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(2) : 'Max listeners reached');
+    }
+
+    if (typeof listener !== 'function') {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(3) : 'The given listener is not a function');
+    }
+
+    this.handlers[event] = this.handlers[event] || [];
+
+    const onceWrapper = () => {
+      listener();
+      this.off(event, onceWrapper);
+    };
+
+    this.handlers[event].push(onceWrapper);
+    return this;
+  };
+  removeListener = (event, listener) => {
+    if (this.handlers[event]) {
+      this.handlers[event] = this.handlers[event].filter(handler => handler !== listener);
+    }
+
+    return this;
+  };
+  off = (event, listener) => this.removeListener(event, listener);
+  removeAllListeners = event => {
+    if (event) {
+      delete this.handlers[event];
+    } else {
+      this.handlers = {};
+    }
+
+    return this;
+  };
+  setMaxListeners = n => {
+    this.maxListeners = n;
+    return this;
+  };
+  getMaxListeners = () => this.maxListeners;
+  listeners = event => {
+    if (this.handlers[event]) {
+      return [...this.handlers[event]];
+    }
+
+    return [];
+  };
+  rawListeners = event => [...this.handlers[event]];
+  listenerCount = event => {
+    if (this.handlers[event]) {
+      return Object.keys(this.handlers[event]).length;
+    }
+
+    return 0;
+  };
+  prependListener = (event, listener) => {
+    if (Object.keys(this.handlers).length === this.maxListeners) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(2) : 'Max listeners reached');
+    }
+
+    this.handlers[event] = this.handlers[event] || [];
+    this.handlers[event].unshift(listener);
+    return this;
+  };
+  prependOnceListener = (event, listener) => {
+    if (Object.keys(this.handlers).length === this.maxListeners) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(2) : 'Max listeners reached');
+    }
+
+    this.handlers[event] = this.handlers[event] || [];
+
+    const onceWrapper = () => {
+      listener();
+      this.off(event, onceWrapper);
+    };
+
+    this.handlers[event].unshift(onceWrapper);
+    return this;
+  };
+  eventNames = () => Object.keys(this.handlers);
+  on = (event, listener) => this.addListener(event, listener);
+  emit = (event, ...args) => {
+    const listeners = this.listeners(event);
+
+    if (listeners.length > 0) {
+      listeners.forEach(listener => {
+        if (listener) listener(args);
+      });
+      return true;
+    }
+
+    return false;
+  };
+}
+
+exports.PacketType = void 0;
+
+(function (PacketType) {
+  PacketType[PacketType["EVENT"] = 0] = "EVENT";
+  PacketType[PacketType["ACK"] = 1] = "ACK";
+})(exports.PacketType || (exports.PacketType = {}));
+
+exports.ConnectionState = void 0;
+
+(function (ConnectionState) {
+  ConnectionState["DISCONNECTED"] = "disconnected";
+  ConnectionState["CONNECTING"] = "connecting";
+  ConnectionState["CONNECTED"] = "connected";
+  ConnectionState["DISCONNECTING"] = "disconnecting";
+})(exports.ConnectionState || (exports.ConnectionState = {}));
+
+const DEFAULT_OPTIONS = {
+  reconnection: true,
+  reconnectionDelay: 1000,
+  reconnectionDelayMax: 5000,
+  reconnectionAttempts: Infinity,
+  randomizationFactor: 0.5,
+  timeout: 5000,
+  debug: false
+};
+
+class TeckosClient extends SocketEventEmitter {
+  url;
+  options;
+  ws;
+  currentReconnectDelay;
+  currentReconnectionAttempts = 0;
+  acks = new Map();
+  fnId = 0;
+  connectionTimeout;
+  reconnectionTimeout;
+
+  constructor(url, options) {
+    super();
+    this.options = { ...DEFAULT_OPTIONS,
+      ...options
+    };
+    this.currentReconnectDelay = this.options.reconnectionDelay;
+    this.url = url;
+  }
+
+  attachHandler = () => {
+    if (this.ws) {
+      this.ws.onopen = this.handleOpen;
+      this.ws.onerror = this.handleError;
+      this.ws.onclose = this.handleClose;
+      this.ws.onmessage = this.handleMessage;
+    }
+  };
+
+  get webSocket() {
+    return this.ws;
+  }
+
+  connect = () => {
+    if (this.options.debug) console.log(`(teckos:client) Connecting to ${this.url}...`); // This will try to connect immediately
+    // eslint-disable-next-line new-cap
+
+    this.ws = new IsomorphicWebSocket__namespace.WebSocket(this.url); // Attach handlers
+
+    this.attachHandler(); // Handle timeout
+
+    this.connectionTimeout = setTimeout(() => {
+      if (this.ws && this.ws.readyState === 0
+      /* = CONNECTING */
+      ) {
+        this.ws.close();
+      }
+    }, this.options.timeout);
+  };
+  reconnect = () => {
+    this.listeners('reconnect_attempt').forEach(listener => listener());
+    this.connect();
+  };
+
+  getConnectionState() {
+    if (this.ws) {
+      switch (this.ws.readyState) {
+        case 0
+        /* = CONNECTING */
+        :
+          return exports.ConnectionState.CONNECTING;
+
+        case 1
+        /* = OPEN */
+        :
+          return exports.ConnectionState.CONNECTED;
+
+        case 2
+        /* = CLOSING */
+        :
+          return exports.ConnectionState.DISCONNECTING;
+
+        default:
+          /* 3 = CLOSED */
+          return exports.ConnectionState.DISCONNECTED;
+      }
+    }
+
+    return exports.ConnectionState.DISCONNECTED;
+  }
+
+  get state() {
+    return this.getConnectionState();
+  }
+
+  get connected() {
+    return this.getConnectionState() === exports.ConnectionState.CONNECTED;
+  }
+
+  get disconnected() {
+    return this.getConnectionState() === exports.ConnectionState.DISCONNECTED;
+  }
+
+  emit = (event, ...args) => {
+    args.unshift(event);
+    const packet = {
+      type: exports.PacketType.EVENT,
+      data: args
+    };
+
+    if (typeof args[args.length - 1] === 'function') {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      this.acks.set(this.fnId, args.pop());
+      packet.id = this.fnId;
+      this.fnId += 1;
+    }
+
+    return this.sendPackage(packet);
+  };
+  send = (...args) => {
+    args.unshift('message');
+    return this.sendPackage({
+      type: exports.PacketType.EVENT,
+      data: args
+    });
+  };
+  sendPackage = packet => {
+    if (this.ws !== undefined && this.ws.readyState === 1
+    /* = OPEN */
+    ) {
+      const buffer = encodePacket(packet);
+      if (this.options.debug) console.log(`(teckos:client) [${this.url}] Send packet: ${JSON.stringify(packet)}`);
+      this.ws.send(buffer);
+      return true;
+    }
+
+    return false;
+  };
+  handleMessage = msg => {
+    const packet = typeof msg.data === 'string' ? JSON.parse(msg.data) : decodePacket(msg.data);
+    if (this.options.debug) console.log(`(teckos:client) [${this.url}] Got packet: ${JSON.stringify(packet)}`);
+
+    if (packet.type === exports.PacketType.EVENT) {
+      const event = packet.data[0];
+      const args = packet.data.slice(1);
+
+      if (event) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this.listeners(event).forEach(listener => listener(...args));
+      } else {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : `(teckos-client) [${this.url}] Got invalid event message: ${JSON.stringify(msg.data)}`);
+      }
+    } else if (packet.type === exports.PacketType.ACK && packet.id !== undefined) {
+      // Call assigned function
+      const ack = this.acks.get(packet.id);
+
+      if (typeof ack === 'function') {
+        ack.apply(this, packet.data);
+        this.acks.delete(packet.id);
+      }
+    } else {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(1) : `(teckos-client) [${this.url}] Got invalid message type: ${packet.type}`);
+    }
+  };
+  handleOpen = () => {
+    if (this.currentReconnectionAttempts > 0) {
+      // Reset reconnection settings to default
+      this.currentReconnectDelay = this.options.reconnectionDelay;
+      this.currentReconnectionAttempts = 0; // Inform listeners
+
+      if (this.options.debug) console.log(`(teckos:client) [${this.url}] Reconnected!`); // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+
+      this.listeners('reconnect').forEach(listener => listener());
+    } // Inform listeners
+
+
+    if (this.options.debug) console.log(`(teckos:client) [${this.url}] Connected!`);
+    this.listeners('connect').forEach(listener => listener());
+  };
+  handleError = error => {
+    if (this.handlers && this.handlers.error) {
+      if (this.options.debug) console.log(`(teckos:client) [${this.url}] Got error from server: ${JSON.stringify(error)}`);
+      this.handlers.error.forEach(listener => listener(error));
+    }
+  };
+  handleClose = () => {
+    // Stop connection timeout
+    if (this.connectionTimeout) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      clearTimeout(this.connectionTimeout);
+    } // Stop reconnection timeout
+
+
+    if (this.reconnectionTimeout) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      clearTimeout(this.reconnectionTimeout);
+    } // Inform listeners
+
+
+    if (this.currentReconnectionAttempts > 0) {
+      if (this.options.debug) console.log(`(teckos:client) [${this.url}] Reconnect #${this.currentReconnectionAttempts} failed!`);
+      this.listeners('reconnect_error').forEach(listener => {
+        if (listener) listener();
+      });
+    } else {
+      if (this.options.debug) console.log(`(teckos:client) [${this.url}] Disconnected!`);
+      this.listeners('disconnect').forEach(listener => {
+        if (listener) listener();
+      });
+    }
+
+    if (this.options.reconnection) {
+      // Apply reconnection logic
+      this.currentReconnectionAttempts += 1;
+
+      if (this.options.reconnectionAttempts === Infinity || this.currentReconnectionAttempts <= this.options.reconnectionAttempts) {
+        const timeout = Math.min(this.options.reconnectionDelayMax, this.currentReconnectDelay); // Increase reconnection delay
+
+        this.currentReconnectDelay = Math.round(this.currentReconnectDelay + this.currentReconnectDelay * this.options.randomizationFactor);
+        if (this.options.debug) console.log(`(teckos:client) [${this.url}] Try reconnecting (${this.currentReconnectionAttempts}/${this.options.reconnectionAttempts}) in ${timeout}ms to ${this.url}...`);
+        this.reconnectionTimeout = setTimeout(() => {
+          this.reconnect();
+        }, timeout);
+      } else {
+        if (this.options.debug) console.log(`(teckos:client) [${this.url}] Reconnection maximum of ${this.options.reconnectionAttempts} reached`);
+        this.listeners('reconnect_failed').forEach(listener => listener());
+      }
+    }
+  };
+  close = () => {
+    if (this.options.debug) console.log(`(teckos:client) [${this.url}] Closing connection (client-side)`);
+
+    if (this.ws !== undefined) {
+      this.ws.onclose = () => {};
+
+      this.ws.close();
+      this.listeners('disconnect').forEach(listener => listener());
+    }
+  };
+  disconnect = () => {
+    this.close();
+  };
+}
+
+/* eslint-disable no-console */
+
+class TeckosClientWithJWT extends TeckosClient {
+  token;
+  initialData;
+  receivedReady = false; // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+
+  constructor(url, options, token, initialData) {
+    super(url, options);
+    this.token = token; // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+
+    this.initialData = initialData;
+    this.on('disconnect', () => {
+      this.receivedReady = false;
+    });
+  }
+
+  getConnectionState() {
+    if (this.ws) {
+      switch (this.ws.readyState) {
+        case IsomorphicWebSocket__namespace.WebSocket.OPEN:
+          if (this.receivedReady) {
+            return exports.ConnectionState.CONNECTED;
+          }
+
+          return exports.ConnectionState.CONNECTING;
+
+        case IsomorphicWebSocket__namespace.WebSocket.CONNECTING:
+          return exports.ConnectionState.CONNECTING;
+
+        case IsomorphicWebSocket__namespace.WebSocket.CLOSING:
+          return exports.ConnectionState.DISCONNECTING;
+
+        default:
+          return exports.ConnectionState.DISCONNECTED;
+      }
+    }
+
+    return exports.ConnectionState.DISCONNECTED;
+  }
+
+  handleReadyEvent = () => {
+    if (this.options.debug) console.log(`(teckos:client) [${this.url}] Connected!`);
+    this.receivedReady = true;
+
+    if (this.currentReconnectionAttempts > 0) {
+      if (this.options.debug) console.log(`(teckos:client) [${this.url}] Reconnected!`);
+      this.listeners('reconnect').forEach(listener => listener()); // Reset reconnection settings to default
+
+      this.currentReconnectDelay = this.options.reconnectionDelay;
+      this.currentReconnectionAttempts = 0;
+    }
+
+    this.listeners('connect').forEach(listener => listener());
+  };
+  handleOpen = () => {
+    this.receivedReady = false;
+    this.once('ready', this.handleReadyEvent);
+    if (this.options.debug) console.log(`(teckos:client) Connection opened, sending token now`);
+    this.emit('token', {
+      token: this.token,
+      ...this.initialData
+    });
+  };
+}
+
+exports.TeckosClient = TeckosClient;
+exports.TeckosClientWithJWT = TeckosClientWithJWT;

package/package.json

@@ -1,15 +1,17 @@
 {
-  "version": "0.2.4",
+  "version": "0.3.1",
   "license": "MIT",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "lib/teckos-client.js",
+  "unpkg": "dist/teckos-client.js",
+  "module": "es/teckos-client.js",
+  "types": "types/index.d.ts",
   "files": [
     "dist",
-    "src"
+    "lib",
+    "es",
+    "src",
+    "types"
   ],
-  "engines": {
-    "node": ">=10"
-  },
   "keywords": [
     "websocket",
     "uwebsocket",
@@ -17,15 +19,15 @@
     "callbacks"
   ],
   "scripts": {
+    "clean": "rimraf lib dist es coverage types",
     "dev:web": "webpack serve --config webpack.config.example.web.js",
     "dev:node": "DEBUG=example*,teckos* nodemon --watch './src/**/*.ts,./example/node/**/*.ts' --exec 'ts-node' --project tsconfig.example.node.json example/node/index.ts",
     "build:example:web": "npm run build && webpack --config webpack.config.example.web.js",
     "build:example:node": "npm run build && tsc --p tsconfig.example.node.json",
-    "start": "tsdx watch",
-    "build": "tsdx build",
-    "test": "env TS_NODE_COMPILER_OPTIONS='{\"module\": \"commonjs\" }' mocha -r ts-node/register '__tests__/**/*.ts'",
-    "lint": "npx eslint ./src --ext .ts",
-    "prepare": "tsdx build",
+    "check-types": "tsc --noEmit",
+    "build": "rollup -c",
+    "lint": "eslint --ext js,ts src",
+    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest",
     "size": "size-limit",
     "analyze": "size-limit --why"
   },
@@ -52,7 +54,6 @@
   "bugs": {
     "url": "https://github.com/delude88/teckos-client/issues"
   },
-  "module": "dist/teckos-client.esm.js",
   "size-limit": [
     {
       "path": "dist/teckos-client.cjs.production.min.js",
@@ -64,48 +65,66 @@
     }
   ],
   "devDependencies": {
+    "@babel/cli": "^7.17.10",
+    "@babel/core": "^7.18.5",
+    "@babel/eslint-parser": "^7.18.2",
+    "@babel/node": "^7.18.5",
+    "@babel/plugin-external-helpers": "^7.17.12",
+    "@babel/plugin-proposal-object-rest-spread": "^7.18.0",
+    "@babel/plugin-transform-runtime": "^7.18.5",
+    "@babel/preset-env": "^7.18.2",
+    "@babel/preset-flow": "^7.17.12",
+    "@babel/preset-typescript": "^7.17.12",
+    "@babel/register": "^7.17.7",
+    "@rollup/plugin-babel": "^5.3.1",
+    "@rollup/plugin-node-resolve": "^13.3.0",
+    "@rollup/plugin-replace": "^4.0.0",
     "@size-limit/preset-small-lib": "^7.0.8",
-    "@types/chai": "^4.3.0",
-    "@types/debug": "^4.1.7",
-    "@types/mocha": "^9.1.0",
-    "@types/node": "^17.0.20",
-    "@types/ws": "^8.2.3",
-    "@typescript-eslint/eslint-plugin": "^5.12.1",
-    "@typescript-eslint/parser": "^5.12.1",
+    "@types/jest": "^28.1.3",
+    "@types/node": "^18.0.0",
+    "@types/ws": "^8.5.3",
+    "@typescript-eslint/eslint-plugin": "^5.29.0",
+    "@typescript-eslint/parser": "^5.29.0",
     "babel-eslint": "^10.1.0",
-    "chai": "^4.3.6",
+    "babel-jest": "^28.1.1",
     "clean-webpack-plugin": "^4.0.0",
-    "eslint": "^8.9.0",
+    "cross-env": "^7.0.3",
+    "eslint": "^8.18.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-airbnb-typescript": "^16.1.0",
-    "eslint-config-prettier": "^8.4.0",
-    "eslint-config-react-app": "^7.0.0",
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-react-app": "^7.0.1",
     "eslint-plugin-flowtype": "^8.0.3",
-    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-jsx-a11y": "^6.5.1",
     "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-promise": "^6.0.0",
-    "eslint-plugin-react": "^7.28.0",
-    "eslint-plugin-react-hooks": "^4.3.0",
+    "eslint-plugin-react": "^7.30.0",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "glob": "^8.0.3",
     "html-webpack-plugin": "^5.5.0",
-    "husky": "^7.0.4",
-    "mocha": "^9.2.1",
-    "nodemon": "^2.0.15",
-    "prettier": "^2.5.1",
+    "husky": "^8.0.1",
+    "ioredis": "^5.0.6",
+    "jest": "^28.1.1",
+    "nodemon": "^2.0.18",
+    "prettier": "^2.7.1",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.75.7",
+    "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-typescript2": "^0.32.1",
     "size-limit": "^7.0.8",
-    "teckos": "^0.8.0",
-    "ts-loader": "^9.2.6",
-    "ts-node": "^10.5.0",
-    "tsdx": "^0.14.1",
-    "tslib": "^2.3.1",
-    "typescript": "^4.5.5",
-    "webpack": "^5.69.1",
-    "webpack-cli": "^4.9.2",
-    "webpack-dev-server": "^4.7.4",
-    "ws": "^8.5.0"
+    "teckos": "^0.9.6",
+    "ts-jest": "^28.0.5",
+    "ts-node": "^10.8.1",
+    "typescript": "^4.7.4",
+    "webpack": "^5.73.0",
+    "webpack-cli": "^4.10.0",
+    "webpack-dev-server": "^4.9.2",
+    "ws": "^8.8.0"
   },
   "dependencies": {
-    "debug": "^4.3.3",
+    "@babel/runtime": "^7.18.3",
     "isomorphic-ws": "^4.0.1"
-  }
+  },
+  "sideEffects": false
 }

package/src/ITeckosClient.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ITeckosClient.js.map

package/src/ITeckosClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITeckosClient.js","sourceRoot":"","sources":["ITeckosClient.ts"],"names":[],"mappings":""}

package/src/ITeckosClient.ts

@@ -1,10 +1,10 @@
-import WebSocket from 'isomorphic-ws'
+import * as IsomorphicWebSocket from 'isomorphic-ws'
 import { ConnectionState, Packet, SocketEvent } from './types'
 import { SocketEventEmitter } from './util/SocketEventEmitter'
 
 interface ITeckosClient extends SocketEventEmitter<SocketEvent> {
-    ws: WebSocket | undefined
-    readonly webSocket: WebSocket | undefined
+    ws: IsomorphicWebSocket.WebSocket | undefined
+    readonly webSocket: IsomorphicWebSocket.WebSocket | undefined
     readonly state: ConnectionState
     readonly connected: boolean
     readonly disconnected: boolean