Merge remote-tracking branch 'origin/master'

Author: mattkrick

README.md

@@ -30,7 +30,7 @@ function reducer(state, action) {
   }
 }
 ```
-This initial state object is an immutable.js Map that looks like this:
+This initial state object is an Object that looks like this:
 
 ```
   id: null,
@@ -39,15 +39,15 @@ This initial state object is an immutable.js Map that looks like this:
   authToken: null,
   authError: null,
   error: null,
-  pendingSubs: List(),
-  subs: List()
+  pendingSubs: [],
+  subs: []
 ```
-###`reduxSocket(socketClusterOptions, hocOptions)` - a HOC to put on your highest level real-time component.
+###`reduxSocket(options, hocOptions)` - a HOC to put on your highest level real-time component.
 eg `@reduxSocket({authTokenName: 'MyApp.token'}, {keepAlive: 60000})`
 
 For example, if you use websockets for everything, stick this on the main `app`.
 If only certain components have websockets, stick this on those containers.
-The `socketClusterOptions` are identical to the options you'd pass in to the client socketCluster 
+The `options` are identical to what you'd pass in to the client socketCluster
 (http://socketcluster.io/#!/docs/api-socketcluster-client).
 
 `hocOptions` has the following properties:
@@ -57,9 +57,9 @@ Say the client subs to 1000 items & accidently clicks a link that unmounts the c
 if they make it back to the component before the time expires, you won't have to start a new connection or resend
 those 1000 documents. Plus, any docs that came in while they were away will be there too. Neat!
 - `AuthEngine`: a class that takes in a redux `store` and creates a socket cluster `AuthEngine`.
-- `onConnect(socket)`: a callback that returns an active socket when a connection has been established.
+- `onConnect(options, hocOptions, socket)`: a callback that returns an active socket when a connection has been established.
 Useful if you want to do something like upgrade a transport from HTTP to sockets
-- `onDisconnect(timedOut, socket)`: a callback that returns a Boolean that is true due to `keepAlive` expiring
+- `onDisconnect(timedOut, options, hocOptions, socket)`: a callback that returns a Boolean that is true due to `keepAlive` expiring
 and the now inactive socket.
 Similar to above, this is useful if you want to downgrade something from a socket transport to HTTP.
 

package.json

@@ -48,10 +48,11 @@
     "redux": "^3.5.2",
     "rimraf": "^2.5.2"
   },
+  "peerDependencies": {
+    "socketcluster-client": "^4.3.19"
+  },
   "dependencies": {
     "es6-promisify": "^4.1.0",
-    "immutable": "^3.8.1",
-    "react": "^15.1.0",
-    "socketcluster-client": "^4.3.19"
+    "react": "^15.1.0"
   }
 }

src/index.js

@@ -1,11 +1,14 @@
-// For now, socketcluster-client is a devDep because of https://github.com/npm/npm/issues/3081
-import socketCluster from 'socketcluster-client';
 import React, {Component} from 'react';
 import promisify from 'es6-promisify';
-import {Map, List} from 'immutable';
 
 // constants
-const {CLOSED, CONNECTING, OPEN, AUTHENTICATED, PENDING, UNAUTHENTICATED} = socketCluster.SCSocket;
+const CLOSED = 'closed';
+const CONNECTING = 'connecting';
+const OPEN = 'open';
+const AUTHENTICATED = 'authenticated';
+const PENDING = 'pending';
+const UNAUTHENTICATED = 'unauthenticated';
+
 const CONNECT_REQUEST = '@@socketCluster/CONNECT_REQUEST';
 const CONNECT_SUCCESS = '@@socketCluster/CONNECT_SUCCESS';
 const CONNECT_ERROR = '@@socketCluster/CONNECT_ERROR';
@@ -21,78 +24,90 @@ const DISCONNECT = '@@socketCluster/DISCONNECT';
 const DEAUTHENTICATE = '@@socketCluster/DEAUTHENTICATE';
 
 // Reducer
-const initialState = Map({
+const initialState = {
   id: null,
   socketState: CLOSED,
   authState: PENDING,
   authToken: null,
   authError: null,
   error: null,
-  pendingSubs: List(),
-  subs: List()
-});
+  pendingSubs: [],
+  subs: []
+};
 
 export const socketClusterReducer = function (state = initialState, action) {
   switch (action.type) {
     case DEAUTHENTICATE:
-      return state.merge({
+      return {
+        ...state,
         authState: UNAUTHENTICATED,
         authToken: null
-      });
+      };
     case DISCONNECT:
       return initialState;
     case CONNECT_REQUEST:
-      return state.merge({
+      return {
+        ...state,
         socketState: CONNECTING
-      });
+      };
     case CONNECT_ERROR:
-      return state.merge({
+      return {
+        ...state,
         error: action.error
-      });
+      };
     case CONNECT_SUCCESS:
-      return state.merge({
+      return {
+        ...state,
         id: action.payload.id,
         socketState: action.payload.socketState,
         authState: action.payload.authState,
         error: action.error
-      });
+      };
     case AUTH_REQUEST:
-      return state.merge({
+      return {
+        ...state,
         authState: PENDING
-      });
+      };
     case AUTH_SUCCESS:
-      return state.merge({
+      return {
+        ...state,
         authState: AUTHENTICATED,
         authToken: action.payload.authToken
-      });
+      };
     case AUTH_ERROR:
-      return state.merge({
+      return {
+        ...state,
         authState: UNAUTHENTICATED,
         authError: action.error
-      });
+      };
     case SUBSCRIBE_REQUEST:
-      return state.merge({
-        pendingSubs: state.get('pendingSubs').push(action.payload.channelName)
-      });
+      return {
+        ...state,
+        pendingSubs: state.pendingSubs.concat(action.payload.channelName)
+      };
     case SUBSCRIBE_SUCCESS:
-      return state.merge({
-        pendingSubs: state.get('pendingSubs').filter(sub => sub !== action.payload.channelName),
-        subs: state.get('subs').push(action.payload.channelName)
-      });
+      return {
+        ...state,
+        pendingSubs: state.pendingSubs.filter(sub => sub !== action.payload.channelName),
+        subs: state.subs.concat(action.payload.channelName)
+      };
     case SUBSCRIBE_ERROR:
-      return state.merge({
-        pendingSubs: state.get('pendingSubs').filter(sub => sub !== action.payload.channelName),
+      return {
+        ...state,
+        pendingSubs: state.pendingSubs.filter(sub => sub !== action.payload.channelName),
         error: action.error
-      });
+      };
     case UNSUBSCRIBE:
-      return state.merge({
-        subs: state.get('subs').filter(sub => sub !== action.payload.channelName),
+      return {
+        ...state,
+        subs: state.subs.filter(sub => sub !== action.payload.channelName),
         error: action.error
-      });
+      };
     case KICKOUT:
-      return state.merge({
+      return {
+        ...state,
         error: action.error
-      });
+      };
     default:
       return state;
   }
@@ -127,13 +142,13 @@ export const reduxSocket = (options, hocOptions) => ComposedComponent =>
         this.handleError();
         this.handleSubs();
         this.handleAuth();
+        const {onConnect} = this.hocOptions;
+        if (onConnect) {
+          onConnect(this.options, this.hocOptions, this.socket);
+        }
         return;
       }
       clearTimeout(this.socket.__destructionCountdown);
-      const {onConnect} = this.hocOptions;
-      if (onConnect) {
-        onConnect(this.socket);
-      }
     }
 
     componentWillUnmount() {
@@ -142,7 +157,7 @@ export const reduxSocket = (options, hocOptions) => ComposedComponent =>
         this.socket = this.socketCluster.destroy(options);
         const {onDisconnect} = this.hocOptions;
         if (onDisconnect) {
-          onDisconnect(true, this.socket);
+          onDisconnect(true, this.options, this.hocOptions, this.socket);
         }
       }, this.hocOptions.keepAlive);
     }
@@ -161,6 +176,9 @@ export const reduxSocket = (options, hocOptions) => ComposedComponent =>
           dispatch({type: SUBSCRIBE_REQUEST, payload: {channelName}});
         }
       });
+      socket.on('subscribeRequest', channelName => {
+        dispatch({type: SUBSCRIBE_REQUEST, payload: {channelName}});
+      });
       socket.on('subscribe', channelName => {
         dispatch({type: SUBSCRIBE_SUCCESS, payload: {channelName}});
       });
@@ -212,7 +230,7 @@ export const reduxSocket = (options, hocOptions) => ComposedComponent =>
         const {onDisconnect} = this.hocOptions;
         if (onDisconnect) {
           // did not time out, so first param is false
-          onDisconnect(false, this.socket);
+          onDisconnect(false, this.options, this.hocOptions, this.socket);
         }
       });
       // triggers while in connecting state