serverless-ircd 0.6.0 → 0.7.0

package/apps/web/upstream/src/libs/state/NetworkState.js

@@ -0,0 +1,158 @@
+/** @module */
+
+import Vue from 'vue';
+import { def } from './common';
+import * as IrcClient from '../IrcClient';
+
+/** The IRC network instance */
+export default class NetworkState {
+    constructor(id, appState, userDict, bufferDict) {
+        // Enumerable properties that become reactive under Vue
+        this.id = id;
+        this.name = '';
+        this.editable_name = false;
+        // State of the transport
+        this.state = 'disconnected';
+        this.state_error = '';
+        // Last error from the IRC server. Resets on reconnect
+        this.last_error = '';
+        this.auto_commands = '';
+        this.is_znc = false;
+        this.is_bnc = false;
+        this.hidden = false;
+        this.channel_list = [];
+        this.channel_list_state = '';
+        // The IRCd type as mentioned in the 002 numeric
+        this.ircd = '';
+        this.connection = {
+            server: '',
+            port: 6667,
+            tls: false,
+            path: '',
+            // Server password
+            password: '',
+            direct: false,
+            encoding: 'utf8',
+            bncnetid: '',
+            nick: '',
+        };
+        this.settings = {
+            show_raw_caps: false,
+        };
+        this.nick = '';
+        this.username = '';
+        this.gecos = '';
+        // SASL password
+        this.account = {
+            account: '',
+            password: '',
+        };
+        this.password = '';
+        this.away = '';
+
+        Vue.observable(this);
+
+        // Some non-enumerable properties (vues $watch won't cover these properties)
+        def(this, 'appState', appState, false);
+        def(this, 'userDict', userDict, false);
+        def(this, 'bufferDict', bufferDict, false);
+        def(this, 'frameworkClient', null, true);
+
+        def(this, 'users', Object.create(null), (newVal) => {
+            appState.$set(userDict.networks, this.id, newVal);
+        });
+
+        // Pending prviate messages awaiting whois operator check
+        def(this, 'pendingPms', [], false);
+
+        bufferDict.$set(bufferDict.networks, this.id, []);
+    }
+
+    get ircClient() {
+        if (!this.frameworkClient) {
+            this.frameworkClient = IrcClient.create(this.appState, this);
+        }
+
+        return this.frameworkClient;
+    }
+
+    get buffers() {
+        return this.bufferDict.networks[this.id];
+    }
+
+    connect(...args) {
+        this.ircClient.connect(...args);
+    }
+
+    bufferByName(name) {
+        return this.appState.getBufferByName(this.id, name);
+    }
+
+    serverBuffer() {
+        return this.appState.getBufferByName(this.id, '*');
+    }
+
+    setting(name, val) {
+        if (typeof val !== 'undefined') {
+            this.appState.$set(this.settings, name, val);
+            return val;
+        }
+
+        return this.settings[name];
+    }
+
+    isChannelName(input) {
+        if (typeof input !== 'string' || !input) {
+            return false;
+        }
+
+        let chanPrefixes = this.ircClient.network.supports('CHANTYPES') || '#&';
+        return chanPrefixes.indexOf(input[0]) > -1;
+    }
+
+    showServerBuffer(tabName) {
+        this.appState.$emit('active.component', null);
+        this.appState.setActiveBuffer(this.id, this.serverBuffer().name);
+        // Hacky, but the server buffer component listens for events to switch
+        // between tabs
+        setImmediate(() => {
+            this.appState.$emit('server.tab.show', tabName || 'settings');
+        });
+    }
+
+    /**
+     * Check if a nick is exempt from block PM's
+     * @param {String} nick of the user to check
+     * @returns {Boolean} If the boolean is null a whois check is required
+     */
+    isNickExemptFromPmBlocks(nick) {
+        // Check if nick is op of shared channel
+        let buffers = this.appState.getBuffersWithUser(this.id, nick);
+        for (let i = 0; i < buffers.length; i++) {
+            let buffer = buffers[i];
+            if (buffer.isUserAnOp(nick)) {
+                return true;
+            }
+        }
+
+        let user = this.appState.getUser(this.id, nick);
+        if (!user || !user.hasWhois) {
+            // if we have not seen or whois the user they might be a network oper
+            // so return null then a whois can be performed
+            return null;
+        }
+
+        if (user.operator) {
+            return true;
+        }
+        return false;
+    }
+
+    currentUser() {
+        return this.appState.getUser(this.id, this.nick);
+    }
+
+    userByName(nick) {
+        return this.appState.getUser(this.id, nick);
+    }
+}

package/apps/web/upstream/src/libs/state/UserState.js

@@ -0,0 +1,89 @@
+/** @module */
+
+import Vue from 'vue';
+import * as TextFormatting from '@/helpers/TextFormatting';
+import { def } from './common';
+
+export default class UserState {
+    constructor(user) {
+        this.key = user.nick.toUpperCase();
+        this.nick = user.nick;
+        this.host = user.host || '';
+        this.username = user.username || '';
+        this.realname = user.realname || '';
+        this.modes = user.modes || '';
+        this.away = user.away || '';
+        this.colour = user.colour || '';
+        this.account = user.account || '';
+        this.buffers = Object.create(null);
+        this.hasWhois = false;
+        this.typingState = Object.create(null);
+        this.avatar = user.avatar || { small: '', large: '' };
+        this.ignore = false;
+
+        Vue.observable(this);
+
+        // Whois details are non-enumerable properties (vues $watch won't cover these properties)
+        def(this, 'actual_host', '', true);
+        def(this, 'helpop', '', true);
+        def(this, 'bot', '', true);
+        def(this, 'server', '', true);
+        def(this, 'server_info', '', true);
+        def(this, 'operator', '', true);
+        def(this, 'channels', '', true);
+        def(this, 'modes', '', true);
+        def(this, 'idle', '', true);
+        def(this, 'logon', '', true);
+        def(this, 'registered_nick', '', true);
+        def(this, 'secure', '', true);
+        def(this, 'special', '', true);
+    }
+
+    getColour() {
+        if (!this.colour) {
+            this.colour = TextFormatting.createNickColour(this.nick);
+        }
+        // default will use the themes default text colour
+        return this.colour === 'default' ? '' : this.colour;
+    }
+
+    isAway() {
+        return !!this.away;
+    }
+
+    typingStatus(_target, status) {
+        let target = _target.toUpperCase();
+        if (!status) {
+            return this.typingState[target] || { status: '' };
+        }
+
+        let typing = this.typingState[target];
+        if (!typing) {
+            Vue.set(this.typingState, target, { started: 0, status: '' });
+            typing = this.typingState[target];
+        }
+
+        if (typing.timeout) {
+            clearTimeout(typing.timeout);
+            typing.timeout = null;
+        }
+
+        if (status === 'done') {
+            Vue.delete(this.typingState, target);
+            return null;
+        }
+
+        typing.started = Date.now();
+        typing.status = status;
+
+        // Paused state gets a longer timeout as it's usually someone stopping typing
+        // to think about their words
+        let timeoutLen = status === 'paused' ?
+            30000 :
+            6000;
+
+        typing.timeout = setTimeout(() => this.typingStatus(target, 'done'), timeoutLen);
+
+        return typing;
+    }
+}

package/apps/web/upstream/src/libs/state/common.js

@@ -0,0 +1,26 @@
+// Define a non-enumerable property on an object with an optional setter callback
+export function def(target, key, value, canSet) {
+    let val = value;
+
+    let definition = {
+        get() {
+            return val;
+        },
+    };
+
+    if (canSet) {
+        definition.set = function set(newVal) {
+            let oldVal = val;
+            val = newVal;
+            if (typeof canSet === 'function') {
+                canSet(newVal, oldVal);
+            }
+        };
+    }
+
+    Object.defineProperty(target, key, definition);
+
+    if (typeof canSet === 'function') {
+        canSet(val);
+    }
+}