Switch to redux and webpack

client/src/js/actions/channel.js

@@ -1,36 +1,55 @@
-var Reflux = require('reflux');
+import * as actions from '../actions';
+import { updateSelection } from './tab';
 
-var socket = require('../socket');
+export function join(channels, server) {
+  return {
+    type: actions.JOIN,
+    channels,
+    server,
+    socket: {
+      type: 'join',
+      data: { channels, server }
+    }
+  };
+}
 
-var channelActions = Reflux.createActions([
-	'join',
-	'part',
-	'invite',
-	'kick',
-	'addUser',
-	'removeUser',
-	'removeUserAll',
-	'renameUser',
-	'setUsers',
-	'setTopic',
-	'setMode',
-	'load'
-]);
+export function part(channels, server) {
+  return dispatch => {
+    dispatch({
+      type: actions.PART,
+      channels,
+      server,
+      socket: {
+        type: 'part',
+        data: { channels, server }
+      }
+    });
+    dispatch(updateSelection());
+  };
+}
 
-channelActions.join.preEmit = (channels, server) => {
-	socket.send('join', { server, channels });
-};
+export function invite(user, channel, server) {
+  return {
+    type: actions.INVITE,
+    user,
+    channel,
+    server,
+    socket: {
+      type: 'invite',
+      data: { user, channel, server }
+    }
+  };
+}
 
-channelActions.part.preEmit = (channels, server) => {
-	socket.send('part', { server, channels });
-};
-
-channelActions.invite.preEmit = (user, channel, server) => {
-	socket.send('invite', { server, channel, user });
-};
-
-channelActions.kick.preEmit = (user, channel, server) => {
-	socket.send('kick', { server, channel, user });
-};
-
-module.exports = channelActions;
+export function kick(user, channel, server) {
+  return {
+    type: actions.KICK,
+    user,
+    channel,
+    server,
+    socket: {
+      type: 'kick',
+      data: { user, channel, server }
+    }
+  };
+}

client/src/js/actions/environment.js

@@ -0,0 +1,17 @@
+import * as actions from '../actions';
+
+export function setEnvironment(key, value) {
+  return {
+    type: actions.SET_ENVIRONMENT,
+    key,
+    value
+  };
+}
+
+export function setWrapWidth(width) {
+  return setEnvironment('wrapWidth', width);
+}
+
+export function setCharWidth(width) {
+  return setEnvironment('charWidth', width);
+}

client/src/js/actions/inputHistory.js

@@ -1,10 +1,26 @@
-var Reflux = require('reflux');
+import * as actions from '../actions';
 
-var inputHistoryActions = Reflux.createActions([
-	'add',
-	'reset',
-	'increment',
-	'decrement'
-]);
+export function addInputHistory(line) {
+  return {
+    type: actions.INPUT_HISTORY_ADD,
+    line
+  };
+}
 
-module.exports = inputHistoryActions;
+export function resetInputHistory() {
+  return {
+    type: actions.INPUT_HISTORY_RESET
+  };
+}
+
+export function incrementInputHistory() {
+  return {
+    type: actions.INPUT_HISTORY_INCREMENT
+  };
+}
+
+export function decrementInputHistory() {
+  return {
+    type: actions.INPUT_HISTORY_DECREMENT
+  };
+}

client/src/js/actions/message.js

@@ -1,19 +1,77 @@
-var Reflux = require('reflux');
+import * as actions from '../actions';
 
-var socket = require('../socket');
+export function sendMessage(message, to, server) {
+  return (dispatch, getState) => {
+    return dispatch({
+      type: actions.SEND_MESSAGE,
+      from: getState().servers.getIn([server, 'nick']),
+      message,
+      to,
+      server,
+      time: new Date(),
+      socket: {
+        type: 'chat',
+        data: { message, to, server }
+      }
+    });
+  };
+}
 
-var messageActions = Reflux.createActions([
-	'send',
-	'add',
-	'addAll',
-	'broadcast',
-	'inform',
-	'command',
-	'setWrapWidth'
-]);
+export function addMessage(message) {
+  message.time = new Date();
 
-messageActions.send.preEmit = (message, to, server) => {
-	socket.send('chat', { server, to, message });
-};
+  return {
+    type: actions.ADD_MESSAGE,
+    message
+  };
+}
 
-module.exports = messageActions;
+export function addMessages(messages) {
+  const now = new Date();
+  messages.forEach(message => message.time = now);
+
+  return {
+    type: actions.ADD_MESSAGES,
+    messages
+  };
+}
+
+export function broadcast(message, server, channels) {
+  return addMessages(channels.map(channel => {
+    return {
+      server,
+      to: channel,
+      message,
+      type: 'info'
+    };
+  }));
+}
+
+export function inform(message, server, channel) {
+  if (Array.isArray(message)) {
+    return addMessages(message.map(msg => {
+      return {
+        server,
+        to: channel,
+        message: msg,
+        type: 'info'
+      };
+    }));
+  }
+
+  return addMessage({
+    server,
+    to: channel,
+    message,
+    type: 'info'
+  });
+}
+
+export function runCommand(command, channel, server) {
+  return {
+    type: actions.COMMAND,
+    command,
+    channel,
+    server
+  };
+}

client/src/js/actions/privateChat.js

@@ -1,8 +1,21 @@
-var Reflux = require('reflux');
+import * as actions from '../actions';
+import { updateSelection } from './tab';
 
-var privateChatActions = Reflux.createActions([
-	'open',
-	'close'
-]);
+export function openPrivateChat(server, nick) {
+  return {
+    type: actions.OPEN_PRIVATE_CHAT,
+    server,
+    nick
+  };
+}
 
-module.exports = privateChatActions;
+export function closePrivateChat(server, nick) {
+  return dispatch => {
+    dispatch({
+      type: actions.CLOSE_PRIVATE_CHAT,
+      server,
+      nick
+    });
+    dispatch(updateSelection());
+  };
+}

client/src/js/actions/route.js

@@ -1,7 +0,0 @@
-var Reflux = require('reflux');
-
-var routeActions = Reflux.createActions([
-	'navigate'
-]);
-
-module.exports = routeActions;

client/src/js/actions/search.js

@@ -1,15 +1,20 @@
-var Reflux = require('reflux');
+import * as actions from '../actions';
 
-var socket = require('../socket');
+export function searchMessages(server, channel, phrase) {
+  return {
+    type: actions.SEARCH_MESSAGES,
+    server,
+    channel,
+    phrase,
+    socket: {
+      type: 'search',
+      data: { server, channel, phrase }
+    }
+  };
+}
 
-var searchActions = Reflux.createActions([
-	'search',
-	'searchDone',
-	'toggle'
-]);
-
-searchActions.search.preEmit = (server, channel, phrase) => {
-	socket.send('search', { server, channel, phrase });
-};
-
-module.exports = searchActions;
+export function toggleSearch() {
+  return {
+    type: actions.TOGGLE_SEARCH
+  };
+}

client/src/js/actions/server.js

@@ -1,45 +1,76 @@
-var Reflux = require('reflux');
+import * as actions from '../actions';
+import { updateSelection } from './tab';
 
-var socket = require('../socket');
+export function connect(server, nick, options) {
+  return {
+    type: actions.CONNECT,
+    server,
+    nick,
+    options,
+    socket: {
+      type: 'connect',
+      data: {
+        server,
+        nick,
+        username: options.username || nick,
+        password: options.password,
+        realname: options.realname || nick,
+        tls: options.tls || false,
+        name: options.name || server
+      }
+    }
+  };
+}
 
-var serverActions = Reflux.createActions([
-	'connect',
-	'disconnect',
-	'whois',
-	'away',
-	'setNick',
-	'load'
-]);
+export function disconnect(server) {
+  return dispatch => {
+    dispatch({
+      type: actions.DISCONNECT,
+      server,
+      socket: {
+        type: 'quit',
+        data: { server }
+      }
+    });
+    dispatch(updateSelection());
+  };
+}
 
-serverActions.connect.preEmit = (server, nick, opts) => {
-	socket.send('connect', {
-		server,
-		nick,
-		username: opts.username || nick,
-		password: opts.password,
-		realname: opts.realname || nick,
-		tls: opts.tls || false,
-		name: opts.name || server
-	});
-};
+export function whois(user, server) {
+  return {
+    type: actions.WHOIS,
+    user,
+    server,
+    socket: {
+      type: 'whois',
+      data: { user, server }
+    }
+  };
+}
 
-serverActions.disconnect.preEmit = (server) => {
-	socket.send('quit', { server });
-};
+export function away(message, server) {
+  return {
+    type: actions.AWAY,
+    message,
+    server,
+    socket: {
+      type: 'away',
+      data: { message, server }
+    }
+  };
+}
 
-serverActions.whois.preEmit = (user, server) => {
-	socket.send('whois', { server, user });
-};
-
-serverActions.away.preEmit = (message, server) => {
-	socket.send('away', { server, message });
-};
-
-serverActions.setNick.preEmit = (nick, server) => {
-	socket.send('nick', {
-		server,
-		new: nick
-	});
-};
-
-module.exports = serverActions;
+export function setNick(nick, server) {
+  return {
+    type: actions.SET_NICK,
+    nick,
+    server,
+    socket: {
+      type: 'nick',
+      data: {
+        new: nick,
+        server
+      }
+    }
+  };
+}

client/src/js/actions/tab.js

@@ -1,9 +1,60 @@
-var Reflux = require('reflux');
+import { pushPath } from 'redux-simple-router';
+import * as actions from '../actions';
 
-var tabActions = Reflux.createActions([
-	'select',
-	'hideMenu',
-	'toggleMenu'
-]);
+export function select(server, channel, pm) {
+  if (pm) {
+    return pushPath(`/${server}/pm/${channel}`);
+  } else if (channel) {
+    return pushPath(`/${server}/${encodeURIComponent(channel)}`);
+  }
 
-module.exports = tabActions;
+  return pushPath(`/${server}`);
+}
+
+export function updateSelection() {
+  return (dispatch, getState) => {
+    const state = getState();
+    const history = state.tab.history;
+    const { servers } = state;
+    const { server } = state.tab.selected;
+
+    if (servers.size === 0) {
+      dispatch(pushPath('/connect'));
+    } else if (history.size > 0) {
+      const tab = history.last();
+      dispatch(select(tab.server, tab.channel || tab.user, tab.user));
+    } else if (servers.has(server)) {
+      dispatch(select(server));
+    } else {
+      dispatch(pushPath('/'));
+    }
+  };
+}
+
+export function setSelectedChannel(server, channel = null) {
+  return {
+    type: actions.SELECT_TAB,
+    server,
+    channel
+  };
+}
+
+export function setSelectedUser(server, user = null) {
+  return {
+    type: actions.SELECT_TAB,
+    server,
+    user
+  };
+}
+
+export function hideMenu() {
+  return {
+    type: actions.HIDE_MENU
+  };
+}
+
+export function toggleMenu() {
+  return {
+    type: actions.TOGGLE_MENU
+  };
+}