serverless-ircd 0.6.0 → 0.7.0

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

@@ -0,0 +1,71 @@
+'kiwi public';
+
+const defaultLogger = makeLogger();
+export default defaultLogger;
+
+function makeLogger(label, rootLogger) {
+    function logger(...args) {
+        logger.info(...args);
+    }
+
+    logger.LEVEL_DEBUG = 2;
+    logger.LEVEL_INFO = 1;
+    logger.LEVEL_ERROR = 0;
+    logger.level = logger.LEVEL_ERROR;
+
+    function logLevel(compareLevel) {
+        let l = rootLogger || logger;
+        return l.level >= compareLevel;
+    }
+
+    logger.debug = function logDebug(...args) {
+        if (logLevel(logger.LEVEL_DEBUG)) {
+            if (label) {
+                args[0] = `[${label}] DEBUG ${args[0]}`;
+            }
+            window.console.log(...args);
+        }
+    };
+
+    logger.info = function logInfo(...args) {
+        if (logLevel(logger.LEVEL_INFO)) {
+            if (label) {
+                args[0] = `[${label}] INFO ${args[0]}`;
+            }
+            window.console.log(...args);
+        }
+    };
+
+    logger.error = function logError(...args) {
+        if (logLevel(logger.LEVEL_ERROR)) {
+            if (label) {
+                args[0] = `[${label}] ERROR ${args[0]}`;
+            }
+
+            window.console.error(...args);
+        }
+    };
+
+    logger.assert = function assert(condition, ...args) {
+        if (condition) {
+            return;
+        }
+
+        this.error('Assertion failed.', ...args);
+    };
+
+    logger.setLevel = function setLevel(newLevel) {
+        logger.level = newLevel;
+    };
+
+    logger.namespace = function namespace(newLabel) {
+        let l = newLabel;
+        if (label) {
+            l = `[${label}][${l}]`;
+        }
+
+        return makeLogger(l, logger);
+    };
+
+    return logger;
+}

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

@@ -0,0 +1,169 @@
+'kiwi public';
+
+import Vue from 'vue';
+import parseMessage from '@/libs/MessageParser';
+import toHtml from '@/libs/renderers/Html';
+import GlobalApi from '@/libs/GlobalApi';
+import getState from './state';
+
+let nextId = 0;
+
+function def(target, key, value) {
+    Object.defineProperty(target, key, {
+        writable: true,
+        value,
+    });
+}
+
+export default class Message {
+    constructor(message, user) {
+        // instance_num is a running number for all messages created within Kiwi. Used to order
+        // messages if the message time is the same.
+        def(this, 'instance_num', nextId++);
+        def(this, 'id', extractMessageId(message) || nextId++);
+
+        // internal_time is used to allow for a getter/setter
+        // so day_num can be updated if the time is changed
+        def(this, 'internal_time', null);
+        def(this, 'day_num', null);
+
+        // Two different times;
+        //   time = time in the users local time (getter/setter)
+        //   server_time = time the server gave us
+        this.time = message.time || Date.now();
+        def(this, 'server_time', message.server_time || this.time);
+        def(this, 'nick', message.nick);
+        def(this, 'message', message.message);
+        def(this, 'tags', message.tags);
+        def(this, 'type', message.type || 'message');
+        def(this, 'type_extra', message.type_extra);
+        def(this, 'ignore', false);
+        def(this, 'mentioned_urls', []);
+        // If embed.payload is truthy, it will be embedded within the message
+        this.embed = { type: 'url', payload: null };
+        this.html = '';
+        this.blocks = [];
+        def(this, 'hasRendered', false);
+        // template should be null or a Vue component to render this message
+        def(this, 'template', message.template || null);
+        def(this, 'templateProps', message.templateProps || {});
+        // bodyTemplate should be null or a Vue component to render in the body of the message
+        def(this, 'bodyTemplate', message.bodyTemplate || null);
+        def(this, 'bodyTemplateProps', message.bodyTemplateProps || {});
+        def(this, 'isHighlight', false);
+
+        // We don't want the user object to be enumerable
+        Object.defineProperty(this, 'user', { value: user });
+
+        Vue.observable(this);
+    }
+
+    get time() {
+        return this.internal_time;
+    }
+
+    set time(newTime) {
+        this.internal_time = newTime;
+        // txOffset is the milliseconds needed to get localtime to UTC
+        // eg UTC+1 = -3,600,000
+        const tzOffset = (new Date(newTime)).getTimezoneOffset() * 60000;
+        // 68400000 equals one day in milliseconds
+        this.day_num = Math.floor((newTime - tzOffset) / 86400000);
+    }
+
+    render() {
+        // Allow plugins to render their own messages if needed
+        GlobalApi.singleton().emit('message.render', { message: this });
+        return this;
+    }
+
+    toHtml(messageList) {
+        if (this.hasRendered) {
+            return this.html;
+        }
+
+        this.hasRendered = true;
+
+        let state = getState();
+        let showEmoticons = state.setting('buffers.show_emoticons') && !messageList.buffer.isSpecial();
+
+        this.toBlocks(messageList.buffer, messageList.useExtraFormatting);
+
+        state.$emit('message.prestyle', { message: this, blocks: this.blocks });
+
+        let content = toHtml(this.blocks, showEmoticons);
+        this.html = content;
+
+        state.$emit('message.poststyle', { message: this, blocks: this.blocks });
+        return this.html;
+    }
+
+    toBlocks(buffer, useExtraFormatting) {
+        let state = getState();
+        let userList = buffer.users;
+
+        let blocks = parseMessage(
+            this.message,
+            {
+                extras: !buffer.isSpecial() && useExtraFormatting && this.type === 'privmsg',
+            },
+            userList
+        );
+
+        this.mentioned_urls = blocks.filter((block) => block.type === 'url').map((block) => block.meta.url);
+        this.maybeAutoEmbed();
+
+        state.$emit('message.blocks', { message: this, blocks: blocks });
+        this.blocks = blocks;
+        return blocks;
+    }
+
+    maybeAutoEmbed() {
+        if (!this.mentioned_urls || this.mentioned_urls.length === 0) {
+            return;
+        }
+
+        // Only auto preview links on user messages. Traffic, topics, notices, etc would get
+        // annoying as they usually contain links of some sort
+        if (this.type !== 'privmsg') {
+            return;
+        }
+
+        let url = this.mentioned_urls[0];
+
+        let whitelistRegex = getState().setting('buffers.inline_link_auto_preview_whitelist');
+        whitelistRegex = (whitelistRegex || '').trim();
+        try {
+            if (!whitelistRegex || !(new RegExp(whitelistRegex, 'i')).test(url)) {
+                return;
+            }
+        } catch (err) {
+            // A bad regex pattern will throw an error
+            return;
+        }
+
+        this.embed.payload = url;
+        this.embed.type = 'url';
+    }
+
+    serialise() {
+        return {
+            id: this.id,
+            time: this.time,
+            server_time: this.server_time,
+            nick: this.nick,
+            message: this.message,
+            tags: this.tags,
+            type: this.type,
+            type_extra: this.type_extra,
+        };
+    }
+}
+
+function extractMessageId(message) {
+    if (!message.tags) {
+        return undefined;
+    }
+
+    return message.tags.msgid || message.tags['draft/msgid'] || undefined;
+}

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

@@ -0,0 +1,364 @@
+'kiwi public';
+
+const tokens = Object.create(null);
+
+/**
+ * Token functions may return:
+ * null - move forward in the input by the length of the token
+ * -1 - do not treat this character as a token and continue as normal content
+ * 0+ - move to this point in the input
+ */
+
+/* eslint-disable dot-notation */
+tokens['_'] = {
+    token: '_',
+    extra: true,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        if (openToks[this.token]) {
+            delete block.styles.underline;
+            openToks[this.token] = null;
+            prevBlock.content += this.token;
+            return null;
+        }
+
+        // If this style is alrady open by something else, ignore it
+        if (block.styles.underline === true) {
+            return -1;
+        }
+
+        // Underscores may be part of a word or URL so consider it an opening
+        if (pos > 0 && inp[pos - 1] !== ' ') {
+            return -1;
+        }
+
+        // token if it's on it's own
+        // Only underline if we have a closing _ further on
+        if (inp.substr(pos + 1).indexOf(this.token) === -1) {
+            return -1;
+        }
+
+        openToks[this.token] = true;
+        block.styles.underline = true;
+        block.content += this.token;
+
+        return null;
+    },
+};
+tokens['*'] = {
+    token: '*',
+    extra: true,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        if (openToks[this.token]) {
+            delete block.styles.italic;
+            openToks[this.token] = null;
+            prevBlock.content += this.token;
+            return null;
+        }
+
+        // If this style is alrady open by something else, ignore it
+        if (block.styles.italic === true) {
+            return -1;
+        }
+
+        // Ignore is after a : character. :* is usually a kiss emoji
+        if (inp[pos - 1] === ':') {
+            return -1;
+        }
+
+        // * may be part of a word (ie. pasting code) or URL so only start bolding if * is after a
+        // space
+        if (pos > 0 && inp[pos - 1] !== ' ') {
+            return -1;
+        }
+
+        // Only style if:
+        //     * we have a closing * further on
+        //     * the * further on has a space after it or is the last character
+        let remainingText = inp.substr(pos + 1);
+        let nextPos = remainingText.indexOf(this.token);
+        if (
+            nextPos === -1 ||
+            (nextPos < remainingText.length - 1 && remainingText[nextPos + 1] !== ' ')
+        ) {
+            return -1;
+        }
+
+        openToks[this.token] = true;
+        block.styles.italic = true;
+        block.content += this.token;
+
+        return null;
+    },
+};
+tokens['**'] = {
+    token: '**',
+    extra: true,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        if (openToks[this.token]) {
+            delete block.styles.bold;
+            openToks[this.token] = null;
+            prevBlock.content += this.token;
+            return null;
+        }
+
+        // If this style is alrady open by something else, ignore it
+        if (block.styles.bold === true) {
+            return -1;
+        }
+
+        // Only style if we have a closing ** further on
+        if (inp.substr(pos + 1).indexOf(this.token) === -1) {
+            return -1;
+        }
+
+        openToks[this.token] = true;
+        block.styles.bold = true;
+        block.content += this.token;
+
+        return null;
+    },
+};
+tokens['`'] = {
+    token: '`',
+    extra: true,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        if (openToks[this.token]) {
+            delete block.styles.quote;
+            openToks[this.token] = null;
+            prevBlock.content += this.token;
+            return null;
+        }
+
+        // Backticks may be part of a word or NICK so only consider it a codeblock if
+        // it's at the start of a scentence or comes after a space
+        if (pos > 0 && inp[pos - 1] !== ' ') {
+            return -1;
+        }
+
+        // Find the closing backtick
+        let str = inp.substr(pos + 1);
+        let endPos = str.indexOf(this.token);
+
+        // If we don't have a closing backtick further on, don't take this as an opening backtick
+        if (endPos === -1) {
+            return -1;
+        }
+
+        // Only consider the found closing backtick as closing if it comes before a space or is at
+        // the end of the text. If it's in the middle of text then it's highly lickely part of that
+        // text and not actually closing. eg. `hello and wel`come
+        if (str[endPos + 1] && str[endPos + 1] !== ' ') {
+            return -1;
+        }
+
+        // No styling should appear in this codeblock. Add all the content we can
+        // before jumping the position forward in the input
+        openToks[this.token] = true;
+        block.styles.quote = true;
+        block.content += this.token + str.substr(0, endPos);
+        block.containsContent = true;
+        // The + 1 because:
+        // We added 2 ` characters, but we want the last ` character to call this
+        // fn again so it can be closed.
+        return pos + endPos + 1;
+    },
+};
+
+// Bold
+tokens['\x02'] = {
+    token: '\x02',
+    extra: false,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        if (openToks[this.token]) {
+            delete block.styles.bold;
+            openToks[this.token] = null;
+        } else {
+            openToks[this.token] = true;
+            block.styles.bold = true;
+        }
+
+        return null;
+    },
+};
+
+// Italic
+tokens['\x1D'] = {
+    token: '\x1D',
+    extra: false,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        if (openToks[this.token]) {
+            delete block.styles.italic;
+            openToks[this.token] = null;
+        } else {
+            openToks[this.token] = true;
+            block.styles.italic = true;
+        }
+
+        return null;
+    },
+};
+
+// Underline
+tokens['\x1F'] = {
+    token: '\x1F',
+    extra: false,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        if (openToks[this.token]) {
+            delete block.styles.underline;
+            openToks[this.token] = null;
+        } else {
+            openToks[this.token] = true;
+            block.styles.underline = true;
+        }
+
+        return null;
+    },
+};
+
+// Clear all styles
+tokens['\x0F'] = {
+    token: '\x0F',
+    extra: false,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        Object.keys(block.styles).forEach((k) => delete block.styles[k]);
+        Object.keys(openToks).forEach((k) => delete openToks[k]);
+
+        return null;
+    },
+};
+
+// Colours
+tokens['\x03'] = {
+    token: '\x03',
+    extra: false,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        let colours = {
+            0: 'white',
+            1: 'black',
+            2: 'blue',
+            3: 'green',
+            4: 'light-red',
+            5: 'brown',
+            6: 'purple',
+            7: 'orange',
+            8: 'yellow',
+            9: 'light-green',
+            10: 'cyan',
+            11: 'light-cyan',
+            12: 'light-blue',
+            13: 'pink',
+            14: 'grey',
+            15: 'light-grey',
+        };
+
+        let colourMatchRegexp = /^\x03(([0-9][0-9]?)(,([0-9][0-9]?))?)/;
+        let match = colourMatchRegexp.exec(inp.substr(pos, 6));
+        if (match) {
+            // fg colour = 2, bg colour = 4
+            let fgColour = colours[parseInt(match[2], 10)];
+            let bgColour = colours[parseInt(match[4], 10)];
+            if (typeof fgColour !== 'undefined') {
+                block.styles.color = fgColour;
+            }
+            if (typeof bgColour !== 'undefined') {
+                block.styles.background = bgColour;
+            }
+
+            return pos + match[0].length;
+        }
+
+        // 03 without a colour = delete any existing colour
+        delete block.styles.color;
+        delete block.styles.background;
+
+        return null;
+    },
+};
+
+// Reverse (unimplemented)
+tokens['\x16'] = {
+    token: '\x16',
+    extra: false,
+    fn: function parseToken(inp, pos, block, prevBlock, openToks) {
+        return null;
+    },
+};
+
+export default function parse(inp, _opts) {
+    let opts = _opts || {};
+    let block = createNewBlock();
+    let blocks = [block];
+    let openTokens = Object.create(null);
+
+    let pos = 0;
+    let len = inp.length;
+
+    while (pos < len) {
+        let tok = findTokenAtPosition();
+        if (!tok || (!opts.extras && tok.extra)) {
+            block.content += inp[pos];
+            block.containsContent = true;
+            pos++;
+            continue;
+        }
+
+        // Current character is a token of some sort
+
+        let newBlock = null;
+
+        // Consecutive tokens can stack up styles into the same blocks. A consecutive
+        // token means that the block before it will not have any content yet
+        if (block.containsContent) {
+            newBlock = createNewBlock();
+        } else {
+            newBlock = block;
+        }
+
+        Object.assign(newBlock.styles, block.styles);
+        let newPos = tok.fn(inp, pos, newBlock, block, openTokens);
+
+        if (newPos === -1) {
+            // The token invalidated itself so treat it as content
+            block.content += tok.token;
+            block.containsContent = true;
+            pos += tok.token.length;
+            continue;
+        }
+
+        block = newBlock;
+
+        // This block may have already been pushed if this is a consecutive token
+        if (blocks[blocks.length - 1] !== newBlock) {
+            blocks.push(newBlock);
+        }
+
+        if (typeof newPos === 'number') {
+            pos = newPos;
+        } else {
+            pos += tok.token.length;
+        }
+    }
+
+    return blocks;
+
+    function findTokenAtPosition() {
+        let tok = tokens[inp.substr(pos, 2)] || tokens[inp[pos]];
+        return tok;
+    }
+}
+
+export function createNewBlock(
+    content = '',
+    styles = {},
+    type = 'text',
+    meta = {}
+) {
+    const newBlock = {
+        styles: styles,
+        content: content,
+        containsContent: !!content,
+        type: type,
+        meta: meta,
+    };
+    return newBlock;
+}