serverless-ircd 0.6.0 → 0.7.0

package/apps/web/upstream/src/helpers/Misc.js

@@ -0,0 +1,401 @@
+'kiwi public';
+
+/** @module */
+
+import _ from 'lodash';
+import Vue from 'vue';
+import strftime from 'strftime';
+import PluginWrapper from '@/components/utils/PluginWrapper';
+import * as TextFormatting from '@/helpers/TextFormatting';
+import { urlRegex } from './TextFormatting';
+
+const strftimeUTC = strftime.timezone('+0');
+/**
+ * Extract an array of buffers from a string, parsing multiple buffer names and channel keys
+ * "#chan,#chan2" => 2 channels without a key
+ * "#chan,#chan2 key" => 2 channels, the first having a key
+ * "#chan,#chan2 key1,key2" => 2 channels, both having a key
+ * "#chan,#chan2 ,key2" => 2 channels, the second having a key
+ * @param {string} str List of buffer names and channel keys
+ */
+export function extractBuffers(str) {
+    let spaceIdx = str.indexOf(' ');
+    if (spaceIdx === -1) spaceIdx = str.length;
+
+    let bufferNames = str.substr(0, spaceIdx).split(',');
+    let keys = str.substr(spaceIdx + 1).split(',');
+
+    let buffers = [];
+    bufferNames.forEach((bufferName, idx) => {
+        // return if bufferName is empty
+        if (!bufferName.trim()) {
+            return;
+        }
+        buffers.push({
+            name: bufferName,
+            key: keys[idx] || '',
+        });
+    });
+
+    return buffers;
+}
+
+export function extractURL(str) {
+    let matches = str.match(urlRegex);
+    return matches ? matches[0] : '';
+}
+
+export function stripStyles(str) {
+    return str.replace(/(\x03[0-9]{0,2})?([\x02\x16\x1d\x1f]+)?/g, '');
+}
+
+/**
+ * Does a string mention a nickname?
+ * @param {string} input The string to search within
+ * @param {string} nick The nick to search for
+ */
+export function mentionsNick(input, nick) {
+    if (input.toLowerCase().indexOf(nick.toLowerCase()) === -1) {
+        return false;
+    }
+    let punc = '\\s,.!:;+()\\[\\]?¿\\/<>@-';
+    let escapedNick = _.escapeRegExp(nick);
+    let stylesStrippedInput = stripStyles(input);
+    let r = new RegExp(`(^|[${punc}])${escapedNick}([${punc}]|$)`, 'i');
+    return r.test(stylesStrippedInput);
+}
+
+/**
+ * Get a query string value from the current URL
+ * @param {string} _name The query string variable name
+ * @param {string} _url The full URL to extract the variable from
+ */
+export function queryStringVal(_name, _url) {
+    let url = _url || window.location.href;
+    let name = _.escapeRegExp(_name);
+    let regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)');
+    let results = regex.exec(url);
+
+    if (!results) {
+        return null;
+    }
+    if (!results[2]) {
+        return '';
+    }
+
+    return decodeURIComponent(results[2].replace(/\+/g, ' '));
+}
+
+/**
+ * Convert a known error code to a human readable message
+ * @param {string} err The error message from the network connection
+ */
+export function networkErrorMessage(err) {
+    let errs = {
+        err_unknown_host: 'Unknown domain name or host',
+        err_forbidden: 'Forbidden to connect',
+        err_timeout: 'Took too long to connect',
+        err_refused: 'The server refused the connection',
+        err_tls: 'Could not connect securely',
+        err_proxy: 'The Kiwi IRC server had an error',
+    };
+
+    return errs[err] || 'Unknown error';
+}
+
+/**
+ * Take a users connection object (usually from startupOptions) and normalise a connection
+ * settings object. Parses websocket/direct/kiwiServer/etc options and creates a single
+ * object that Kiwi can consistently read from.
+ * @param {Object} config User provided connection config object
+ */
+export function connectionInfoFromConfig(config) {
+    let connection = {
+        tls: false,
+        port: 0,
+        hostname: '',
+        direct: false,
+        direct_path: '',
+    };
+
+    let wsUri = config.websocket ?
+        matchUri(config.websocket) :
+        null;
+
+    if (wsUri) {
+        connection.direct = true;
+        connection.tls = ['wss', 'https', 'ircs'].indexOf(wsUri.protocol) > -1;
+        connection.port = wsUri.port;
+        connection.hostname = wsUri.hostname;
+        connection.direct_path = wsUri.path;
+        if (wsUri.search) {
+            connection.direct_path += '?' + wsUri.search;
+        }
+    } else {
+        connection.tls = config.tls;
+        connection.port = config.port;
+        connection.hostname = config.server;
+        connection.direct = !!config.direct;
+        connection.direct_path = config.direct_path || '';
+    }
+
+    return connection;
+}
+
+export function matchUri(uri) {
+    let reg = /(?:([a-z]+):\/\/)?([a-z.0-9-]+)(?::(?:(\+)?([0-9]+)))?(?:\/([^?]*))?(?:\?(.*))?/;
+    /*
+    0: "ws://hostname.com:6676/erferf?foo=val"
+    1: "ws"
+    2: "hostname.com"
+    3: undefined
+    4: "6676"
+    5: "erferf"
+    6: "foo=var"
+    */
+    let m = uri.match(reg);
+    if (!m) {
+        return null;
+    }
+
+    return {
+        protocol: (m[1] || '').toLowerCase(),
+        hostname: m[2] || '',
+        port: parseIntZero(m[4] || ''),
+        path: '/' + (m[5] || ''),
+        search: m[6] || '',
+    };
+}
+
+/**
+ * Parse a connection string into an object
+ * E.g. [ircs?://]irc.network.net:[+]6667/channel?nick=mynick;
+ * Multiple connections may be given, separated by ;
+ * @param {string} str The connection string URI
+ */
+export function parseIrcUri(str) {
+    let reg = /(?:(ircs?|wss?):\/\/)?([a-z.0-9-]+)(?::(?:(\+)?([0-9]+)))?(?:\/([^?]*))?(?:\?(.*))?/;
+    let connections = [];
+    str.split(';').forEach((connectionString) => {
+        if (!connectionString) {
+            return;
+        }
+
+        let m = connectionString.match(reg);
+
+        if (!m) {
+            return;
+        }
+
+        let tls = m[1] === 'ircs' || m[1] === 'wss' || !!m[3];
+        let direct = m[1] === 'ws' || m[1] === 'wss';
+        let params = Object.create(null);
+        (m[6] || '').split('&').forEach((p) => {
+            let parts = p.split('=');
+            if (parts.length === 2) {
+                params[parts[0].toLowerCase()] = parts[1];
+            }
+        });
+
+        let channels = (m[5] || params.channel || '');
+        channels = _(channels.split(','))
+            .compact()
+            .map((_channelName) => {
+                let hasPrefix = _channelName[0] === '#' ||
+                    _channelName[0] === '&';
+
+                let channelName = hasPrefix ?
+                    _channelName :
+                    '#' + _channelName;
+
+                return channelName;
+            });
+
+        connections.push({
+            tls: tls,
+            server: m[2],
+            port: parseInt(m[4] || (tls ? 6697 : 6667), 10),
+            channels: channels,
+            nick: params.nick || '',
+            encoding: (params.encoding || 'utf8'),
+            params: params,
+            direct: direct,
+        });
+    });
+
+    return connections;
+}
+
+/**
+ * Parse preset server string to an object
+ * format: freenode|irc.freenode.net:+6697
+ * @param {string} input Preset server string
+ */
+export function parsePresetServer(input) {
+    let ret = {
+        name: '',
+        server: '',
+        port: 6667,
+        tls: false,
+    };
+
+    ret.toUri = () => `${ret.server}:${ret.tls ? '+' : ''}${ret.port}`;
+
+    let val = input;
+
+    let pipePos = val.indexOf('|');
+    if (pipePos > -1) {
+        ret.name = val.substr(0, pipePos);
+        val = val.substr(pipePos + 1);
+    }
+
+    let colonPos = val.indexOf(':');
+    if (colonPos === -1) {
+        ret.server = val;
+        val = '';
+    } else {
+        ret.server = val.substr(0, colonPos);
+        val = val.substr(colonPos + 1);
+    }
+
+    if (val[0] === '+') {
+        ret.tls = true;
+        val = val.substr(1);
+    }
+
+    if (val.length > 0) {
+        ret.port = parseInt(val, 10);
+        val = '';
+    }
+
+    if (!ret.name) {
+        ret.name = ret.server;
+    }
+
+    return ret;
+}
+
+/**
+ * Scan though an object and extend any dot notated keys
+ * @param {Object} confObj Source object to traverse
+ */
+export function dedotObject(confObj, _place) {
+    let place = _place || [];
+    let regex = /\w\.\w/;
+
+    _.each(confObj, (val, key) => {
+        let ourPlace = place.concat([key]);
+        if (typeof val === 'object') {
+            dedotObject(confObj[key], ourPlace);
+            return;
+        }
+        if (regex.test(key)) {
+            delete confObj[key];
+            _.set(confObj, ourPlace.join('.'), val);
+        }
+    });
+}
+
+/**
+ * Replace the target object with source, while keeping the target object reference intact.
+ * Delete all the properties from the target object and copy the properties from source
+ * over to the target.
+ * a = {one: 1, two: 2, three: 3}
+ * b = {four: 4, five: 5, six: 6}
+ * replaceObjectProps(a, b)
+ * a.one === undefined;
+ * a.six === 6;
+ * @param {Object} target The target object that will be replaced
+ * @param {Object} source The source object from which all properties will be copied from
+ */
+export function replaceObjectProps(target, source) {
+    Object.keys(target).forEach((prop) => delete target[prop]);
+    Object.keys(source).forEach((prop) => { target[prop] = source[prop]; });
+}
+
+/**
+ * Create an ISO8601 formatted date
+ * @param {Date} date The date object to create the time from. Defaults to the current time
+ */
+export function dateIso(date) {
+    let d = date || new Date();
+    return strftimeUTC('%Y-%m-%dT%H:%M:%S.%LZ', d);
+}
+
+/**
+ * Cast a string to an int, returning 0 if it fails
+ * @param {String} inp The number as a string to convert to an int
+ */
+export function parseIntZero(inp) {
+    let int = parseInt(inp, 10);
+    return Number.isNaN(int) ?
+        0 :
+        int;
+}
+
+/**
+ * Prepare plugin provided object, for use as a plugin component
+ * @param {Number} pluginId The number to identify this plugin object
+ * @param {Component} componentOrElement The vue.js component object or html element
+ * @param {Object} args Optional arguments for this plugin { title: '', props: {} }
+ */
+export function makePluginObject(pluginId, componentOrElement, args = {}) {
+    const plugin = {
+        id: pluginId,
+        component: null,
+        title: () => '',
+        props: {},
+        tabName: '',
+    };
+
+    // copy props from args
+    plugin.props = Object.assign(plugin.props, args.props);
+    plugin.tabName = args.tabName || args.title || 'plugin_tab_' + pluginId;
+
+    if (componentOrElement instanceof Element) {
+        // componentOrElement is an html element, so wrap it in a functional component
+
+        // eslint-disable-next-line no-underscore-dangle
+        if (componentOrElement.__vue__ && !window.kiwi_deprecations_vueEl) {
+            window.kiwi_deprecations_vueEl = true;
+            // eslint-disable-next-line no-console
+            console.warn('deprecated component.$el added to plugin api, please switch to just passing the vue.js component object');
+        }
+        plugin.component = PluginWrapper;
+        plugin.props = Object.assign(plugin.props, {
+            pluginElement: componentOrElement,
+        });
+    } else if (componentOrElement instanceof Object) {
+        // componentOrElement is an object, attempt to make a vue component from it
+        plugin.component = Vue.extend(componentOrElement);
+    } else {
+        plugin.component = componentOrElement;
+    }
+
+    if (typeof args.title === 'string') {
+        // if args.title exists wrap it in a function, that can also be a translation string
+        plugin.title = () => (args.title.slice(0, 2) === 't_' ? TextFormatting.t(args.title.slice(2)) : args.title);
+    }
+
+    return plugin;
+}
+
+// This provides a better sort for numbered nicks but does not work on ios9
+let intlCollator;
+if (global.Intl) {
+    intlCollator = new Intl.Collator({}, { numeric: true });
+}
+
+export function strCompare(a, b) {
+    if (intlCollator) {
+        return intlCollator.compare(a, b);
+    }
+
+    if (a === b) {
+        return 0;
+    }
+
+    return a > b ?
+        1 :
+        -1;
+}

package/apps/web/upstream/src/helpers/TextFormatting.js

@@ -0,0 +1,237 @@
+'kiwi public';
+
+/** @module */
+import _ from 'lodash';
+import * as ipRegex from 'ip-regex';
+import i18next from 'i18next';
+import * as murmurhash3 from 'murmurhash3js';
+
+import getState from '@/libs/state';
+import ThemeManager from '@/libs/ThemeManager';
+
+export const urlRegex = new RegExp(
+    // Detect either a protocol or 'www.' to start a URL
+    /(([A-Za-z][A-Za-z0-9-]*:\/\/)|(www\.))/.source +
+        '(' +
+        // Hostname and tld
+        /([\w\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF.-]+\.[a-zA-Z]{2,63})/.source +
+        '|' +
+        'localhost' +
+        '|' +
+        // IPv4 address
+        ipRegex.v4().source +
+        '|' +
+        // IPv6 address
+        '(\\[?' +
+        ipRegex.v6().source +
+        '\\]?)' +
+        ')' +
+        // Optional port..
+        /(:[0-9]+)?/.source +
+        // Optional path..
+        /(\/[\w\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF!:.?$'()[\]*,;~+=&%@!\-/]*)?/.source +
+        // Optional fragment
+        /(#.*)?/.source,
+    'i'
+);
+
+export const channelRegex = /(^|\s)([@+~&%}]*)([#&][^ ,\007<>\n\r]+?)([:;.,<>\n\r]+)?$/i;
+
+export function linkifyChannels(word) {
+    // "@#kiwiirc," = 3 parts. (prefix=@)(channel=#kiwiirc)(suffix=,)
+    return word.replace(channelRegex, (match, mLead, mPrefix, mChannel, mSuffix) => {
+        let chan = _.escape(mChannel.trim());
+        let lead = _.escape(mLead);
+        let prefix = _.escape(mPrefix);
+        let suffix = _.escape(mSuffix);
+
+        let link = `<a class="u-link kiwi-channel" data-channel-name="${chan}">${chan}</a>`;
+        return `${lead}${prefix}${link}${suffix}`;
+    });
+}
+
+/**
+ * Convert a nickname string to a colour code
+ * Uses these properties from the CSS theme file:
+ * --kiwi-nickcolour-count: 200;  - number of available nick colours
+ * --kiwi-nickcolour-hueoffset: 0;  - moves the hue value by hueoffset amounts
+ * --kiwi-nickcolour-saturation: 70;  - the nick saturation in HSL value
+ * --kiwi-nickcolour-lightness: 40;  - the nick lightness in HSL value
+ */
+export function createNickColour(nick) {
+    let themeMngr = ThemeManager.instance();
+    let nickLower = (nick || '').toLowerCase();
+    let nickNum = murmurhash3.x86.hash32(nickLower);
+
+    let bucketSize = toInt(themeMngr.themeVar('nickcolour-count')) || 200;
+    let hueOffset = toInt(themeMngr.themeVar('nickcolour-hueoffset'));
+    let hsl = {
+        h: mapRange(Math.abs(nickNum) % bucketSize, 0, bucketSize, 0, 360) + hueOffset,
+        s: toInt(themeMngr.themeVar('nickcolour-saturation')) || 70,
+        l: toInt(themeMngr.themeVar('nickcolour-lightness')) || 40,
+    };
+    return `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`;
+}
+
+/**
+ * Parse a string to an int, where NaN is 0
+ * @param {string} inp
+ */
+export function toInt(inp) {
+    let int = parseInt(inp, 10);
+    if (Number.isNaN(int)) {
+        int = 0;
+    }
+
+    return int;
+}
+
+/**
+ * Extract a substring from a hex string and parse it as an integer
+ * @param {string} hash - Source hex string
+ * @param {number} index - Start index of substring
+ * @param {number} [length] - Length of substring. Defaults to 1.
+ */
+export function hexVal(hash, index, len) {
+    return parseInt(hash.substr(index, len || 1), 16);
+}
+
+/*
+ * Re-maps a number from one range to another
+ * http://processing.org/reference/map_.html
+ */
+export function mapRange(value, vMin, vMax, dMin, dMax) {
+    let vValue = parseFloat(value);
+    let vRange = vMax - vMin;
+    let dRange = dMax - dMin;
+
+    return (vValue - vMin) * dRange / vRange + dMin;
+}
+
+/**
+ * Format a string according to the configured textFormats, including a
+ * translation for the %text formatting variable
+ */
+export function formatAndT(formatId, formatParams, localeId, localeParams) {
+    let body = t(localeId, localeParams);
+    if (formatParams) {
+        formatParams.text = body;
+        body = formatText(formatId, formatParams);
+    } else {
+        body = formatText(formatId, { text: body });
+    }
+
+    return body;
+}
+
+/**
+ * Create a user reference string similar to 'nick'
+ */
+export function formatUser(fNick) {
+    let nick = fNick;
+
+    // Allow passing of a user object or irc-framework event
+    if (typeof nick === 'object') {
+        nick = nick.nick;
+    }
+
+    return formatText('user', { nick });
+}
+
+/**
+ * Create a full user reference similar to 'nick (user@host)'
+ */
+export function formatUserFull(fNick, fUsername, fHost) {
+    let nick = '';
+    let username = '';
+    let host = '';
+
+    // Allow passing of a user object or irc-framework event
+    if (typeof fNick === 'object') {
+        let user = fNick;
+        nick = user.nick;
+        username = user.username || user.ident;
+        host = user.hostname || user.host;
+    } else {
+        nick = fNick;
+        username = fUsername;
+        host = fHost;
+    }
+
+    return formatText('user_full', { nick, username, host });
+}
+
+/**
+ * Format a string according to the configured textFormats
+ */
+export function formatText(formatId, formatParams) {
+    let format = getState().setting('textFormats.' + formatId);
+    let params = formatParams;
+
+    // Most texts only have a 'text' variable so allow passing of a string for this
+    // variable as shorthand.
+    if (typeof params === 'string') {
+        params = { text: params };
+    }
+
+    // Expand a user mask into its individual parts (nick, ident, hostname)
+    if (params.user) {
+        params.nick = params.user.nick || '';
+        params.username = params.user.username || '';
+        params.host = params.user.hostname || '';
+        params.prefix = params.user.prefix || '';
+    }
+
+    // Do the magic. Use the %shorthand syntax to produce output.
+    let result = format.replace(/%([A-Z]{2,})/ig, (match, key) => {
+        let ret = '';
+        if (typeof params[key] !== 'undefined') {
+            ret = params[key];
+        }
+
+        return ret;
+    });
+
+    return result;
+}
+
+// Convert a given duration in seconds to human readable weeks,days,hours,minutes,seconds
+// only showing the duration parts that are used eg 3666 --> 1 hour, 1 minute, 6 seconds
+export function formatDuration(timeSeconds) {
+    let seconds = timeSeconds;
+
+    const weeks = Math.floor(seconds / (3600 * 24 * 7));
+    seconds -= weeks * 3600 * 24 * 7;
+
+    const days = Math.floor(seconds / (3600 * 24));
+    seconds -= days * 3600 * 24;
+
+    const hours = Math.floor(seconds / 3600);
+    seconds -= hours * 3600;
+
+    const minutes = Math.floor(seconds / 60);
+    seconds -= minutes * 60;
+
+    const tmp = [];
+    (weeks) && tmp.push(t('week', { count: weeks }));
+    (weeks || days) && tmp.push(t('day', { count: days }));
+    (days || hours) && tmp.push(t('hour', { count: hours }));
+    (days || hours || minutes) && tmp.push(t('minute', { count: minutes }));
+    tmp.push(t('second', { count: seconds }));
+
+    return tmp.join(' ');
+}
+
+export function formatNumber(num) {
+    return num.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, '$1,');
+}
+
+export function t(key, options) {
+    let val = i18next.t(key, options);
+    if (!val) {
+        let opts = options || {};
+        opts.lng = 'en-us';
+        val = i18next.t(key, opts);
+    }
+    return val;
+}