angelia.io 2.3.68 → 2.4.71

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "angelia.io",
-	"version": "2.3.68",
+	"version": "2.4.71",
 	"description": "WebSockets Server and Client API for node.js and the browser, with rooms support.",
 	"homepage": "https://github.com/titoBouzout/angelia.io",
 	"repository": {

package/readme.md

@@ -1,6 +1,6 @@
 # angelia.io
 
-WebSockets Server and Client API for node.js and the browser, with rooms support.
+WebSockets Server and Client API for node.js and the browser, (with rooms support in development).
 
 The goal of this project is to provide a developer friendly API that just works™.
 
@@ -12,18 +12,24 @@ If you fancy for Client side a regular JavaScript file, then use https://github.
 
 ## Simple Example
 
-### Server (Node.js)
-
 ```JavaScript
 // server.js (node.js)
 import Server from 'angelia.io/server';
 
-class Connection {
-	async listen() {
-		console.log('-'.repeat(60));
-		console.log('Server started listening on port ' + this.server.port);
-		console.log(this.server);
+class FancyChat {
+	async typing(socket, data, callback) {
+		console.log('Im', data ? ' typing' : ' not typing')
 	}
+	async theMessage(socket, data, callback) {
+		console.log('the message is', data, socket)
+		socket.emit('gotIt', 'thanks')
+		callback('yes Im sure')
+	}
+}
+
+Server.on(FancyChat);
+
+class Connection {
 	async connect(socket, request) {
 		console.log('socket connected', socket)
 	}
@@ -33,42 +39,30 @@ class Connection {
 }
 Server.on(Connection);
 
-class FancyChat {
-	async chatMessage(socket, message, callback) {
-		console.log('socket sent', message)
-		socket.emit('chatMessage', 'Hi client nice to meet you')
-		callback('yes, got it')
-	}
-}
-Server.on(FancyChat);
-
-const server = new Server.listen({
+Server.listen({
 	port: 3001,
 });
-```
-
-### Client (Browser)
 
-```JavaScript
 // index.js (browser)
 import Client from 'angelia.io/client';
 
-const socket = new Client({
-	url: 'ws://localhost:3001',
-});
+const socket = new Client('ws://localhost:3001');
 
-socket.on('chatMessage', (message) => {
-	console.log('Server sent', message)
-})
+socket.emit('typing', true)
 
-socket.emit('chatMessage', 'Hi there server, Im client', (data) =>{
-	console.log('you got it?', data)
+setTimeout(() => {
+	socket.emit('typing', false)
+	socket.emit('theMessage', 'hi there!', (data) =>{
+		console.log('you sure?', data)
+	})
+}, 10000)
+
+socket.on('gotIt', (message) => {
+	console.log('Server got it yey', message)
 })
 ```
 
-## Server (Node.js)
-
-### Options
+## Server Documentation (Node.js)
 
 A call to `Server.listen` starts the server. `Server` is a singleton and can only have running 1 server.
 
@@ -76,7 +70,7 @@ A call to `Server.listen` starts the server. `Server` is a singleton and can onl
 // server.js (node.js)
 import Server from 'angelia.io/server'
 
-const server = new Server.listen({
+Server.listen({
 	hostname: 'localhost',
 	port: 3001,
 	maxMessageSize: 5,
@@ -85,13 +79,14 @@ const server = new Server.listen({
 })
 ```
 
+### `Server` Options
+
 | name                 | kind    | default | description                                         |
 | -------------------- | ------- | ------- | --------------------------------------------------- |
 | `hostname`           | String  | ''      | the hostname if any                                 |
 | `port`               | Number  | 3001    | the port to use for this server                     |
 | `maxMessageSize`     | Number  | 5       | max size in mb of a message received                |
 | `skipUTF8Validation` | Boolean | false   | allows to skip utf8 validation                      |
-| `dontConnect`        | Boolean | false   | allows to instance the socket without connecting    |
 | `cert`               | String  | ''      | path to the cert file for using https fullchain.pem |
 | `key`                | String  | ''      | path to the key file for using https privkey.pem    |
 
@@ -110,12 +105,15 @@ class _ {
 }
 Server.on(_)
 
-const server = new Server.listen({
+Server.listen({
 	port: 3001,
 })
 ```
 
-#### Server Properties
+#### List of `Server` Object Properties
+
+<details>
+<summary><b>Expand</b></summary>
 
 | signature                             | kind     | description                                                                                    |
 | ------------------------------------- | -------- | ---------------------------------------------------------------------------------------------- |
@@ -141,7 +139,9 @@ const server = new Server.listen({
 | `broadcastOnce(sender, key, [value])` | Function | emits to the sockets except sender and replace if exists a pending message with the same `key` |
 | `sockets`                             | Set      | a Set() with all the current connected sockets                                                 |
 
-### Socket Object
+</details>
+
+### `Socket` Object
 
 The `socket` object is given to you by a listener
 
@@ -156,12 +156,15 @@ class _ {
 }
 Server.on(_)
 
-new Server.listen({
+Server.listen({
 	port: 3001,
 })
 ```
 
-#### Socket Properties
+#### List of `Socket` Object Properties
+
+<details>
+<summary><b>Expand</b></summary>
 
 | signature                   | kind     | description                                                                   |
 | --------------------------- | -------- | ----------------------------------------------------------------------------- |
@@ -182,72 +185,23 @@ new Server.listen({
 | `once(key, [value])`        | Function | replace if exists a pending message with the same `key` from emit queue       |
 | `disconnect([noReconnect])` | Function | disconnects the socket from the server, pass `true` to prevent re-connections |
 
+</details>
+
 ### Listeners
 
 To listen for a client message/event you may do the familiar way `Server.on('connect', (socket) => {console.log('socket connected!', socket)})`
 
 However, to ease organization and development you may listen to an event by creating a class with any name, and give to methods the name of the things you want to listen to. You then add your class to the listeners as `Server.on(MyClass);` and you are done.
 
-On user defined listeners, the listener receives three things as sent by the client: `socket`, `data` and a `callback`; Example `class FancyChat { async typing(socket, data, callback) {console.log(socket, data);callback('got it')}}`.
-
-If you are building a chat you may write something like this
-
-```JavaScript
-// server.js (node.js)
-import Server from 'angelia.io/server';
-
-class FancyChat {
-	async typing(socket, data, callback) {
-		console.log('Im', data ? ' typing' : ' not typing')
-	}
-	async theMessage(socket, data, callback) {
-		console.log('the message is', data, socket)
-		socket.emit('gotIt', 'thanks')
-		callback('yes Im sure')
-	}
-}
-
-Server.on(FancyChat);
-
-class Connection {
-	async connect(socket, request) {
-		console.log('socket connected', socket)
-	}
-	async disconnect(socket, code, message) {
-		console.log('socket disconnected', code, message, socket);
-	}
-}
-Server.on(Connection);
-
-const server = new Server.listen({
-	port: 3001,
-});
-
-// index.js (browser)
-import Client from 'angelia.io/client';
-
-const socket = new Client({
-	url: 'ws://localhost:3001',
-});
-
-socket.emit('typing', true)
-
-setTimeout(() => {
-	socket.emit('typing', false)
-	socket.emit('theMessage', 'hi there!', (data) =>{
-		console.log('you sure?', data)
-	})
-}, 10000)
-
-socket.on('gotIt', (message) => {
-	console.log('Server got it yey', message)
-})
-```
+On user defined listeners, the listener receives three things as sent by the client: `socket`, `data` and a `callback`; Example `class FancyChat { async typing(socket, data, callback) {console.log(socket, data);}}`.
 
 #### Syntax For Listeners
 
 Listeners have the following alternative syntax if you feel like
 
+<details>
+<summary><b>Expand</b></summary>
+
 ```javascript
 // server.js (node.js)
 import Server from 'angelia.io/server'
@@ -290,12 +244,14 @@ Server.on('connect', function fancyConnect(socket, request) {
 	onsole.log('connect in named function')
 })
 
-const server = new Server.listen({
+Server.listen({
 	port: 3001,
 })
 ```
 
-### Predefined Events
+</details>
+
+### Predefined `Server` Events
 
 There's a bunch of handy predefined events dispatched whenever you add listeners for them.
 
@@ -315,12 +271,15 @@ class _ {
 
 Server.on(_);
 
-const server = new Server.listen({
+Server.listen({
 	port: 3001,
 });
 ```
 
-#### List of Predefined Events
+#### List of Predefined `Server` Events
+
+<details>
+<summary><b>Expand</b></summary>
 
 | signature                           | description                                                                               |
 | ----------------------------------- | ----------------------------------------------------------------------------------------- |
@@ -341,16 +300,20 @@ const server = new Server.listen({
 | `events`  | reference to event dispatcher, ex: `this.events.typing()` will dispatch the `typing` event to anyone listening to it |
 | `classes` | reference to all functions that have been attached as listeners , ex: `this.classes.MyFancyChat.typing`              |
 
+</details>
+
 ## Client API (Browser)
 
-### Options
+### `Client` Options
 
 Configurable options used by the constructor
 
 ```javascript
 const socket = new Client({
 	url: 'ws://localhost:3001',
-	params: function (){ return { fast: 'data', test: 'a space' })
+	params: function () {
+		return { fast: 'data', test: 'a space' }
+	},
 })
 ```
 
@@ -359,6 +322,7 @@ const socket = new Client({
 | `url`           | string   | 'ws(s)://\${window.location.hostname}:3001' | url of the socket server, example 'ws://localhost:3001'                                                                                                                   |
 | `params`        | Function | {}                                          | to send data while connecting, accesible via `socket.params` server side                                                                                                  |
 | `longLiveFlash` | boolean  | false                                       | browsers throw when calling swf functions via ExternalInterface after events like WebSocket.onmesssage; setting this to `true` fix it by dispatching them in a setTimeout |
+| `dontConnect`   | Boolean  | false                                       | allows to instance the socket without connecting                                                                                                                          |
 
 You may also do like this if you don't need any option
 
@@ -366,10 +330,13 @@ You may also do like this if you don't need any option
 const socket = new Client('ws://localhost:3001')
 ```
 
-### API
+### `Client` API
 
 The client API is similar to regular event handling
 
+<details>
+<summary><b>Expand</b></summary>
+
 | signature                      | kind     | description                                                        |
 | ------------------------------ | -------- | ------------------------------------------------------------------ |
 | `connected`                    | Boolean  | `true` when the socket is connected else `false`                   |
@@ -380,15 +347,23 @@ The client API is similar to regular event handling
 | `emit(key, [value, callback])` | Function | emits data to the server                                           |
 | `decode(data)`                 | Function | for decoding binary data, returns a promise                        |
 
-#### List of Predefined Events
+</details>
+
+#### List of Predefined `Client` Events
 
 As in `socket.on('connect', () => console.log('connect happened!'))`
 
+<details>
+<summary><b>Expand</b></summary>
+
 | signature    | description                                                                                             |
 | ------------ | ------------------------------------------------------------------------------------------------------- |
 | `connect`    | **this happens only once** when we connect to the server, any future connection is a `reconnect`        |
 | `reconnect`  | if we were connected at least once, then any reconnection will dispatch this event instead of `connect` |
 | `disconnect` | when we disconnect from the server                                                                      |
+|              |
+
+</details>
 
 ## Authors
 

package/server/Server.js

@@ -141,7 +141,11 @@ class ServerSingleton {
 			process.on(m, () => {
 				if (!io.closing) {
 					io.closing = true
-					console.log('Server Shutting Down\n', this)
+					if (options.debug) {
+						console.log('Server Shutting Down\n', this)
+					} else {
+						console.log('Server Shutting Down\n')
+					}
 					io.close()
 					if (options.debug) {
 						process.exit()
@@ -150,7 +154,7 @@ class ServerSingleton {
 			})
 		}
 
-		console.log('Server Started Listening On Port ' + this.port)
+		console.log('Socket Server Started Listening On Port ', this.port)
 		this.events.listen && this.events.listen()
 
 		return this

package/server/rooms/Manager.js

@@ -103,7 +103,7 @@ class ManagerSingleton {
 	}
 
 	[Symbol.iterator]() {
-		return this.rooms
+		return this.rooms[Symbol.iterator]()
 	}
 }
 

package/server/rooms/Room.js

@@ -1,90 +1,100 @@
 'use strict'
 
-const { join, leave, parent } = require('./constants.js')
+const { join, leave, parent, add, remove } = require('./constants.js')
 
 class Room {
 	constructor() {
-		this.users = []
+		this.sockets = new Set()
 	}
 	has(socket) {
-		return this.users.indexOf(socket) !== -1
+		return this.sockets.has(socket)
 	}
+	get size() {
+		return this.sockets.size
+	}
+	// private
 	[join](roomList, socket) {
 		// add to list of room list
 		if (!this[parent]) {
 			this[parent] = roomList
-			this[parent].add(this)
+			this[parent][add](this)
 		}
 
 		// add user
-		this.users.push(socket)
+		this.sockets.add(socket)
 
-		// to be able to list rooms for socket
+		// to be able to list rooms for a socket
 		socket.rooms.add(this)
 
-		if (this.users.length === 1) {
+		// if the room has the property "persistent"
+		// then maybe the room is old and someone just joined
+		// for this reason we dont dispatch onCreate for persistent rooms
+		// as that would be misleading
+		if (!this.persistent && this.sockets.size === 1) {
 			// dispatch create
-			this.create && this.create(socket)
+			this.onCreate && this.onCreate(socket)
 		}
 
 		// dispatch join
-		this.join && this.join(socket)
+		this.onJoin && this.onJoin(socket)
 	}
 	[leave](socket) {
 		// remove user
-		let index = this.users.indexOf(socket)
-		if (index !== -1) this.users.splice(index, 1)
+		this.sockets.delete(socket)
 
 		// to be able to list rooms for socket
 		socket.rooms.delete(this)
 
-		// check removal
-		if (this.users.length === 0 && !this.persistent) {
+		// check room deletion
+		if (!this.persistent && this.sockets.size === 0) {
 			// remove room from list
-			this[parent].delete(this)
+			this[parent][remove](this)
 
 			// dispatch leave
-			this.leave && this.leave(socket)
+			this.onLeave && this.onLeave(socket)
 
 			// dispatch that the room has been deleted
-			this.delete && this.delete(socket)
+			this.onDelete && this.onDelete(socket)
 		} else {
 			// dispatch leave
-			this.leave && this.leave(socket)
+			this.onLeave && this.onLeave(socket)
 		}
 	}
 
 	emit(k, v) {
 		let d = [k, v]
 
-		for (let socket of this.users) {
+		for (let socket of this.sockets) {
 			socket.emit(d)
 		}
 	}
 	once(k, v) {
 		let d = [k, v]
 
-		for (let socket of this.users) {
+		for (let socket of this.sockets) {
 			socket.once(d)
 		}
 	}
 	broadcast(me, k, v) {
 		let d = [k, v]
 
-		for (let socket of this.users) {
+		for (let socket of this.sockets) {
 			if (me != socket) socket.emit(d)
 		}
 	}
 	broadcastOnce(me, k, v) {
 		let d = [k, v]
 
-		for (let socket of this.users) {
+		for (let socket of this.sockets) {
 			if (me != socket) socket.once(d)
 		}
 	}
 
+	toJSON() {
+		return this.sockets
+	}
 	[Symbol.iterator]() {
-		return this.users
+		return this.sockets[Symbol.iterator]()
 	}
 }
 

package/server/rooms/Rooms.js

@@ -1,85 +1,39 @@
 'use strict'
 
-const { parent } = require('./constants.js')
+const { add, remove } = require('./constants.js')
 
 class Rooms {
 	constructor(path) {
 		Object.assign(this, {
 			path: path,
-			rooms: [],
+			rooms: new Set(),
 			roomsById: new Map(),
 		})
 	}
 
-	has(room) {
-		return this.rooms.indexOf(room) !== -1
-	}
-
 	get(id) {
 		return this.roomsById.get(id)
 	}
-
-	add(room) {
-		if (!this.has(room)) {
-			this.rooms.push(room)
-			this.roomsById.set(room.id, room)
-		}
-	}
-	delete(room) {
-		if (!room.persistent) {
-			let index = this.rooms.indexOf(room)
-			if (index !== -1) this.rooms.splice(index, 1)
-			this.roomsById.delete(room.id)
-		}
-	}
-
-	emit(k, v) {
-		let d = [k, v]
-
-		for (let room of this.rooms) {
-			for (let socket of room.users) {
-				socket.emit(d)
-			}
-		}
-	}
-	once(k, v) {
-		let d = [k, v]
-
-		for (let room of this.rooms) {
-			for (let socket of room.users) {
-				socket.once(d)
-			}
-		}
+	get size() {
+		return this.rooms.size
 	}
-	broadcast(me, k, v) {
-		let d = [k, v]
-
-		for (let room of this.rooms) {
-			for (let socket of room.users) {
-				if (me != socket) {
-					socket.emit(d)
-				}
-			}
+	// private
+	[add](room) {
+		if (!this.rooms.has(room)) {
+			this.rooms.add(room)
+			this.roomsById.set(room.id, room)
 		}
 	}
-	broadcastOnce(me, k, v) {
-		let d = [k, v]
-
-		for (let room of this.rooms) {
-			for (let socket of room.users) {
-				if (me != socket) {
-					socket.once(d)
-				}
-			}
-		}
+	[remove](room) {
+		this.rooms.delete(room)
+		this.roomsById.delete(room.id)
 	}
 
 	toJSON() {
 		return this.rooms
 	}
-
 	[Symbol.iterator]() {
-		return this.rooms
+		return this.rooms[Symbol.iterator]()
 	}
 }
 

package/server/rooms/constants.js

@@ -2,8 +2,16 @@ const join = Symbol.for('Room.join')
 const leave = Symbol.for('Room.leave')
 const parent = Symbol.for('Room.parent')
 
+const add = Symbol.for('Rooms.add')
+const remove = Symbol.for('Rooms.remove')
+
 module.exports = {
+	// Room
 	join,
 	leave,
 	parent,
+
+	// Rooms
+	add,
+	remove,
 }