Initial commit

Author: Viorel Baicu

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.DS_Store

README.md

@@ -0,0 +1,100 @@
+# TFPSockets
+Simple, lightweight, event based websockets library for web and nodejs.
+
+[**TFPSockets**](https://github.com/vbaicu/TFPSockets)
+
+## Usage
+
+
+### Install
+
+```bash
+npm install --save tfpSockets
+```
+
+### Client
+
+**Include code - Browser**
+
+```html 
+<script src="TFPSocketsClient-Browser.js"> <script>
+```
+
+**Include code - Nodejs**
+
+```javascript
+const TFPSocketsClient = require('TFPSockets').client
+```
+
+**Open connection**
+
+```javascript 
+var conn = new TFPSocketsClient("ws://localhost:1600", ["chat"])
+    conn.on('connected', event => {
+        console.log('connected')
+       
+    })
+```
+
+**Add event listeners**
+```javascript
+conn.on('eventName', data => {
+    console.log('Received event: ', data.eventName, 'with payload: ', data.payload)
+})
+```
+**Send Events**
+
+Only supports sending serialisable objects and strings now. 
+Binary data support is in progress.
+
+```javascript
+conn.send('eventName',{x:0,y:0})
+```
+
+Client for browser is build on top of WebSocket javascript object. TFPSocketsClient provides access to base socket object via `ws` property and can also be initialised with a pre initialised WebSocket instance using: 
+```javascript
+var cleint = new TFPSocketsClient(null, null,initilisedWS)
+```
+
+## Server
+Server library is build on top of [**WS**](https://github.com/websockets/ws) libary. library provides access to base WebSocket.Server object via `wss` proprerty for those who need more customisation.
+
+**Include**
+
+```javascript
+const TFPSocketsServer = require('TFPSockets').server
+```
+
+**Create Server (using express)**
+
+```javascript
+const express = require('express');
+const http = require('http');
+const url = require('url');
+
+const app = express();
+
+
+const server = http.createServer(app);
+
+const TFPServer = new TFPSockets.server(server,["chat"])
+
+server.listen(1507, function listening() {
+  console.log('Listening on %d', server.address().port);
+});
+```
+
+**Listening for connections and event**
+```javascript
+TFPServer.on('connection',client => {
+  client.on('testEvent', data => {
+    console.log("test event payload: ", data.payload)
+    client.send('testEventBack',{x:1,y:100})
+  })
+})
+```
+
+## Limitations & next steps
+* doesn't support binary data events - WIP
+* ssl certificates setup - WIP
+

TFPSocketsClient-Browser.js

@@ -0,0 +1,77 @@
+const isString = s => typeof (s) === 'string' || s instanceof String;
+
+class TFPSocketsClient {
+
+    constructor(url, protocols,cutomws = null) {
+
+        this.EventStream = (function () {
+
+            var listeners = {};
+
+            const paddListener = (name, callback) => {
+                if (!listeners[name]) {
+                    listeners[name] = [];
+                }
+                listeners[name] = [...listeners[name], callback];
+            }
+
+            const premoveListener = (name, callback) => listeners[name] = listeners[name].filter(c => c != callback);
+
+            const pemit = (name, data) => (listeners[name] ? listeners[name] : []).forEach(c => c(data));
+
+
+            return {
+                addListener: (name, callback) => paddListener(name, callback),
+                removeListener: (name, callback) => premoveListener(name, callback),
+                emit: (name, data) => pemit(name, data)
+            };
+        }());
+
+        this.connectionUrl = url
+        this.connectionProtocols = protocols
+        this.isOpen = false
+        this.handlers = {}
+        this.ws = cutomws != null ? cutomws: new WebSocket(url, protocols)
+        this.ws.onopen = event => {
+            this.isOpen = true
+            this.EventStream.emit('connected', event)
+        }
+        this.ws.onclose = event => {
+            this.isOpen = false
+            this.EventStream.emit('disconnected', event)
+        }
+        this.ws.binaryType = "arraybuffer"
+        this.ws.onmessage = (data) => {
+            if (isString(data.data)) {
+                //handle incomming message
+                try {
+                    let obj = JSON.parse(data.data);
+                    this.EventStream.emit(obj.eventName, obj)
+                } catch (e) {
+                    console.log("Message doesn't repect protocol with exception: ", e)
+                }
+            } else {
+                //binary data wip
+            }
+        }
+    }
+
+    on(eventName, handler) {
+        this.EventStream.addListener(eventName, handler)
+    }
+
+    send(eventName, payload) {
+        let obj = { eventName, payload }
+        if (this.isOpen) {
+            this.ws.send(JSON.stringify(obj))
+        } else {
+            console.log("Connection is not opened")
+        }
+    }
+
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = TFPSocketsClient
+} else {
+}

example.js

@@ -0,0 +1,35 @@
+const express = require('express');
+const http = require('http');
+const url = require('url');
+const TFPSockets = require('./index')
+
+
+const app = express();
+
+
+const server = http.createServer(app);
+
+const TFPServer = new TFPSockets.server(server,["chat"])
+TFPServer.on('connection',client => {
+  client.on('testEvent', data => {
+    console.log("test event payload: ", data.payload)
+    client.send('testEventBack',{x:1,y:100})
+  })
+})
+
+
+const testClient = new TFPSockets.client("ws://localhost:1507",["chat"])
+testClient.on('open', event => {
+  console.log("test client open")
+  testClient.send('testEvent',{x:10,y:89})
+})
+
+testClient.on('testEventBack', data => {
+  console.log('testEventBack ', data.payload);
+})
+
+
+
+server.listen(1507, function listening() {
+  console.log('Listening on %d', server.address().port);
+});

index.js

@@ -0,0 +1,3 @@
+const TFP = require('./lib/TFPSockets.js')
+
+module.exports = TFP

lib/TFPSockets.js

@@ -0,0 +1,93 @@
+const WebSocket = require('ws')
+
+const isString = s => typeof (s) === 'string' || s instanceof String;
+
+class TFPBaseEventStream {
+    constructor() {
+        this.EventStream = (function () {
+
+            var listeners = {};
+
+            const paddListener = (name, callback) => {
+                if (!listeners[name]) {
+                    listeners[name] = [];
+                }
+                listeners[name] = [...listeners[name], callback];
+            }
+
+            const premoveListener = (name, callback) => listeners[name] = listeners[name].filter(c => c != callback);
+
+            const pemit = (name, data) => (listeners[name] ? listeners[name] : []).forEach(c => c(data));
+
+
+            return {
+                addListener: (name, callback) => paddListener(name, callback),
+                removeListener: (name, callback) => premoveListener(name, callback),
+                emit: (name, data) => pemit(name, data)
+            };
+        }());
+    }
+
+    on(eventName, handler) {
+        if(typeof handler === 'function'){
+            this.EventStream.addListener(eventName, handler)
+        } else {
+            console.log("Handler needs to be a function")
+        }
+    }
+}
+
+
+class TFPSocketsClient extends TFPBaseEventStream {
+
+    constructor(url, protocols, connection = null) {
+        super()
+        this.ws = connection != null ? connection : new WebSocket(url,protocols)
+        this.isOpen = connection != null
+        this.ws.on('open', event => {
+            this.isOpen = true
+            this.EventStream.emit('open',event)
+        })
+        this.ws.on('message', (data) => {
+            if (isString(data)) {
+                //handle incomming message
+                try {
+                    let obj = JSON.parse(data);
+                    this.EventStream.emit(obj.eventName, obj)
+                } catch (e) {
+                    console.log("Message doesn't repect protocol with exception: ", e)
+                }
+            } else {
+                //binary data wip
+            }
+        })
+        this.ws.on('close', () => this.EventStream.emit('close') )
+    }
+
+    send(eventName, payload) {
+        let obj = { eventName, payload }
+        if (this.isOpen) {
+            this.ws.send(JSON.stringify(obj))
+        } else {
+            console.log("Connection is not opened")
+        }
+    }
+
+}
+
+class TFPSocketsServer extends TFPBaseEventStream {
+    constructor(server, protocols, customwss = null) {
+        super()
+        this.wss = customwss != null ? customwss : new WebSocket.Server({ server, handleProtocols: (ps, req) => { return protocols } });
+        this.wss.on('connection', (ws, req) => {
+            var client = new TFPSocketsClient(null, null,ws);
+            this.EventStream.emit('connection', client);
+        });
+    }
+
+}
+
+module.exports = {
+    client: TFPSocketsClient,
+    server: TFPSocketsServer
+}

package.json

@@ -0,0 +1,24 @@
+{
+  "name": "tfpsockets",
+  "version": "0.1.0",
+  "description": "Simple event based websockets wrapper",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "websocktes",
+    "ws",
+    "nodewebsockets",
+    "javascrip",
+    "js",
+    "sockets",
+    "tcp"
+  ],
+  "author": "Viorel Baicu",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.16.0",
+    "ws": "^3.2.0"
+  }
+}