serverless-ircd 0.5.0 → 0.7.0

package/apps/web/upstream/src/components/utils/TabbedView.vue

@@ -0,0 +1,149 @@
+<template>
+    <div class="u-tabbed-view">
+        <div :key="prefixID + a" class="u-tabbed-view-tabs">
+            <a
+                v-for="c in tabs"
+                :key="c.name || c.header"
+                :class="{
+                    'u-tabbed-view-tab': true,
+                    'u-tabbed-view-tab--active': c.active
+                }"
+                @click="setActive(c)"
+            >{{ c.header }}</a>
+        </div>
+        <slot />
+    </div>
+</template>
+
+<script>
+'kiwi public';
+
+let Vue = require('vue');
+
+Vue.component('tabbed-tab', {
+    props: {
+        header: { status: String },
+        focus: { status: Boolean },
+        name: { status: String },
+    },
+    data: function data() {
+        return { active: false };
+    },
+    template: '<div v-if="active" class="u-tabbed-content"><slot></slot></div>',
+});
+
+export default Vue.component('tabbed-view', {
+    data: function data() {
+        return {
+            // We increment this when we need to re-render the tabs.
+            // Vue doesn't pick up on the $children changes all the time so we handle
+            // it ourselves.
+            a: 1,
+            prefixID: Math.floor(Math.random() * 100000).toString(36),
+        };
+    },
+    computed: {
+        tabs: function computedtabs() {
+            return this.$children;
+        },
+    },
+    mounted() {
+        this.setActiveCheck();
+    },
+    methods: {
+        getActive: function getActive() {
+            let foundChild = null;
+            this.$children.forEach((child) => {
+                if (child.active) {
+                    foundChild = child;
+                }
+            });
+
+            return foundChild;
+        },
+        setActive: function setActive(c) {
+            this.$children.forEach((child) => {
+                if (child !== c) {
+                    child.active = false;
+                }
+            });
+            c.active = true;
+
+            // Without this, vue doesnt update itself with the new $children :(
+            this.a++;
+            this.$emit('changed', c.name);
+        },
+        setActiveByName: function setActiveByName(name) {
+            this.$children.forEach((child) => {
+                if (child.name === name) {
+                    this.setActive(child);
+                }
+            });
+        },
+        setActiveCheck: function setActiveCheck() {
+            this.$children.forEach((t) => {
+                if (t.focus) {
+                    this.setActive(t);
+                }
+            });
+        },
+    },
+});
+</script>
+
+<style>
+.u-tabbed-view {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+}
+
+.u-tabbed-view-tabs {
+    padding-top: 15px;
+}
+
+.u-tabbed-view-tab {
+    display: inline-block;
+    cursor: pointer;
+    border-width: 0;
+    border-style: solid;
+    background: #fff;
+    font-weight: 600;
+    opacity: 1;
+    z-index: 1;
+    margin-bottom: -3px;
+    position: relative;
+    width: auto;
+    text-align: left;
+    box-sizing: border-box;
+    padding: 0.5em 1em;
+    border-bottom: 3px solid rgba(0, 0, 0, 0.1);
+    transition: border 0.3s;
+}
+
+.u-tabbed-view-tab:hover,
+.u-tabbed-view-tab--active {
+    border-bottom-width: 3px;
+}
+
+.u-tabbed-view-tab:last-of-type {
+    z-index: 1;
+    border-radius: 0 4px 0 0;
+}
+
+.u-tabbed-content {
+    overflow: auto;
+    height: 100%;
+}
+
+@media screen and (max-width: 769px) {
+    .u-tabbed-view-tabs {
+        padding-top: 0;
+    }
+
+    .u-tabbed-view-tab {
+        padding: 10px 20px;
+        width: auto;
+    }
+}
+</style>

package/apps/web/upstream/src/components/utils/TransitionExpand.vue

@@ -0,0 +1,97 @@
+<template>
+    <transition
+        name="u-transition-expand"
+        @enter="enter"
+        @after-enter="afterEnter"
+        @leave="leave"
+    >
+        <div v-if="$slots.default"><slot /></div>
+    </transition>
+</template>
+
+<script>
+'kiwi public';
+
+const Vue = require('vue');
+
+// Code created from https://markus.oberlehner.net/blog/transition-to-height-auto-with-vue/
+
+export default Vue.component('transition-expand', {
+    name: 'TransitionExpand',
+    methods: {
+        enter(element) {
+            const width = getComputedStyle(element).width;
+
+            element.style.width = width;
+            element.style.position = 'absolute';
+            element.style.visibility = 'hidden';
+            element.style.height = 'auto';
+
+            const height = getComputedStyle(element).height;
+
+            element.style.width = null;
+            element.style.position = null;
+            element.style.visibility = null;
+            element.style.height = 0;
+
+            // Force repaint to make sure the
+            // animation is triggered correctly.
+            // eslint-disable-next-line no-unused-expressions
+            getComputedStyle(element).height;
+
+            // Trigger the animation.
+            // We use `requestAnimationFrame` because we need
+            // to make sure the browser has finished
+            // painting after setting the `height`
+            // to `0` in the line above.
+            requestAnimationFrame(() => {
+                element.style.height = height;
+            });
+        },
+        afterEnter(element) {
+            element.style.height = 'auto';
+        },
+        leave(element) {
+            const height = getComputedStyle(element).height;
+
+            element.style.height = height;
+
+            // Force repaint to make sure the
+            // animation is triggered correctly.
+            // eslint-disable-next-line no-unused-expressions
+            getComputedStyle(element).height;
+
+            requestAnimationFrame(() => {
+                element.style.height = 0;
+            });
+        },
+    },
+});
+</script>
+
+<style>
+.u-transition-expand-enter-active,
+.u-transition-expand-leave-active {
+    transition: height 0.2s, opacity 0.2s;
+    overflow: hidden;
+}
+
+.u-transition-expand-enter,
+.u-transition-expand-leave-to {
+    opacity: 0;
+    height: 0;
+}
+</style>
+
+<style scoped>
+/*
+    try to force the browser into optimizing the animation
+    using hardware acceleration
+*/
+* {
+    will-change: height;
+    transform: translateZ(0);
+    backface-visibility: hidden;
+    perspective: 1000px;
+}
+</style>

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

@@ -0,0 +1,128 @@
+'kiwi public';
+
+/** @module */
+
+/**
+ * Converts a hex CSS color value to RGB.
+ * Adapted from http://stackoverflow.com/a/5624139.
+ *
+ * @param   {String}  _hex     The hexadecimal color value
+ * @return  {Object}          The RGB representation
+ */
+export function hex2rgb(_hex) {
+    // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
+    let shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+    let hex = _hex.replace(shorthandRegex, (m, r, g, b) => r + r + g + g + b + b);
+
+    let result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? {
+        r: parseInt(result[1], 16),
+        g: parseInt(result[2], 16),
+        b: parseInt(result[3], 16),
+    } : null;
+}
+
+/**
+ * Converts an RGB color value to a hex string.
+ * @param  {Object} rgb RGB as r, g, and b keys
+ * @return {String}     Hex color string
+ */
+export function rgb2hex(rgb) {
+    return '#' + ['r', 'g', 'b']
+        .map((key) => ('0' + rgb[key].toString(16)).slice(-2))
+        .join('');
+}
+
+/**
+ * Converts an RGB color value to HSL. Conversion formula adapted from
+ * http://en.wikipedia.org/wiki/HSL_color_space. This function adapted
+ * from http://stackoverflow.com/a/9493060.
+ * Assumes r, g, and b are contained in the set [0, 255] and
+ * returns h, s, and l in the set [0, 1].
+ *
+ * @param   Object  rgb     RGB as r, g, and b keys
+ * @return  Object          HSL as h, s, and l keys
+ */
+export function rgb2hsl(rgb) {
+    let r = rgb.r;
+    let g = rgb.g;
+    let b = rgb.b;
+
+    r /= 255;
+    g /= 255;
+    b /= 255;
+
+    let max = Math.max(r, g, b);
+    let min = Math.min(r, g, b);
+    let h = 0;
+    let s = 0;
+    let l = (max + min) / 2;
+
+    if (max === min) {
+        h = s = 0; // achromatic
+    } else {
+        let d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        if (max === r) {
+            h = (g - b) / d + (g < b ? 6 : 0);
+        } else if (max === g) {
+            h = (b - r) / d + 2;
+        } else if (max === b) {
+            h = (r - g) / d + 4;
+        }
+        h /= 6;
+    }
+
+    return { h, s, l };
+}
+
+/**
+ * Converts an HSL color value to RGB. Conversion formula adapted from
+ * http://en.wikipedia.org/wiki/HSL_color_space. This function adapted
+ * from http://stackoverflow.com/a/9493060.
+ * Assumes h, s, and l are contained in the set [0, 1] and
+ * returns r, g, and b in the set [0, 255].
+ *
+ * @param   Object  hsl     HSL as h, s, and l keys
+ * @return  Object          RGB as r, g, and b values
+ */
+export function hsl2rgb(hsl) {
+    function hue2rgb(_p, _q, _t) {
+        let p = _p;
+        let q = _q;
+        let t = _t;
+        if (t < 0) t += 1;
+        if (t > 1) t -= 1;
+        if (t < 1 / 6) return p + (q - p) * 6 * t;
+        if (t < 1 / 2) return q;
+        if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+    }
+
+    let h = hsl.h;
+    let s = hsl.s;
+    let l = hsl.l;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+
+    if (s === 0) {
+        r = g = b = l; // achromatic
+    } else {
+        let q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        let p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+    }
+
+    return {
+        r: Math.round(r * 255),
+        g: Math.round(g * 255),
+        b: Math.round(b * 255),
+    };
+}
+
+export function rgb2rgbString(rgb) {
+    return 'rgb(' + [rgb.r, rgb.g, rgb.b].join(',') + ')';
+}

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

@@ -0,0 +1,26 @@
+'kiwi public';
+
+export function extbanAccount(network) {
+    // Eg. InspIRCd-2.0
+    // Eg. UnrealIRCd-4.0.17
+    // Eg. ircd-seven-1.1.7
+    // Eg. u2.10.12.10+snircd(1.3.4a)
+    let ircdType = network.ircd.toLowerCase();
+
+    // Eg. ~,qjncrRa
+    // Eg. ,qjncrRa
+    let extban = network.ircClient.network.supports('EXTBAN') || '';
+    if (!extban) {
+        return '';
+    }
+
+    let prefix = extban.split(',')[0];
+    let type = 'a';
+
+    // https://docs.inspircd.org/3/modules/services_account/#extended-bans
+    if (ircdType.indexOf('inspircd') > -1) {
+        type = 'R';
+    }
+
+    return prefix + type;
+}

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

@@ -0,0 +1,193 @@
+'kiwi public';
+
+/** @module */
+
+/* eslint-disable */
+// http://www.myersdaily.org/joseph/javascript/md5-text.html
+
+function md5cycle(x, k) {
+    var a = x[0], b = x[1], c = x[2], d = x[3];
+
+    a = ff(a, b, c, d, k[0], 7, -680876936);
+    d = ff(d, a, b, c, k[1], 12, -389564586);
+    c = ff(c, d, a, b, k[2], 17,  606105819);
+    b = ff(b, c, d, a, k[3], 22, -1044525330);
+    a = ff(a, b, c, d, k[4], 7, -176418897);
+    d = ff(d, a, b, c, k[5], 12,  1200080426);
+    c = ff(c, d, a, b, k[6], 17, -1473231341);
+    b = ff(b, c, d, a, k[7], 22, -45705983);
+    a = ff(a, b, c, d, k[8], 7,  1770035416);
+    d = ff(d, a, b, c, k[9], 12, -1958414417);
+    c = ff(c, d, a, b, k[10], 17, -42063);
+    b = ff(b, c, d, a, k[11], 22, -1990404162);
+    a = ff(a, b, c, d, k[12], 7,  1804603682);
+    d = ff(d, a, b, c, k[13], 12, -40341101);
+    c = ff(c, d, a, b, k[14], 17, -1502002290);
+    b = ff(b, c, d, a, k[15], 22,  1236535329);
+
+    a = gg(a, b, c, d, k[1], 5, -165796510);
+    d = gg(d, a, b, c, k[6], 9, -1069501632);
+    c = gg(c, d, a, b, k[11], 14,  643717713);
+    b = gg(b, c, d, a, k[0], 20, -373897302);
+    a = gg(a, b, c, d, k[5], 5, -701558691);
+    d = gg(d, a, b, c, k[10], 9,  38016083);
+    c = gg(c, d, a, b, k[15], 14, -660478335);
+    b = gg(b, c, d, a, k[4], 20, -405537848);
+    a = gg(a, b, c, d, k[9], 5,  568446438);
+    d = gg(d, a, b, c, k[14], 9, -1019803690);
+    c = gg(c, d, a, b, k[3], 14, -187363961);
+    b = gg(b, c, d, a, k[8], 20,  1163531501);
+    a = gg(a, b, c, d, k[13], 5, -1444681467);
+    d = gg(d, a, b, c, k[2], 9, -51403784);
+    c = gg(c, d, a, b, k[7], 14,  1735328473);
+    b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+    a = hh(a, b, c, d, k[5], 4, -378558);
+    d = hh(d, a, b, c, k[8], 11, -2022574463);
+    c = hh(c, d, a, b, k[11], 16,  1839030562);
+    b = hh(b, c, d, a, k[14], 23, -35309556);
+    a = hh(a, b, c, d, k[1], 4, -1530992060);
+    d = hh(d, a, b, c, k[4], 11,  1272893353);
+    c = hh(c, d, a, b, k[7], 16, -155497632);
+    b = hh(b, c, d, a, k[10], 23, -1094730640);
+    a = hh(a, b, c, d, k[13], 4,  681279174);
+    d = hh(d, a, b, c, k[0], 11, -358537222);
+    c = hh(c, d, a, b, k[3], 16, -722521979);
+    b = hh(b, c, d, a, k[6], 23,  76029189);
+    a = hh(a, b, c, d, k[9], 4, -640364487);
+    d = hh(d, a, b, c, k[12], 11, -421815835);
+    c = hh(c, d, a, b, k[15], 16,  530742520);
+    b = hh(b, c, d, a, k[2], 23, -995338651);
+
+    a = ii(a, b, c, d, k[0], 6, -198630844);
+    d = ii(d, a, b, c, k[7], 10,  1126891415);
+    c = ii(c, d, a, b, k[14], 15, -1416354905);
+    b = ii(b, c, d, a, k[5], 21, -57434055);
+    a = ii(a, b, c, d, k[12], 6,  1700485571);
+    d = ii(d, a, b, c, k[3], 10, -1894986606);
+    c = ii(c, d, a, b, k[10], 15, -1051523);
+    b = ii(b, c, d, a, k[1], 21, -2054922799);
+    a = ii(a, b, c, d, k[8], 6,  1873313359);
+    d = ii(d, a, b, c, k[15], 10, -30611744);
+    c = ii(c, d, a, b, k[6], 15, -1560198380);
+    b = ii(b, c, d, a, k[13], 21,  1309151649);
+    a = ii(a, b, c, d, k[4], 6, -145523070);
+    d = ii(d, a, b, c, k[11], 10, -1120210379);
+    c = ii(c, d, a, b, k[2], 15,  718787259);
+    b = ii(b, c, d, a, k[9], 21, -343485551);
+
+    x[0] = add32(a, x[0]);
+    x[1] = add32(b, x[1]);
+    x[2] = add32(c, x[2]);
+    x[3] = add32(d, x[3]);
+
+}
+
+function cmn(q, a, b, x, s, t) {
+a = add32(add32(a, q), add32(x, t));
+return add32((a << s) | (a >>> (32 - s)), b);
+}
+
+function ff(a, b, c, d, x, s, t) {
+return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+}
+
+function gg(a, b, c, d, x, s, t) {
+return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+}
+
+function hh(a, b, c, d, x, s, t) {
+return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function ii(a, b, c, d, x, s, t) {
+return cmn(c ^ (b | (~d)), a, b, x, s, t);
+}
+
+function md51(s) {
+    //txt = '';
+    var n = s.length,
+    state = [1732584193, -271733879, -1732584194, 271733878], i;
+    for (i=64; i<=s.length; i+=64) {
+    md5cycle(state, md5blk(s.substring(i-64, i)));
+    }
+    s = s.substring(i-64);
+    var tail = [0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0];
+    for (i=0; i<s.length; i++)
+    tail[i>>2] |= s.charCodeAt(i) << ((i%4) << 3);
+    tail[i>>2] |= 0x80 << ((i%4) << 3);
+    if (i > 55) {
+    md5cycle(state, tail);
+    for (i=0; i<16; i++) tail[i] = 0;
+    }
+    tail[14] = n*8;
+    md5cycle(state, tail);
+    return state;
+}
+
+/* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ */
+function md5blk(s) { /* I figured global was faster.   */
+    var md5blks = [], i; /* Andy King said do it this way. */
+    for (i=0; i<64; i+=4) {
+    md5blks[i>>2] = s.charCodeAt(i)
+    + (s.charCodeAt(i+1) << 8)
+    + (s.charCodeAt(i+2) << 16)
+    + (s.charCodeAt(i+3) << 24);
+    }
+    return md5blks;
+}
+
+var hex_chr = '0123456789abcdef'.split('');
+
+function rhex(n){
+    var s='', j=0;
+    for(; j<4; j++)
+    s += hex_chr[(n >> (j * 8 + 4)) & 0x0F]
+    + hex_chr[(n >> (j * 8)) & 0x0F];
+    return s;
+}
+
+function hex(x) {
+    for (var i=0; i<x.length; i++)
+    x[i] = rhex(x[i]);
+    return x.join('');
+}
+
+function md5(s) {
+    return hex(md51(s));
+}
+
+/* this function is much faster,
+so if possible we use it. Some IEs
+are the only ones I know of that
+need the idiotic second function,
+generated by an if clause.  */
+
+function add32(a, b) {
+    return (a + b) & 0xFFFFFFFF;
+}
+
+if (md5('hello') != '5d41402abc4b2a76b9719d911017c592') {
+    function add32(x, y) {
+        var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+        msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+        return (msw << 16) | (lsw & 0xFFFF);
+    }
+}
+
+
+export {md5};