discord.js-selfv13 13.0.1

package/test/random.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const Discord = require('../');
+const request = require('superagent');
+const fs = require('fs');
+
+console.time('magic');
+
+const client = new Discord.Client({ fetchAllMembers: true, apiRequestMethod: 'sequential' });
+
+const { email, password, token, usertoken, song } = require('./auth.json');
+
+client.login(token).then(atoken => console.log('logged in with token ' + atoken)).catch(console.error);
+
+client.on('ready', () => {
+  console.log(`ready with ${client.users.size} users`);
+  console.timeEnd('magic');
+});
+
+client.on('debug', console.log);
+
+client.on('error', m => console.log('debug', new Error(m).stack));
+client.on('reconnecting', m => console.log('reconnecting', m));
+
+client.on('message', message => {
+  if (true) {
+    if (message.content === 'makechann') {
+      if (message.channel.guild) {
+        message.channel.guild.createChannel('hi', 'text').then(console.log);
+      }
+    }
+
+    if (message.content === 'imma queue pls') {
+      let count = 0;
+      let ecount = 0;
+      for(let x = 0; x < 4000; x++) {
+        message.channel.send(`this is message ${x} of 3999`)
+          .then(m => {
+            count++;
+            console.log('reached', count, ecount);
+          })
+          .catch(m => {
+            console.error(m);
+            ecount++;
+            console.log('reached', count, ecount);
+          });
+      }
+    }
+
+    if (message.content === 'myperms?') {
+      message.channel.send('Your permissions are:\n' +
+        JSON.stringify(message.channel.permissionsFor(message.author).serialize(), null, 4));
+    }
+
+    if (message.content === 'delchann') {
+      message.channel.delete().then(chan => console.log('selfDelChann', chan.name));
+    }
+
+    if (message.content.startsWith('setname')) {
+      message.channel.setName(message.content.substr(8));
+    }
+
+    if (message.content.startsWith('botname')) {
+      client.user.setUsername(message.content.substr(8));
+    }
+
+    if (message.content.startsWith('botavatar')) {
+      request
+        .get('url')
+        .end((err, res) => {
+          client.user.setAvatar(res.body).catch(console.error)
+            .then(user => message.channel.send('Done!'));
+        });
+    }
+
+    if (message.content.startsWith('gn')) {
+      message.guild.setName(message.content.substr(3))
+        .then(guild => console.log('guild updated to', guild.name))
+        .catch(console.error);
+    }
+
+    if (message.content === 'leave') {
+      message.guild.leave().then(guild => console.log('left guild', guild.name)).catch(console.error);
+    }
+
+    if (message.content === 'stats') {
+      let m = '';
+      m += `I am aware of ${message.guild.channels.size} channels\n`;
+      m += `I am aware of ${message.guild.members.size} members\n`;
+      m += `I am aware of ${client.channels.size} channels overall\n`;
+      m += `I am aware of ${client.guilds.size} guilds overall\n`;
+      m += `I am aware of ${client.users.size} users overall\n`;
+      message.channel.send(m).then(msg => msg.edit('nah')).catch(console.error);
+    }
+
+    if (message.content === 'messageme!') {
+      message.author.send('oh, hi there!').catch(e => console.log(e.stack));
+    }
+
+    if (message.content === 'don\'t dm me') {
+      message.author.deleteDM();
+    }
+
+    if (message.content.startsWith('kick')) {
+      message.guild.member(message.mentions[0]).kick().then(member => {
+        console.log(member);
+        message.channel.send('Kicked!' + member.user.username);
+      }).catch(console.error);
+    }
+
+    if (message.content === 'ratelimittest') {
+      let i = 1;
+      const start = Date.now();
+      while (i <= 20) {
+        message.channel.send(`Testing my rates, item ${i} of 20`);
+        i++;
+      }
+      message.channel.send('last one...').then(m => {
+        const diff = Date.now() - start;
+        m.reply(`Each message took ${diff / 21}ms to send`);
+      });
+    }
+
+    if (message.content === 'makerole') {
+      message.guild.createRole().then(role => {
+        message.channel.send(`Made role ${role.name}`);
+      }).catch(console.error);
+    }
+  }
+});
+
+function nameLoop(user) {
+  // user.setUsername(user.username + 'a').then(nameLoop).catch(console.error);
+}
+
+function chanLoop(channel) {
+  channel.setName(channel.name + 'a').then(chanLoop).catch(console.error);
+}
+
+client.on('message', msg => {
+  if (msg.content.startsWith('?raw')) {
+    msg.channel.send('```' + msg.content + '```');
+  }
+
+  if (msg.content.startsWith('#eval') && msg.author.id === '66564597481480192') {
+    try {
+      const com = eval(msg.content.split(" ").slice(1).join(" "));
+      msg.channel.send('```\n' + com + '```');
+    } catch(e) {
+      msg.channel.send('```\n' + e + '```');
+    }
+  }
+});
+
+const ytdl = require('ytdl-core');
+
+let disp, con;
+
+client.on('message', msg => {
+  if (msg.content.startsWith('/play')) {
+    console.log('I am now going to play', msg.content);
+    const chan = msg.content.split(' ').slice(1).join(' ');
+        const s = ytdl(chan, {filter:'audioonly'}, { passes : 3 });
+    s.on('error', e => console.log(`e w stream 1 ${e}`));
+    con.playStream(s);
+  }
+  if (msg.content.startsWith('/join')) {
+    const chan = msg.content.split(' ').slice(1).join(' ');
+    msg.channel.guild.channels.get(chan).join()
+      .then(conn => {
+        con = conn;
+        msg.reply('done');
+        const s = ytdl(song, {filter:'audioonly'}, { passes : 3 });
+        s.on('error', e => console.log(`e w stream 2 ${e}`));
+        disp = conn.playStream(s);
+        conn.player.on('debug', console.log);
+        conn.player.on('error', err => console.log(123, err));
+      })
+      .catch(console.error);
+  }
+});
+
+client.on('messageReactionAdd', (reaction, user) => {
+  if (reaction.message.channel.id !== '222086648706498562') return;
+  reaction.message.channel.send(`${user.username} added reaction ${reaction.emoji}, count is now ${reaction.count}`);
+});
+
+client.on('messageReactionRemove', (reaction, user) => {
+  if (reaction.message.channel.id !== '222086648706498562') return;
+  reaction.message.channel.send(`${user.username} removed reaction ${reaction.emoji}, count is now ${reaction.count}`);
+});
+
+client.on('message', m => {
+  if (m.content.startsWith('#reactions')) {
+    const mID = m.content.split(' ')[1];
+    m.channel.fetchMessage(mID).then(rM => {
+      for (const reaction of rM.reactions.values()) {
+        reaction.fetchUsers().then(users => {
+          m.channel.send(
+            `The following gave that message ${reaction.emoji}:\n` +
+            `${users.map(u => u.username).map(t => `- ${t}`).join('\n')}`
+          );
+        });
+      }
+    });
+  }
+});

package/test/shard.js

@@ -0,0 +1,31 @@
+const Discord = require('../');
+const { token } = require('./auth.json');
+
+const client = new Discord.Client({
+  shardId: process.argv[2],
+  shardCount: process.argv[3],
+});
+
+client.on('message', msg => {
+  if (msg.content.startsWith('?eval') && msg.author.id === '66564597481480192') {
+    try {
+      const com = eval(msg.content.split(' ').slice(1).join(' '));
+      msg.channel.sendMessage('```\n' + com + '```');
+    } catch (e) {
+      msg.channel.sendMessage('```\n' + e + '```');
+    }
+  }
+});
+
+process.send(123);
+
+client.on('ready', () => {
+  console.log('Ready', client.options.shardId);
+  if (client.options.shardId === 0)
+    setTimeout(() => {
+      console.log('kek dying');
+      client.destroy();
+    }, 5000);
+});
+
+client.login(token).catch(console.error);

package/test/sharder.js

@@ -0,0 +1,7 @@
+const Discord = require('../');
+
+const sharder = new Discord.ShardingManager(`${process.cwd()}/test/shard.js`, 4, false);
+
+sharder.on('launch', shard => console.log(`launched ${shard.id}`));
+
+sharder.spawn(4);

package/test/voice.js

@@ -0,0 +1,78 @@
+/* eslint no-console: 0 */
+'use strict';
+
+const Discord = require('../');
+const ytdl = require('ytdl-core');
+
+const client = new Discord.Client({ fetchAllMembers: false, apiRequestMethod: 'sequential' });
+
+const auth = require('./auth.json');
+
+client.login(auth.token).then(() => console.log('logged')).catch(console.error);
+
+const connections = new Map();
+
+let broadcast;
+
+client.on('message', m => {
+  if (!m.guild) return;
+  if (m.content.startsWith('/join')) {
+    const channel = m.guild.channels.get(m.content.split(' ')[1]) || m.member.voiceChannel;
+    if (channel && channel.type === 'voice') {
+      channel.join().then(conn => {
+        conn.player.on('error', (...e) => console.log('player', ...e));
+        if (!connections.has(m.guild.id)) connections.set(m.guild.id, { conn, queue: [] });
+        m.reply('ok!');
+      });
+    } else {
+      m.reply('Specify a voice channel!');
+    }
+  } else if (m.content.startsWith('/play')) {
+    if (connections.has(m.guild.id)) {
+      const connData = connections.get(m.guild.id);
+      const queue = connData.queue;
+      const url = m.content.split(' ').slice(1).join(' ')
+        .replace(/</g, '')
+        .replace(/>/g, '');
+      queue.push({ url, m });
+      if (queue.length > 1) {
+        m.reply(`OK, that's going to play after ${queue.length - 1} songs`);
+        return;
+      }
+      doQueue(connData);
+    }
+  } else if (m.content.startsWith('/skip')) {
+    if (connections.has(m.guild.id)) {
+      const connData = connections.get(m.guild.id);
+      if (connData.dispatcher) {
+        connData.dispatcher.end();
+      }
+    }
+  } else if (m.content.startsWith('#eval') && m.author.id === '66564597481480192') {
+    try {
+      const com = eval(m.content.split(' ').slice(1).join(' '));
+      m.channel.sendMessage(`\`\`\`\n${com}\`\`\``);
+    } catch (e) {
+      console.log(e);
+      m.channel.sendMessage(`\`\`\`\n${e}\`\`\``);
+    }
+  }
+});
+
+function doQueue(connData) {
+  const conn = connData.conn;
+  const queue = connData.queue;
+  const item = queue[0];
+  if (!item) return;
+  const stream = ytdl(item.url, { filter: 'audioonly' }, { passes: 3 });
+  const dispatcher = conn.playStream(stream);
+  stream.on('info', info => {
+    item.m.reply(`OK, playing **${info.title}**`);
+  });
+  dispatcher.on('end', () => {
+    queue.shift();
+    doQueue(connData);
+  });
+  dispatcher.on('error', (...e) => console.log('dispatcher', ...e));
+  connData.dispatcher = dispatcher;
+}

package/test/webpack.html

@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>discord.js Webpack test</title>
+  <meta charset="utf-8" />
+</head>
+<body>
+  <script type="text/javascript" src="../webpack/discord.11.4.2.min.js"></script>
+  <script type="text/javascript">
+    (() => {
+      const client = window.client = new Discord.Client();
+
+      client.on('ready', () => {
+        console.log('[CLIENT] Ready!');
+      });
+
+      client.on('error', console.error);
+
+      client.ws.on('close', (event) => console.log('[CLIENT] Disconnect!', event));
+
+      client.on('message', (message) => {
+        console.log(message.author.username, message.author.id, message.content);
+        console.log(message.guild.roles.find("name", "Sever Staff"));
+      });
+
+      client.login(localStorage.token || window.token || prompt('token pls', 'abcdef123456'))
+      .then((token) => localStorage.token = token);
+    })();
+  </script>
+</body>
+</html>

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "typings/index.d.ts"
+    ]
+}

package/tslint.json

@@ -0,0 +1,62 @@
+{
+    "extends": [
+        "tslint-config-typings"
+    ],
+    "rules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "tabs"
+        ],
+        "no-duplicate-variable": true,
+        "no-unused-variable": [false],
+        "no-eval": true,
+        "no-internal-module": true,
+        "no-trailing-whitespace": true,
+        "no-unsafe-finally": true,
+        "no-var-keyword": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "quotemark": [
+            true,
+            "single"
+        ],
+        "semicolon": [
+            true,
+            "always"
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            }
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ]
+    }
+}

package/typings/discord.js-test.ts

@@ -0,0 +1,69 @@
+/// <reference path='index.d.ts' />
+
+import { Collector, Message, CollectorFilter, Client, CollectorHandler, MessageReaction, Collection, User, ReactionCollectorOptions, Snowflake } from 'discord.js';
+
+const client = new Client({
+	disableEveryone: false,
+	disabledEvents: ['GUILD_MEMBER_ADD']
+});
+
+client.on('message', (message) => {
+	if (message.content === 'hello') {
+		message.channel.sendMessage('o/');
+	}
+
+	const collector: ReactionCollector = new ReactionCollector(message,
+		(reaction: MessageReaction) => reaction.emoji.toString() === '👌',
+		{ time: 30e3 });
+	collector.on('end', collected => console.log(collected));
+});
+
+client.login('dsfsd754.4fds4f68d4f6sd46f4s.7878easfdsgdfFDSIJIO');
+
+export class TestCollector extends Collector<Snowflake, Message> {
+	public filter: CollectorFilter;
+	public constructor(client: Client, filter: CollectorFilter) {
+		super(client, filter);
+	}
+
+	public handle(message: Message): CollectorHandler<Snowflake, Message> {
+		return { key: message.id, value: message };
+	}
+
+	public cleanup(): void {}
+	public postCheck(): null { return null; }
+}
+
+class ReactionCollector extends Collector<Snowflake, MessageReaction> {
+	public message: Message;
+	public users: Collection<Snowflake, User>;
+	public total: number;
+	public options: ReactionCollectorOptions;
+	public constructor(message: Message, filter: CollectorFilter, options?: ReactionCollectorOptions) {
+		super(message.client, filter, options || {});
+		this.message = message;
+		this.users = new Collection<Snowflake, User>();
+		this.total = 0;
+		this.client.on('messageReactionAdd', this.listener);
+	}
+
+	public handle(reaction: MessageReaction): CollectorHandler<Snowflake, MessageReaction> {
+		if (reaction.message.id !== this.message.id) { return null; }
+		return {
+			key: reaction.emoji.id || reaction.emoji.name,
+			value: reaction
+		};
+	}
+
+	public postCheck(reaction: MessageReaction, user: User): string {
+		this.users.set(user.id, user);
+		if (this.options.max && ++this.total >= this.options.max) { return 'limit'; }
+		if (this.options.maxEmojis && this.collected.size >= this.options.maxEmojis) { return 'emojiLimit'; }
+		if (this.options.maxUsers && this.users.size >= this.options.maxUsers) { return 'userLimit'; }
+		return null;
+	}
+
+	public cleanup(): void {
+		this.client.removeListener('messageReactionAdd', this.listener as any);
+	}
+}