angelia.io 2.4.70 → 2.4.71

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "angelia.io",
-	"version": "2.4.70",
+	"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/rooms/Room.js

@@ -9,6 +9,10 @@ class Room {
 	has(socket) {
 		return this.sockets.has(socket)
 	}
+	get size() {
+		return this.sockets.size
+	}
+	// private
 	[join](roomList, socket) {
 		// add to list of room list
 		if (!this[parent]) {

package/server/rooms/Rooms.js

@@ -14,7 +14,9 @@ class Rooms {
 	get(id) {
 		return this.roomsById.get(id)
 	}
-
+	get size() {
+		return this.rooms.size
+	}
 	// private
 	[add](room) {
 		if (!this.rooms.has(room)) {