serverless-ircd 0.6.0 → 0.7.0

package/apps/web/upstream/static/themes/sky/theme.css

@@ -0,0 +1,107 @@
+@import '../common/base.css';
+
+:root {
+    /* Primary Variables */
+    --brand-primary: #78c9dc;
+    --brand-primary-hover: #8fd9ea;
+    --brand-midtone: #f1f1f1;
+    --brand-darktone: #969696;
+    --brand-default-bg: #fff;
+    --brand-default-fg: #22231f;
+
+    /* Warning colors */
+    --brand-notice: #f6c358;
+    --brand-warning: #fcb46e;
+    --brand-error: #bf5155;
+
+    /* Connection Indicator top */
+    --comp-workspace-before-bg: var(--brand-primary);
+    --comp-bg-kiwi-workspace--disconnected-after-bg: var(--brand-error);
+
+    /* Container Header */
+    --comp-header-bg: var(--brand-default-bg);
+    --comp-header-name-fg: var(--brand-default-fg);
+    --comp-header-option-active-fg: var(--brand-default-bg);
+    --comp-header-option-active-bg: var(--brand-primary);
+
+    /* StateBrowser */
+    --comp-statebrowser-fg: #fff;
+    --comp-statebrowser-bg: #4dafc5;
+    --comp-statebrowser-bg-networkname: #80c8d8;
+    --comp-statebrowser-channel-active-bg: #ffffff0d;
+    --comp-statebrowser-channel-active-fg: #fff;
+    --comp-usermenu-open-bg: #0e0e0e;
+    --comp-statebrowser-network-border: #656565;
+
+
+    /* Sidebars ( Right Side ) */
+    --comp-sidebar-bg: #fff;
+    --comp-sidebar-fg: #22231f;
+    --comp-aboutbuffer-bg: rgba(0, 0, 0, 0.03);
+    --comp-aboutbuffer-header-bg: #42b992;
+
+    /* Misc */
+    --brand-link-normal: var(--brand-primary);
+    --brand-link--hover: var(--brand-primary-hover);
+    --brand-shadow: rgba(0, 0, 0, 0.1);
+    --comp-border: #b2b2b2;
+}
+
+/* Welcome */
+.kiwi-startup-common-section-info {
+    border-left-color: var(--brand-primary);
+}
+
+/* StateBrowser */
+.kiwi-statebrowser-usermenu--open {
+    background-color: #5d919c;
+}
+.kiwi-statebrowser-network-status .u-link {
+    color: #fff;
+}
+.kiwi-network-name-options {
+    background-color: #7dc8d9;
+}
+.kiwi-statebrowser-channel-leave {
+    background: transparent;
+}
+
+/* Sidebar */
+.kiwi-aboutbuffer h4 {
+    background-color: #74c9dd;
+}
+
+/* IRC Text Colours */
+.irc-fg-colour-white { color: #fff; }
+.irc-fg-colour-black { color: #000; }
+.irc-fg-colour-blue { color: #00f; }
+.irc-fg-colour-green { color: #009300; }
+.irc-fg-colour-light-red { color: #ff5959; }
+.irc-fg-colour-brown { color: #743a00; }
+.irc-fg-colour-purple { color: #a500ff; }
+.irc-fg-colour-orange { color: #ff8c00; }
+.irc-fg-colour-yellow { color: #ff0; }
+.irc-fg-colour-light-green { color: #6fff6f; }
+.irc-fg-colour-cyan { color: #0cc; }
+.irc-fg-colour-light-cyan { color: #6dffff; }
+.irc-fg-colour-light-blue { color: #59b4ff; }
+.irc-fg-colour-pink { color: #f0f; }
+.irc-fg-colour-grey { color: #a6a6a6; }
+.irc-fg-colour-light-grey { color: #e2e2e2; }
+
+.irc-bg-colour-white { background-color: #fff; }
+.irc-bg-colour-black { background-color: #000; }
+.irc-bg-colour-blue { background-color: #00f; }
+.irc-bg-colour-green { background-color: #009300; }
+.irc-bg-colour-light-red { background-color: #ff5959; }
+.irc-bg-colour-brown { background-color: #743a00; }
+.irc-bg-colour-purple { background-color: #a500ff; }
+.irc-bg-colour-orange { background-color: #ff8c00; }
+.irc-bg-colour-yellow { background-color: #ff0; }
+.irc-bg-colour-light-green { background-color: #6fff6f; }
+.irc-bg-colour-cyan { background-color: #0cc; }
+.irc-bg-colour-light-cyan { background-color: #6dffff; }
+.irc-bg-colour-light-blue { background-color: #59b4ff; }
+.irc-bg-colour-pink { background-color: #f0f; }
+.irc-bg-colour-grey { background-color: #a6a6a6; }
+.irc-bg-colour-light-grey { background-color: #e2e2e2; }

package/apps/web/upstream/tests/unit/BatchAdd.spec.js

@@ -0,0 +1,174 @@
+import batchedAdd from '@/libs/batchedAdd';
+
+describe('batchedAdd.vue', () => {
+    const outOfTickItems = (batchFn, itemCount, endFn) => {
+        // Chain out of tick items so not to interfere
+        // with the timeout within batchedAdd.js
+        let count = 0;
+        const nextTimeout = () => {
+            count++;
+            if (count > itemCount) {
+                if (endFn) {
+                    endFn();
+                }
+                return;
+            }
+            setTimeout(() => {
+                batchFn('item' + count);
+                nextTimeout();
+            }, 10);
+        };
+        nextTimeout();
+    };
+
+    it('should return a batching function', () => {
+        let batch = batchedAdd();
+        expect(batch).toBeInstanceOf(Function);
+    });
+
+    it('should expose its queue', () => {
+        let batch = batchedAdd();
+        expect(batch.queue).toBeInstanceOf(Function);
+        expect(batch.queue()).toEqual([]);
+    });
+
+    it('should process three items without a batch', (done) => {
+        let itemCount = 0;
+        let singleItem = () => {
+            itemCount++;
+            if (itemCount === 3) {
+                done();
+            }
+        };
+        let batchItems = () => {
+            done(new Error('batch item caught'));
+        };
+
+        let batch = batchedAdd(singleItem, batchItems);
+        batch('item1');
+        batch('item2');
+        batch('item3');
+    });
+
+    it('should process 100 items on the same js tick without a batch', (done) => {
+        let itemCount = 0;
+        let singleItem = () => {
+            itemCount++;
+            if (itemCount === 100) {
+                done();
+            }
+        };
+        let batchItems = () => {
+            done(new Error('batch item caught'));
+        };
+
+        let batch = batchedAdd(singleItem, batchItems);
+        for (let i = 0; i < 100; i++) {
+            batch('item' + i);
+        }
+    });
+
+    it('should process 102 single items, then a batch of 3', (done) => {
+        let singleCount = 0;
+        let singleItem = () => {
+            singleCount++;
+        };
+        let batchItems = (items) => {
+            if (singleCount !== 102) {
+                return done(new Error('Expected 102 single items, found ' + singleCount));
+            }
+
+            if (items.length === 1) {
+                return done(new Error('Expected 3 batched items, found ' + items.length));
+            }
+
+            return done();
+        };
+
+        let batch = batchedAdd(singleItem, batchItems);
+        for (let i = 0; i < 100; i++) {
+            batch('item' + i);
+        }
+        outOfTickItems(batch, 5);
+    });
+
+    it('should process a batched item after three single items on different js ticks', (done) => {
+        let singleCount = 0;
+        let singleItem = () => {
+            singleCount++;
+            if (singleCount > 3) {
+                done(new Error('Expected 3 single items before a batch, found ' + singleCount));
+            }
+        };
+        let batchItems = () => {
+            if (singleCount !== 3) {
+                done(new Error('Expected 3 single items before a batch, found ' + singleCount));
+            } else {
+                done();
+            }
+        };
+
+        let batch = batchedAdd(singleItem, batchItems);
+        outOfTickItems(batch, 4);
+    });
+
+    it('should process 3 items in a batch', (done) => {
+        let singleItem = (item) => {};
+        let batchItems = (items) => {
+            if (items.length !== 3) {
+                done(new Error(`Expected 3 items in a batch, found ${items.length}`));
+            } else {
+                done();
+            }
+        };
+
+        let batch = batchedAdd(singleItem, batchItems);
+        outOfTickItems(batch, 6);
+    });
+
+    it('should process a single item after a batch has finished', (done) => {
+        let singleCount = 0;
+        let batchCount = 0;
+        let singleItem = () => {
+            if (singleCount === 3 && batchCount === 1) {
+                done();
+            }
+            singleCount++;
+        };
+        let batchItems = (items) => {
+            if (batchCount > 0) {
+                done(new Error('Processing a batch more than once'));
+            }
+            batchCount++;
+        };
+
+        let batch = batchedAdd(singleItem, batchItems);
+        outOfTickItems(batch, 6, () => {
+            setTimeout(() => {
+                // Should revert back to being a single item
+                batch('item7');
+            }, 1200);
+        });
+    });
+
+    it('should process 4 single items', (done) => {
+        let singleCount = 0;
+        let singleItem = () => {
+            singleCount++;
+            if (singleCount === 4) {
+                done();
+            }
+        };
+        let batchItems = (items) => {
+            done(new Error('Items should not be batched'));
+        };
+
+        let batch = batchedAdd(singleItem, batchItems);
+        outOfTickItems(batch, 3, () => {
+            setTimeout(() => {
+                // Should revert back to being a single item
+                batch('item4');
+            }, 1200);
+        });
+    }, 3000);
+});

package/apps/web/upstream/tests/unit/MessageParser.spec.js

@@ -0,0 +1,125 @@
+import parseMessage from '@/libs/MessageParser';
+
+describe('MessageParser.js', () => {
+    it('should return valid channel blocks', () => {
+        let tests = [
+            ['#channel', '#channel'],
+            ['#channel;', '#channel'],
+            ['#chan;nel', '#chan;nel'],
+            ['#channel.', '#channel'],
+            ['#chan;el;', '#chan;el'],
+            ['#chan[n]el,', '#chan[n]el'],
+            ['#channel.name,', '#channel.name'],
+            ['#channel.name.,', '#channel.name'],
+            ['#channel.,', '#channel'],
+            ['#channel-name,', '#channel-name'],
+            ['#channel_name,', '#channel_name'],
+            ['#channel&name,', '#channel&name'],
+            ['@#channel:', '#channel'],
+            ['@&channel,', '&channel'],
+            ['&@#channel,', '#channel'],
+            ['&@&channel,', '&channel'],
+        ];
+
+        tests.forEach((c) => {
+            let blocks = parseMessage(c[0]);
+            let channelBlocks = blocks.filter((b) => b.type === 'channel');
+
+            expect(channelBlocks.length).toEqual(1);
+            expect(channelBlocks[0].meta.channel).toEqual(c[1]);
+        });
+    });
+
+    it('should return valid url blocks', () => {
+        let tests = [
+            ['www.example.com', 'http://www.example.com'],
+            ['http://example.com'],
+            ['http://127.0.0.1'],
+            ['http://example.com:8080'],
+            ['http://127.0.0.1:8001'],
+            ['http://example.com/test.html?test=foo#bar'],
+            ['http://example.computer/some/path/test.html?test=foo#bar'],
+            ['http://127.0.0.1/test.html?test=foo#bar'],
+            ['https://www.example.com'],
+            ['https://127.0.0.1/test.html?test=foo#bar'],
+            ['http://2001:0000:1234:0000:0000:C1C0:ABCD:0876/'],
+            ['http://[2001:db8:1f70::999:de8:7648:6e8]:100/'],
+            ['ldap://[2001:db8::7]/c=GB?objectClass?one'],
+            ['(http://example.com)', 'http://example.com', '(', ')'],
+        ];
+
+        tests.forEach((c) => {
+            let blocks = parseMessage(c[0]);
+            let urlBlocks = blocks.filter((b) => b.type === 'url');
+            let compare = c.length >= 2 ? c[1] : c[0];
+
+            expect(urlBlocks.length).toEqual(1);
+            expect(urlBlocks[0].meta.url).toEqual(compare);
+            // check prefix and suffix
+            if (c.length === 4) {
+                expect(blocks[0].content).toEqual(c[2]);
+                expect(blocks[2].content).toEqual(c[3]);
+            }
+        });
+    });
+
+    it('should reject invalid urls', () => {
+        let tests = ['test', 'example.com', 'test:8080', '127.0.0.1/test.html'];
+
+        tests.forEach((c) => {
+            let blocks = parseMessage(c[0]);
+            let urlBlocks = blocks.filter((b) => b.type === 'url');
+            expect(urlBlocks.length).toEqual(0);
+        });
+    });
+
+    it('should return valid user blocks', () => {
+        // mock users list
+        let users = {
+            'TESTNICK1': { nick: 'TestNick1', username: 'testnick1', colour: '#a1fc5d' },
+            'TESTNICK2': { nick: 'TestNick2', username: 'testnick2', colour: '#7363fe' },
+            'TESTNICK3': { nick: 'TestNick3', username: 'testnick3' },
+            'TESTNICK4_': { nick: 'Test-Nick4_', username: 'testnick4' },
+            'TEST-NICK5': { nick: 'Test-Nick5', username: 'testnick5' },
+            'TESTNICK6-': { nick: 'TestNick6-', username: 'testnick6' },
+        };
+        let tests = [
+            ['testnick1', 'testnick1'],
+            ['TestNick1'],
+            ['TestNick2'],
+            ['Testnick3', 'Testnick3'],
+            ['testnick1:', 'testnick1'],
+            ['@testnick2', 'testnick2'],
+            ['@TestNick2:', 'TestNick2'],
+            ['tEsTnIcK4_.', 'tEsTnIcK4_'],
+            ['test-nick5'],
+            ['testnick6-'],
+        ];
+
+        tests.forEach((c) => {
+            let blocks = parseMessage(c[0], {}, users);
+            let userBlocks = blocks.filter((b) => b.type === 'user');
+            let compare = c.length === 2 ? c[1] : c[0];
+
+            expect(userBlocks.length).toEqual(1);
+            expect(userBlocks[0].meta.user).toEqual(compare);
+            expect(userBlocks[0].meta.colour).toEqual(users[compare.toUpperCase()].colour);
+        });
+    });
+
+    it('should reject invalid users', () => {
+        // mock users list
+        let users = {
+            TESTNICK1: { nick: 'TestNick1', username: 'testnick1' },
+            TESTNICK2: { nick: 'TestNick2', username: 'testnick2' },
+        };
+        let tests = ['notauser', 'ttestnick', 'testnick11', 'ttestnick11'];
+
+        tests.forEach((c) => {
+            let blocks = parseMessage(c[0], {}, users);
+            let userBlocks = blocks.filter((b) => b.type === 'user');
+
+            expect(userBlocks.length).toEqual(0);
+        });
+    });
+});

package/apps/web/upstream/tests/unit/Misc.spec.js

@@ -0,0 +1,24 @@
+import * as Misc from '@/helpers/Misc';
+
+describe('Misc.js', () => {
+    it('should find mentions of nickname in text', () => {
+        let tests = [
+            ['foo', 'foo', true], // on its own
+            ['Foo', 'foo', true], // different case
+            ['foo bar baz', 'foo', true], // start of line
+            ['baz foo bar', 'foo', true], // in middle of line
+            ['bar baz foo', 'foo', true], // end of line
+            ['missing', 'foo', false], // doesnt exist in text
+            ['baz food bar', 'foo', false], // dont trigger on substrings
+            ['hello food foo bar', 'foo', true], // when substring exists previously
+            ['hello, foo?', 'foo', true], // punctuation test
+            ['foo: hello', 'foo', true], // another
+            ['hello (foo)', 'foo', true], // another
+        ];
+
+        tests.forEach((c) => {
+            let doesMention = Misc.mentionsNick(c[0], c[1]);
+            expect(doesMention).toEqual(c[2]);
+        });
+    });
+});

package/apps/web/upstream/tests/unit/NetworkState.spec.js

@@ -0,0 +1,58 @@
+import state from '@/libs/state';
+import NetworkState from '@/libs/state/NetworkState';
+
+describe('NetworkState', () => {
+    it('should return a network state object', () => {
+        let s = state.create();
+        let network = s.addNetwork('TestNetwork', 'TestNick', {});
+        expect(network).toBeInstanceOf(NetworkState);
+        expect(network.name).toBe('TestNetwork');
+        expect(network.connection.nick).toBe('TestNick');
+        expect(network.appState).toBe(s);
+    });
+
+    it('should add a NetworkState to the global state', () => {
+        let s = state.create();
+        let network = s.addNetwork('TestNetwork', 'TestNick', {
+            server: 'irc.irc.com',
+        });
+        expect(s.networks.length).toEqual(1);
+        expect(s.networks[0]).toEqual(network);
+    });
+
+    it('should retrieve a NetworkState from the global state', () => {
+        let s = state.create();
+        let network = s.addNetwork('TestNetwork', 'TestNick', {
+            server: 'irc.irc.com',
+        });
+        expect(s.getNetwork(network.id)).toEqual(network);
+        expect(s.getNetworkFromAddress('irc.irc.com')).toEqual(network);
+        expect(s.getNetworkFromAddress('definitely.not.irc.irc.com')).toEqual(undefined);
+    });
+
+    it('automatically has a server buffer', () => {
+        let s = state.create();
+        let network = s.addNetwork('TestNetwork', 'TestNick', {});
+        expect(s.networks[0].buffers.length).toEqual(1);
+        expect(s.networks[0].buffers[0]).toEqual(network.serverBuffer());
+        expect(network.bufferByName('*')).toEqual(network.serverBuffer());
+    });
+
+    it('correctly adds buffers', () => {
+        let s = state.create();
+        let network = s.addNetwork('TestNetwork', 'TestNick', {});
+        let buffer = s.addBuffer(network.id, '#channel');
+        expect(s.networks[0].buffers.length).toEqual(2);
+        expect(network.buffers.length).toEqual(2);
+        expect(network.bufferByName('#channel')).toEqual(buffer);
+    });
+
+    it('correctly stores local network settings', () => {
+        let s = state.create();
+        let network = s.addNetwork('TestNetwork', 'TestNick', {});
+        expect(network.setting('setting_key')).toEqual(undefined);
+
+        network.setting('setting_key', 'some value');
+        expect(network.setting('setting_key')).toEqual('some value');
+    });
+});

package/apps/web/upstream/tests/unit/StartupError.spec.js

@@ -0,0 +1,20 @@
+import Vue from 'vue';
+import StartupError from '@/components/StartupError';
+
+Vue.mixin({
+    computed: {
+        $t() {
+            return (key, options) => key;
+        },
+    },
+});
+
+describe('StartupError.vue', () => {
+    it('should render correct contents', () => {
+        const vm = new Vue({
+            el: document.createElement('div'),
+            render: (h) => h(StartupError, { props: { error: 'some error' } }),
+        });
+        expect(vm.$el.querySelector('div').textContent).toEqual('some error');
+    });
+});

package/apps/web/upstream/vue.config.js

@@ -0,0 +1,150 @@
+const path = require('path');
+const fs = require('fs');
+const execSync = require('child_process').execSync;
+const DefinePlugin = require('webpack').DefinePlugin;
+const ProvidePlugin = require('webpack').ProvidePlugin;
+const CopyWebpackPlugin = require('copy-webpack-plugin');
+const StyleLintPlugin = require('stylelint-webpack-plugin');
+const ConvertLocalesPlugin = require('./build/webpack/convert-locales');
+const pkg = require('./package.json');
+
+const makeSourceMap = process.argv.indexOf('--nomap') === -1;
+
+module.exports = {
+    publicPath: '',
+    assetsDir: 'static/',
+    runtimeCompiler: true,
+    transpileDependencies: ['irc-framework', 'ip-regex', 'isomorphic-textencoder'],
+    productionSourceMap: makeSourceMap,
+    css: {
+        sourceMap: makeSourceMap,
+    },
+    configureWebpack: {
+        resolve: {
+            extensions: ['.js', '.vue', '.json'],
+            alias: {
+                vue$: 'vue/dist/vue.common.js',
+            },
+            fallback: {
+                stream: require.resolve('stream-browserify'),
+            },
+            // This prevents yarn link modules from getting linted
+            symlinks: false,
+        },
+        performance: {
+            maxEntrypointSize: 1677722, // 1.6MiB
+            maxAssetSize: 1048576, // 1MiB
+        },
+        optimization: {
+            splitChunks: {
+                cacheGroups: {
+                    // replace the vendors test so it does not chunk css files
+                    vendors: {
+                        name: 'vendor',
+                        test: (m) => /[\\/]node_modules[\\/]/.test(m.context) && m.constructor.name !== 'CssModule',
+                    },
+                },
+            },
+        },
+        plugins: [
+            new DefinePlugin({
+                __VERSION__: JSON.stringify(pkg.version),
+                __COMMITHASH__: JSON.stringify(getCommitHash()),
+            }),
+            new ProvidePlugin({
+                Buffer: ['buffer', 'Buffer'],
+            }),
+            new StyleLintPlugin({
+                files: ['src/**/*.{vue,htm,html,css,sss,less,scss}'],
+            }),
+            new ConvertLocalesPlugin(),
+            new CopyWebpackPlugin({
+                patterns: [
+                    {
+                        from: path.join(__dirname, 'static/'),
+                        to: path.join(__dirname, 'dist/static/'),
+                        toType: 'dir',
+                        globOptions: {
+                            ignore: ['**/.*', '**/config.local.json'],
+                        },
+                        info: { minimized: true },
+                    },
+                ],
+            }),
+        ],
+    },
+    chainWebpack: (config) => {
+        config.plugin('html').tap((args) => {
+            args[0].template = path.join(__dirname, 'index.html');
+            args[0].minify = false;
+            return args;
+        });
+
+        // add build/ to resolveLoader for exports-loader
+        config.resolveLoader.modules.add(path.resolve(__dirname, 'build/webpack/'));
+
+        // add exports-loader for GobalApi
+        const vueRule = config.module.rule('vue');
+        const vueOptions = vueRule.uses.get('vue-loader').get('options');
+        vueRule.uses.clear();
+        vueRule.use('exports-loader').loader('exports-loader');
+        vueRule.use('vue-loader').loader('vue-loader').options(vueOptions);
+
+        const jsRule = config.module.rule('js');
+        jsRule.uses.clear();
+        jsRule.use('exports-loader').loader('exports-loader');
+        jsRule.use('babel-loader').loader('babel-loader');
+
+        config.module
+            .rule('html')
+            .test(/\.html$/)
+            .exclude.add(path.join(__dirname, 'index.html')).end()
+            .use('html-loader')
+            .loader('html-loader');
+
+        // Remove the old 'app' entry
+        config.entryPoints.delete('app');
+
+        // IE11 required by the webpack runtime for async import().
+        // babel polyfills don't help us here
+        config.entry('app').add('core-js/features/promise');
+
+        // IE11 play nice with vue-virtual-scroller
+        config.entry('app').add('core-js/features/array/virtual/find-index');
+        config.entry('app').add('core-js/features/array/virtual/includes');
+
+        // Kiwiirc main entry point
+        config.entry('app').add('./src/main.js');
+    },
+};
+
+// override config.json with config.local.json if it exists
+if (process.env.NODE_ENV === 'development') {
+    let plugins = module.exports.configureWebpack.plugins;
+    let localConfig = path.resolve(__dirname, 'static/config.local.json');
+    if (fs.existsSync(localConfig)) {
+        plugins.push(new CopyWebpackPlugin({
+            patterns: [
+                {
+                    from: localConfig,
+                    to: path.join(__dirname, 'dist/static/config.json'),
+                    force: true,
+                },
+            ],
+        }));
+    }
+}
+
+function getCommitHash() {
+    let commitHash = 'unknown';
+    try {
+        commitHash = execSync('git rev-parse --short HEAD').toString().trim();
+        const modified = execSync('git diff-index --quiet HEAD -- || echo true').toString();
+        if (modified.trim() === 'true') {
+            commitHash += '-modified';
+        }
+    } catch {
+        console.error('Failed to get commit hash');
+    }
+    return commitHash;
+}