serverless-ircd 0.5.0 → 0.7.0

package/apps/web/upstream/src/libs/SoundBleep.js

@@ -0,0 +1,20 @@
+export class SoundBleep {
+    constructor() {
+        this.audio = document.createElement('audio');
+        let source = document.createElement('source');
+
+        if (this.audio.canPlayType('audio/mpeg;')) {
+            source.type = 'audio/mpeg';
+            source.src = 'static/highlight.mp3';
+        } else {
+            source.type = 'audio/ogg';
+            source.src = 'static/highlight.ogg';
+        }
+
+        this.audio.appendChild(source);
+    }
+
+    play() {
+        this.audio.play();
+    }
+}

package/apps/web/upstream/src/libs/StatePersistence.js

@@ -0,0 +1,90 @@
+'kiwi public';
+
+import _ from 'lodash';
+
+export default class StatePersistence {
+    constructor(storageKey, state, storage, logger) {
+        this.storageKey = storageKey;
+        this.state = state;
+        this.storage = storage;
+        this.logger = logger;
+        this.isPersisting = false;
+        this.includeBuffers = true;
+        this.watcher = null;
+
+        this.state.persistence = this;
+    }
+
+    async loadStateIfExists() {
+        if (!this.storageKey) {
+            return;
+        }
+
+        // If we have networks from a previous state, launch directly into it
+        let storedState = await this.storage.get(this.storageKey);
+        if (storedState) {
+            if (this.logger) {
+                this.logger('Importing state', storedState);
+            }
+
+            this.state.importState(storedState);
+        }
+    }
+
+    stopWatchingState() {
+        if (this.watcher) {
+            this.watcher();
+            this.watcher = null;
+        }
+    }
+
+    watchStateForChanges() {
+        if (!this.storageKey) {
+            return;
+        }
+
+        // Throttle saving the state into storage so we don't thrash the disk
+        let debouncedSaveState = _.debounce(() => {
+            if (this.logger) {
+                this.logger('State updated, setting localStorage');
+            }
+
+            this.storage.set(this.storageKey, this.state.exportState(this.includeBuffers));
+        }, 1000);
+
+        this.state.$watch('networks', debouncedSaveState, { deep: true });
+        this.state.$watch('user_settings', debouncedSaveState, { deep: true });
+
+        // We need to touch each property of each buffer for that we want to save our state on.
+        // If any of the properties change then the $watch()er will call debouncedSaveState()
+        this.watcher = this.state.$watch(() => {
+            let watchVals = [];
+
+            this.state.networks.forEach((network) => {
+                let buffersVals = [];
+                buffersVals.push(network.buffers.map((b) => b.name).join(','));
+
+                network.buffers.forEach((buffer) => {
+                    buffersVals.push([
+                        buffer.name,
+                        buffer.settings,
+                        buffer.joined,
+                        buffer.enabled,
+                        buffer.last_read,
+                    ]);
+                });
+
+                watchVals.push(buffersVals);
+            });
+
+            return JSON.stringify(watchVals);
+        }, debouncedSaveState);
+
+        this.isPersisting = true;
+    }
+
+    async forgetState() {
+        this.state.resetState();
+        await this.storage.set(this.storageKey, null);
+    }
+}

package/apps/web/upstream/src/libs/ThemeManager.js

@@ -0,0 +1,128 @@
+'kiwi public';
+
+import _ from 'lodash';
+
+let createdInstance = null;
+
+export default class ThemeManager {
+    constructor(state) {
+        this.state = state;
+        this.listenForIrcEvents();
+        this.varsEl = null;
+    }
+
+    themeVar(varName) {
+        if (!this.varsEl) {
+            this.varsEl = document.querySelector('.kiwi-wrap');
+        }
+
+        let styles = window.getComputedStyle(this.varsEl);
+        let v = styles.getPropertyValue('--kiwi-' + varName);
+        return (v || '').trim();
+    }
+
+    availableThemes() {
+        return this.state.settings.themes;
+    }
+
+    currentTheme() {
+        let state = this.state;
+        let currentThemeName = state.setting('theme');
+        currentThemeName = currentThemeName.toLowerCase();
+
+        let theme = _.find(state.settings.themes, (t) => {
+            let isMatch = t.name.toLowerCase() === currentThemeName;
+            return isMatch;
+        });
+
+        // If no theme was set, use the first one in our theme list
+        if (!theme) {
+            theme = state.settings.themes[0];
+        }
+
+        return theme;
+    }
+
+    setTheme(theme) {
+        let theTheme = null;
+
+        if (typeof theme === 'string') {
+            // Make sure this theme exists
+            theTheme = _.find(this.availableThemes(), (t) => {
+                let isMatch = t.name.toLowerCase() === theme.toLowerCase();
+                return isMatch;
+            });
+
+            if (!theTheme) {
+                return;
+            }
+        } else {
+            theTheme = theme;
+        }
+
+        this.state.setting('theme', theTheme.name);
+        this.state.$emit('theme.change');
+    }
+
+    reload() {
+        let theme = this.currentTheme();
+        if (!theme) {
+            return;
+        }
+
+        let url = theme.url;
+        if (url.indexOf('cb=') > -1) {
+            url = url.replace(/cb=[0-9]+/, () => 'cb=' + Date.now());
+        } else if (url.indexOf('?') > -1) {
+            url += '&cb=' + Date.now();
+        } else {
+            url += '?cb=' + Date.now();
+        }
+
+        theme.url = url;
+        this.state.$emit('theme.change');
+    }
+
+    static themeUrl(theme) {
+        let parts = theme.url.split('?');
+        let url = parts[0];
+        let qs = parts[1] || '';
+
+        if (url[url.length - 1] !== '/') {
+            url += '/';
+        }
+        return url + 'theme.css' + (qs ? '?' + qs : '');
+    }
+
+    setCustomThemeUrl(url) {
+        let theme = _.find(ThemeManager.instance().availableThemes(), {
+            name: 'custom',
+        });
+
+        if (theme) {
+            theme.url = url;
+        }
+
+        if (theme.name === 'custom') {
+            this.state.$emit('theme.change');
+        }
+    }
+
+    // When we get a CTCP 'kiwi theme reload' then reload our theme. Handy for theme devs
+    listenForIrcEvents() {
+        this.state.$on('irc.ctcp request', (event, network) => {
+            let ctcpType = (event.type || '').toLowerCase();
+            if (ctcpType === 'kiwi' && event.message.indexOf('theme reload') > -1) {
+                this.reload();
+            }
+        });
+    }
+}
+
+ThemeManager.instance = function instance(state) {
+    if (!createdInstance) {
+        createdInstance = new ThemeManager(state);
+    }
+
+    return createdInstance;
+};

package/apps/web/upstream/src/libs/TypingMiddleware.js

@@ -0,0 +1,105 @@
+'kiwi public';
+
+/** @module */
+
+/**
+ * Adds the +typing IRCv3 spec to irc-framework
+ */
+export default function typingMiddleware() {
+    return function middleware(client, rawEvents, parsedEvents) {
+        addFunctionsToClient(client);
+        rawEvents.use(theMiddleware);
+    };
+
+    function theMiddleware(command, message, rawLine, client, next) {
+        if (
+            !(command === 'TAGMSG' && message.tags['+typing']) &&
+            !(command === 'PRIVMSG' && message.nick)
+        ) {
+            next();
+            return;
+        }
+
+        // if we are params[0] then the target is the sender (direct message)
+        let target = (message.params[0].toLowerCase() === client.user.nick.toLowerCase()) ?
+            message.nick :
+            message.params[0];
+
+        // if its a privmsg without typing tag emit done
+        let status = message.tags['+typing'] || 'done';
+
+        client.emit('typing', {
+            target: target,
+            nick: message.nick,
+            ident: message.ident,
+            hostname: message.hostname,
+            status: status,
+        });
+
+        next();
+    }
+}
+
+function addFunctionsToClient(client) {
+    let typing = client.typing = {};
+    let activeTyping = Object.create(null);
+
+    function isEnabled() {
+        return client.network.cap.isEnabled('message-tags');
+    }
+
+    typing.start = function start(target) {
+        if (!isEnabled()) {
+            return;
+        }
+
+        let lastSentStatus = activeTyping[target.toLowerCase()];
+        if (lastSentStatus && lastSentStatus > Date.now() - 3000) {
+            return;
+        }
+
+        activeTyping[target.toLowerCase()] = Date.now();
+
+        let message = new client.Message('TAGMSG', target);
+        message.tags['+typing'] = 'active';
+        client.raw(message);
+    };
+
+    typing.pause = function pause(target) {
+        if (!isEnabled()) {
+            return;
+        }
+
+        if (!activeTyping[target.toLowerCase()]) {
+            // Did not start typing so cannot pause
+            return;
+        }
+
+        let message = new client.Message('TAGMSG', target);
+        message.tags['+typing'] = 'paused';
+        client.raw(message);
+    };
+
+    typing.stop = function stop(target, sendStop) {
+        if (!isEnabled()) {
+            return;
+        }
+
+        if (!activeTyping[target.toLowerCase()]) {
+            // Did not start typing so cannot stop
+            return;
+        }
+
+        delete activeTyping[target.toLowerCase()];
+
+        if (!sendStop) {
+            // Stop was called after a message was sent,
+            // only a cleanup of activeTyping is needed
+            return;
+        }
+
+        let message = new client.Message('TAGMSG', target);
+        message.tags['+typing'] = 'done';
+        client.raw(message);
+    };
+}

package/apps/web/upstream/src/libs/WindowTitle.js

@@ -0,0 +1,63 @@
+export default class WindowTitle {
+    constructor(state) {
+        this.state = state;
+        this.title = state.settings.windowTitle || '';
+        this.alert = false;
+
+        // Update the window title if we have one
+        if (state.settings.windowTitle) {
+            this.updateTitle();
+        }
+
+        state.$watch('settings.windowTitle', (newVal) => {
+            this.updateTitle(newVal);
+        });
+
+        state.$watch('ui.app_has_focus', (newVal) => {
+            if (newVal && this.alertTmr) {
+                this.stopAlert();
+            }
+        });
+
+        state.$on('notification.title', (enable) => {
+            if (enable) {
+                this.startAlert();
+            } else {
+                this.stopAlert();
+            }
+        });
+    }
+
+    startAlert() {
+        if (this.alertTmr) {
+            return;
+        }
+
+        this.alertTmr = setInterval(() => {
+            this.updateTitle();
+        }, 1000);
+    }
+
+    stopAlert() {
+        if (this.alertTmr) {
+            clearInterval(this.alertTmr);
+            this.alertTmr = null;
+        }
+
+        this.updateTitle();
+    }
+
+    updateTitle(newTitle) {
+        if (typeof newTitle === 'string') {
+            this.title = newTitle;
+        }
+
+        if (this.alertTmr && !this.alert) {
+            window.document.title = '* ' + this.title;
+            this.alert = true;
+        } else {
+            window.document.title = this.title;
+            this.alert = false;
+        }
+    }
+}

package/apps/web/upstream/src/libs/batchedAdd.js

@@ -0,0 +1,74 @@
+'kiwi public';
+
+/**
+ * batchedAdd prevents a flood of new inserts into state. Based on JS ticks, inserts /sec are
+ * counted by each JS tick that inserts an item. Eg. 10 inserts in 1 tick = 1 count. 10 inserts
+ * on different JS ticks = 10 counts.
+ * After X counts/sec, batch each second worth of new items at the same time.
+ */
+export default function batchedAdd(singleFn, batchedFn, numInsertsSec = 3) {
+    let inTick = false;
+    let queue = [];
+    let numInLastSec = 0;
+    let queueLoopTmr = null;
+    let loopInterval = 1000;
+    let checkSecRateTmr = null;
+
+    function queueLoop() {
+        numInLastSec = 0;
+        if (queue.length) {
+            // emptying queue before calling batchedFn in case that function triggers
+            // code that needs to see that the queue has been processed.
+            let q = queue;
+            queue = [];
+            batchedFn(q);
+            queueLoopTmr = setTimeout(queueLoop, loopInterval);
+        } else {
+            queueLoopTmr = null;
+        }
+    }
+
+    function maybeStartLoop() {
+        if (!queueLoopTmr) {
+            queueLoopTmr = setTimeout(queueLoop, loopInterval);
+        }
+    }
+
+    // Reset numInLastSec after loopInterval. This allows enough time for the counter to
+    // increase to detect batching. Only needs to run if we are not currently batching and
+    // only needs to run once at a time.
+    function resetAddCounter() {
+        if (!queueLoopTmr && !checkSecRateTmr) {
+            checkSecRateTmr = setTimeout(() => {
+                checkSecRateTmr = null;
+                if (!queueLoopTmr) {
+                    numInLastSec = 0;
+                }
+            }, loopInterval);
+        }
+    }
+
+    function batchFn(item) {
+        if (!inTick) {
+            numInLastSec++;
+        }
+
+        // If already queuing or we reached our limit on items/sec, queue the item
+        if (queue.length || numInLastSec > numInsertsSec) {
+            queue.push(item);
+            maybeStartLoop();
+        } else {
+            inTick = true;
+            setTimeout(() => {
+                inTick = false;
+            });
+            singleFn(item);
+            resetAddCounter();
+        }
+    }
+    batchFn.queue = function getQueue() {
+        return queue;
+    };
+
+    return batchFn;
+}

package/apps/web/upstream/src/libs/bufferTools.js

@@ -0,0 +1,177 @@
+'kiwi public';
+
+import _ from 'lodash';
+import getState from '@/libs/state';
+
+export function orderBuffers(buffers) {
+    // Since vuejs will sort in-place and update views when .sort is called
+    // on an array, clone it first so that we have a plain array to sort
+    let list = buffers.map((b) => b);
+
+    list = _.filter(list, (buffer) => !buffer.isServer());
+    list = list.sort((a, b) => {
+        let order = 0;
+        if (a.isChannel() && b.isQuery()) {
+            order = -1;
+        } else if (a.isQuery() && b.isChannel()) {
+            order = 1;
+        } else {
+            order = a.name.localeCompare(b.name);
+        }
+
+        return order;
+    });
+
+    return list;
+}
+
+export function orderedMessages(buffer, opts = {}) {
+    let state = getState();
+    let network = buffer.getNetwork();
+    let currentNick = network.nick;
+    let bufferMessages = buffer.getMessages();
+
+    // Hack; We need to make vue aware that we depend on buffer.message_count in order to
+    // get the messagelist to update its DOM, as the change of message_count alerts
+    // us that the messages have changed. This is done so that vue does not have to make
+    // every emssage reactive which gets very expensive.
+    /* eslint-disable no-unused-vars */
+    let ignoredVar = buffer.message_count;
+
+    let messages = [];
+    if (opts.inPlace) {
+        messages = bufferMessages;
+    } else {
+        messages = bufferMessages.slice(0, bufferMessages.length);
+    }
+
+    messages.sort((a, b) => {
+        if (a.time > b.time) {
+            return 1;
+        } else if (b.time > a.time) {
+            return -1;
+        }
+
+        return a.instance_num > b.instance_num ?
+            1 :
+            -1;
+    });
+
+    if (opts.noFilter) {
+        return messages;
+    }
+
+    let messageTypesToShowSetting = {
+        // message.type: 'settings_name'
+        traffic: 'show_joinparts',
+        topic: 'show_topics',
+        nick: 'show_nick_changes',
+        mode: 'show_mode_changes',
+        presence: 'show_presence_changes',
+    };
+
+    let hiddenMessageTypes = Object.keys(messageTypesToShowSetting)
+        .filter((type) => !buffer.setting(messageTypesToShowSetting[type]));
+
+    let typeExtraIncludesSelf = (message) => message.type_extra &&
+        message.type_extra.endsWith('_self');
+
+    let settingShowTopicInHeader = buffer.setting('show_topic_in_header');
+
+    let list = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        // don't include hidden message types
+        if (hiddenMessageTypes.includes(messages[i].type) && !typeExtraIncludesSelf(messages[i])) {
+            continue;
+        }
+
+        // Ignored users have the ignore flag set
+        if (messages[i].ignore) {
+            continue;
+        }
+
+        // Don't show the first connection message. Channels are only interested in
+        // the joining message at first. Dis/connection messages are only relevant here
+        // if the dis/connection happens between messages (during a conversation)
+        if (messages[i].type === 'connection' && i === 0) {
+            continue;
+        }
+
+        if (
+            messages[i].type === 'topic' &&
+            messages[i].type_extra === 'topic_join' &&
+            !state.ui.is_narrow &&
+            settingShowTopicInHeader
+        ) {
+            continue;
+        }
+
+        // When we join a channel the topic is usually sent next. But this looks
+        // ugly when rendered. So we switch the topic + join messages around so
+        // that the topic is first in the message list.
+        if (
+            messages[i].type === 'topic' &&
+            messages[i - 1] &&
+            messages[i - 1].type === 'traffic' &&
+            messages[i - 1].nick === currentNick
+        ) {
+            list.push(messages[i - 1]);
+            list.push(messages[i]);
+            i--;
+        } else {
+            list.push(messages[i]);
+        }
+    }
+
+    return list.reverse();
+}
+
+export function getNextBuffer() {
+    return getBufferFromDirection(1);
+}
+
+export function getPreviousBuffer() {
+    return getBufferFromDirection(-1);
+}
+
+function getBufferFromDirection(direction) {
+    let state = getState();
+    let network = state.getActiveNetwork();
+    let buffer = state.getActiveBuffer();
+
+    if (!network || !buffer) {
+        return null;
+    }
+
+    let ordered = orderBuffers(network.buffers);
+    let index = _.findIndex(ordered, ['name', buffer.name]) + direction;
+
+    if (index >= ordered.length || index < 0) {
+        network = getNetworkFromDirection(direction);
+        ordered = orderBuffers(network.buffers);
+        buffer = (direction === 1) ? ordered[0] : ordered[ordered.length - 1];
+    } else {
+        buffer = ordered[index];
+    }
+    return buffer;
+}
+
+function getNetworkFromDirection(direction) {
+    let state = getState();
+    let network = state.getActiveNetwork();
+    for (let i = 0; i < state.networks.length; i++) {
+        let index = _.findIndex(state.networks, ['id', network.id]) + direction;
+
+        if (index >= state.networks.length && state.networks.length >= 0) {
+            network = state.networks[0];
+        } else if (index < 0) {
+            network = state.networks[state.networks.length - 1];
+        } else {
+            network = state.networks[index];
+        }
+        if (network.buffers.length > 1) {
+            return network;
+        }
+    }
+    return network;
+}

package/apps/web/upstream/src/libs/polyfill/Element.closest.js

@@ -0,0 +1,18 @@
+// From the Element.closest mdn page.
+if (!Element.prototype.matches) {
+    Element.prototype.matches = Element.prototype.msMatchesSelector ||
+                                Element.prototype.webkitMatchesSelector;
+}
+
+if (!Element.prototype.closest) {
+    Element.prototype.closest = function closest(s) {
+        let el = this;
+        do {
+            if (el.matches(s)) {
+                return el;
+            }
+            el = el.parentElement || el.parentNode;
+        } while (el !== null && el.nodeType === 1);
+        return null;
+    };
+}