mirror of
https://github.com/discordjs/discord.js.git
synced 2026-03-09 16:13:31 +01:00
479 lines
40 KiB
JavaScript
479 lines
40 KiB
JavaScript
"use strict";exports.__esModule = true;var _createClass=(function(){function defineProperties(target,props){for(var i=0;i < props.length;i++) {var descriptor=props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if("value" in descriptor)descriptor.writable = true;Object.defineProperty(target,descriptor.key,descriptor);}}return function(Constructor,protoProps,staticProps){if(protoProps)defineProperties(Constructor.prototype,protoProps);if(staticProps)defineProperties(Constructor,staticProps);return Constructor;};})();function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{"default":obj};}function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError("Cannot call a class as a function");}}function _inherits(subClass,superClass){if(typeof superClass !== "function" && superClass !== null){throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);}subClass.prototype = Object.create(superClass && superClass.prototype,{constructor:{value:subClass,enumerable:false,writable:true,configurable:true}});if(superClass)Object.setPrototypeOf?Object.setPrototypeOf(subClass,superClass):subClass.__proto__ = superClass;}var _InternalClient=require("./InternalClient");var _InternalClient2=_interopRequireDefault(_InternalClient);var _events=require("events");var _events2=_interopRequireDefault(_events);var _StructuresPMChannel=require("../Structures/PMChannel");var _StructuresPMChannel2=_interopRequireDefault(_StructuresPMChannel); // This utility function creates an anonymous error handling wrapper function
|
|
// for a given callback. It is used to allow error handling inside the callback
|
|
// and using other means.
|
|
function errorCallback(callback){return function(error){callback(error);throw error;};} // This utility function creates an anonymous handler function to separate the
|
|
// error and the data arguments inside a callback and return the data if it is
|
|
// eventually done (for promise propagation).
|
|
function dataCallback(callback){return function(data){callback(null,data);return data;};} /**
|
|
* Used to interface with the Discord API.
|
|
*/var Client=(function(_EventEmitter){_inherits(Client,_EventEmitter); /**
|
|
* Used to instantiate Discord.Client
|
|
* @param {ClientOptions} [options] options that should be passed to the Client.
|
|
* @example
|
|
* // creates a new Client that will try to reconnect whenever it is disconnected.
|
|
* var client = new Discord.Client({
|
|
* revive : true
|
|
* });
|
|
*/function Client(){var options=arguments.length <= 0 || arguments[0] === undefined?{}:arguments[0];_classCallCheck(this,Client);_EventEmitter.call(this); /**
|
|
* Options that were passed to the client when it was instantiated.
|
|
* @readonly
|
|
* @type {ClientOptions}
|
|
*/this.options = options || {};this.options.compress = options.compress || !process.browser;this.options.revive = options.revive || false;this.options.rateLimitAsError = options.rateLimitAsError || false;this.options.largeThreshold = options.largeThreshold || 250;this.options.maxCachedMessages = options.maxCachedMessages || 1000; /**
|
|
* Internal Client that the Client wraps around.
|
|
* @readonly
|
|
* @type {InternalClient}
|
|
*/this.internal = new _InternalClient2["default"](this);} /**
|
|
* The users that the Client is aware of. Only available after `ready` event has been emitted.
|
|
* @type {Cache<User>} a Cache of the Users
|
|
* @readonly
|
|
* @example
|
|
* // log usernames of the users that the client is aware of
|
|
* for(var user of client.users){
|
|
* console.log(user.username);
|
|
* }
|
|
*/ /**
|
|
* Log the client in using a token. If you want to use methods such as `client.setUsername` or `client.setAvatar`, you must also pass the email and password parameters.
|
|
* @param {string} token A valid token that can be used to authenticate the account.
|
|
* @param {string} [email] Email of the Discord Account.
|
|
* @param {string} [password] Password of the Discord Account.
|
|
* @param {function(err: Error, token: string)} [callback] callback callback to the method
|
|
* @returns {Promise<string, Error>} Resolves with the token if the login was successful, otherwise it rejects with an error.
|
|
* @example
|
|
* // log the client in - callback
|
|
* client.login("token123", null, null, function(error, token){
|
|
* if(!error){
|
|
* console.log(token);
|
|
* }
|
|
* });
|
|
* @example
|
|
* // log the client in - promise
|
|
* client.login("token123")
|
|
* .then(token => console.log(token))
|
|
* .catch(err => console.log(err));
|
|
*/Client.prototype.loginWithToken = function loginWithToken(token){var email=arguments.length <= 1 || arguments[1] === undefined?null:arguments[1];var password=arguments.length <= 2 || arguments[2] === undefined?null:arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, token*/{}:arguments[3];if(typeof email === "function"){ // email is the callback
|
|
callback = email;email = null;password = null;}return this.internal.loginWithToken(token,email,password).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Log the client in using an email and password.
|
|
* @param {string} email Email of the Discord Account.
|
|
* @param {string} password Password of the Discord Account.
|
|
* @param {function(err: Error, token: string)} [callback] callback callback to the method
|
|
* @returns {Promise<string, Error>} Resolves with the token if the login was successful, otherwise it rejects with an error.
|
|
* @example
|
|
* // log the client in - callback
|
|
* client.login("jeff@gmail.com", "password", function(error, token){
|
|
* if(!error){
|
|
* console.log(token);
|
|
* }
|
|
* });
|
|
* @example
|
|
* // log the client in - promise
|
|
* client.login("jeff@gmail.com", "password")
|
|
* .then(token => console.log(token))
|
|
* .catch(err => console.log(err));
|
|
*/Client.prototype.login = function login(email,password){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, token*/{}:arguments[2];return this.internal.login(email,password).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Logs the client out gracefully and closes all WebSocket connections. Client still retains its Caches.
|
|
* @param {function(err: Error)} [callback] callback callback to the method
|
|
* @returns {Promise<null, Error>} Resolves with null if the logout was successful, otherwise it rejects with an error.
|
|
* @example
|
|
* // log the client out - callback
|
|
* client.logout(function(error){
|
|
* if(error){
|
|
* console.log("Couldn't log out.");
|
|
* }else{
|
|
* console.log("Logged out!");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // log the client out - promise
|
|
* client.logout()
|
|
* .then(() => console.log("Logged out!"))
|
|
* .catch(error => console.log("Couldn't log out."));
|
|
*/Client.prototype.logout = function logout(){var callback=arguments.length <= 0 || arguments[0] === undefined?function() /*err, {}*/{}:arguments[0];return this.internal.logout().then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Similar to log out but this should be used if you know you aren't going to be creating the Client again later in your program.
|
|
* @param {function(err: Error)} [callback] callback callback to the method
|
|
* @returns {Promise<null, Error>} Resolves with null if the destruction was successful, otherwise it rejects with an error.
|
|
* @example
|
|
* // destroy the client - callback
|
|
* client.destroy(function(error){
|
|
* if(error){
|
|
* console.log("Couldn't destroy client.");
|
|
* }else{
|
|
* console.log("Client destroyed!");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // destroy the client - promise
|
|
* client.destroy()
|
|
* .then(() => console.log("Client destroyed!"))
|
|
* .catch(error => console.log("Couldn't destroy client."));
|
|
*/Client.prototype.destroy = function destroy(){var _this=this;var callback=arguments.length <= 0 || arguments[0] === undefined?function() /*err, {}*/{}:arguments[0];return this.internal.logout().then(function(){return _this.internal.disconnected(true);}).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Sends a text message to the specified destination.
|
|
* @param {TextChannelResolvable} destination where the message should be sent
|
|
* @param {StringResolvable} content message you want to send
|
|
* @param {MessageOptions} [options] options you want to apply to the message
|
|
* @param {function(err: Error, msg: Message)} [callback] to the method
|
|
* @returns {Promise<Message, Error>} Resolves with a Message if successful, otherwise rejects with an Error.
|
|
* @example
|
|
* // sending messages
|
|
* client.sendMessage(channel, "Hi there!");
|
|
* client.sendMessage(user, "This is a PM message!");
|
|
* client.sendMessage(server, "This message was sent to the #general channel of the server!");
|
|
* client.sendMessage(channel, "This message is TTS.", {tts : true});
|
|
* @example
|
|
* // callbacks
|
|
* client.sendMessage(channel, "Hi there!", function(err, msg){
|
|
* if(err){
|
|
* console.log("Couldn't send message");
|
|
* }else{
|
|
* console.log("Message sent!");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // promises
|
|
* client.sendMessage(channel, "Hi there!")
|
|
* .then(msg => console.log("Message sent!"))
|
|
* .catch(err => console.log("Couldn't send message"));
|
|
*/Client.prototype.sendMessage = function sendMessage(destination,content){var options=arguments.length <= 2 || arguments[2] === undefined?{}:arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, msg*/{}:arguments[3];if(typeof options === "function"){ // options is the callback
|
|
callback = options;options = {};}return this.internal.sendMessage(destination,content,options).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Sends a TTS text message to the specified destination.
|
|
* @param {TextChannelResolvable} destination where the message should be sent
|
|
* @param {StringResolvable} content message you want to send
|
|
* @param {function(err: Error, msg: Message)} [callback] to the method
|
|
* @returns {Promise<Message, Error>} Resolves with a Message if successful, otherwise rejects with an Error.
|
|
* @example
|
|
* // sending messages
|
|
* client.sendTTSMessage(channel, "This message is TTS.");
|
|
* @example
|
|
* // callbacks
|
|
* client.sendTTSMessage(channel, "Hi there!", function(err, msg){
|
|
* if(err){
|
|
* console.log("Couldn't send message");
|
|
* }else{
|
|
* console.log("Message sent!");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // promises
|
|
* client.sendTTSMessage(channel, "Hi there!")
|
|
* .then(msg => console.log("Message sent!"))
|
|
* .catch(err => console.log("Couldn't send message"));
|
|
*/Client.prototype.sendTTSMessage = function sendTTSMessage(destination,content){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, msg*/{}:arguments[2];return this.sendMessage(destination,content,{tts:true}).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Replies to the author of a message in the same channel the message was sent.
|
|
* @param {MessageResolvable} message the message to reply to
|
|
* @param {StringResolvable} content message you want to send
|
|
* @param {MessageOptions} [options] options you want to apply to the message
|
|
* @param {function(err: Error, msg: Message)} [callback] to the method
|
|
* @returns {Promise<Message, Error>} Resolves with a Message if successful, otherwise rejects with an Error.
|
|
* @example
|
|
* // reply to messages
|
|
* client.reply(message, "Hello there!");
|
|
* client.reply(message, "Hello there, this is a TTS reply!", {tts:true});
|
|
* @example
|
|
* // callbacks
|
|
* client.reply(message, "Hi there!", function(err, msg){
|
|
* if(err){
|
|
* console.log("Couldn't send message");
|
|
* }else{
|
|
* console.log("Message sent!");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // promises
|
|
* client.reply(message, "Hi there!")
|
|
* .then(msg => console.log("Message sent!"))
|
|
* .catch(err => console.log("Couldn't send message"));
|
|
*/Client.prototype.reply = function reply(message,content){var options=arguments.length <= 2 || arguments[2] === undefined?{}:arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, msg*/{}:arguments[3];if(typeof options === "function"){ // options is the callback
|
|
callback = options;options = {};}var msg=this.internal.resolver.resolveMessage(message);if(msg){if(!(msg.channel instanceof _StructuresPMChannel2["default"])){content = msg.author + ", " + content;}return this.internal.sendMessage(msg,content,options).then(dataCallback(callback),errorCallback(callback));}var err=new Error("Destination not resolvable to a message!");callback(err);return Promise.reject(err);}; /**
|
|
* Replies to the author of a message in the same channel the message was sent using TTS.
|
|
* @param {MessageResolvable} message the message to reply to
|
|
* @param {StringResolvable} content message you want to send
|
|
* @param {function(err: Error, msg: Message)} [callback] to the method
|
|
* @returns {Promise<Message, Error>} Resolves with a Message if successful, otherwise rejects with an Error.
|
|
* @example
|
|
* // reply to messages
|
|
* client.replyTTS(message, "Hello there, this is a TTS reply!");
|
|
* @example
|
|
* // callbacks
|
|
* client.replyTTS(message, "Hi there!", function(err, msg){
|
|
* if(err){
|
|
* console.log("Couldn't send message");
|
|
* }else{
|
|
* console.log("Message sent!");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // promises
|
|
* client.replyTTS(message, "Hi there!")
|
|
* .then(msg => console.log("Message sent!"))
|
|
* .catch(err => console.log("Couldn't send message"));
|
|
*/Client.prototype.replyTTS = function replyTTS(message,content){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, msg*/{}:arguments[2];return this.reply(message,content,{tts:true}).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Deletes a message (if the client has permission to)
|
|
* @param {MessageResolvable} message the message to delete
|
|
* @param {MessageDeletionOptions} [options] options to apply when deleting the message
|
|
* @param {function(err: Error)} [callback] callback to the method
|
|
* @returns {Promise<null, Error>} Resolves with null if the deletion was successful, otherwise rejects with an Error.
|
|
* @example
|
|
* // deleting messages
|
|
* client.deleteMessage(message);
|
|
* client.deleteMessage(message, {wait:5000}); //deletes after 5 seconds
|
|
* @example
|
|
* // deleting messages - callback
|
|
* client.deleteMessage(message, function(err){
|
|
* if(err){
|
|
* console.log("couldn't delete");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // deleting messages - promise
|
|
* client.deleteMessage(message)
|
|
* .then(() => console.log("deleted!"))
|
|
* .catch(err => console.log("couldn't delete"));
|
|
*/Client.prototype.deleteMessage = function deleteMessage(message){var options=arguments.length <= 1 || arguments[1] === undefined?{}:arguments[1];var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];if(typeof options === "function"){ // options is the callback
|
|
callback = options;options = {};}return this.internal.deleteMessage(message,options).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Edits a previously sent message (if the client has permission to)
|
|
* @param {MessageResolvable} message the message to edit
|
|
* @param {StringResolvable} content the new content of the message
|
|
* @param {MessageOptions} [options] options to apply to the message
|
|
* @param {function(err: Error, msg: Message)} [callback] callback to the method
|
|
* @returns {Promise<Message, Error>} Resolves with the newly edited message if successful, otherwise rejects with an Error.
|
|
* @example
|
|
* // editing messages
|
|
* client.updateMessage(message, "This is an edit!");
|
|
* @example
|
|
* // editing messages - callback
|
|
* client.updateMessage(message, "This is an edit!", function(err, msg){
|
|
* if(err){
|
|
* console.log("couldn't edit");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // editing messages - promise
|
|
* client.updateMessage(message, "This is an edit!")
|
|
* .then(msg => console.log("edited!"))
|
|
* .catch(err => console.log("couldn't edit"));
|
|
*/Client.prototype.updateMessage = function updateMessage(message,content){var options=arguments.length <= 2 || arguments[2] === undefined?{}:arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, msg*/{}:arguments[3];if(typeof options === "function"){ // options is the callback
|
|
callback = options;options = {};}return this.internal.updateMessage(message,content,options).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Gets the logs of a channel with a specified limit, starting from the most recent message.
|
|
* @param {TextChannelResolvable} where the channel to get the logs of
|
|
* @param {Number} [limit=50] Integer, the maximum amount of messages to retrieve
|
|
* @param {ChannelLogsOptions} [options] options to use when getting the logs
|
|
* @param {function(err: Error, logs: Array<Message>)} [callback] callback to the method
|
|
* @returns {Promise<Array<Message>, Error>} Resolves with an array of messages if successful, otherwise rejects with an error.
|
|
* @example
|
|
* // log content of last 500 messages in channel - callback
|
|
* client.getChannelLogs(channel, 500, function(err, logs){
|
|
* if(!err){
|
|
* for(var message of logs){
|
|
* console.log(message.content);
|
|
* }
|
|
* }
|
|
* });
|
|
* @example
|
|
* // log content of last 500 messages in channel - promise
|
|
* client.getChannelLogs(channel, 500)
|
|
* .then(logs => {
|
|
* for(var message of logs){
|
|
* console.log(message.content);
|
|
* }
|
|
* })
|
|
* .catch(err => console.log("couldn't fetch logs"));
|
|
*/Client.prototype.getChannelLogs = function getChannelLogs(where){var limit=arguments.length <= 1 || arguments[1] === undefined?50:arguments[1];var options=arguments.length <= 2 || arguments[2] === undefined?{}:arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, logs*/{}:arguments[3];if(typeof options === "function"){ // options is the callback
|
|
callback = options;options = {};}else if(typeof limit === "function"){ // options is the callback
|
|
callback = limit;limit = 50;}return this.internal.getChannelLogs(where,limit,options).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Gets the banned users of a server (if the client has permission to)
|
|
* @param {ServerResolvable} server server to get banned users of
|
|
* @param {function(err: Error, bans: Array<User>)} [callback] callback to the method
|
|
* @returns {Promise<Array<User>, Error>} Resolves with an array of users if the request was successful, otherwise rejects with an error.
|
|
* @example
|
|
* // loop through banned users - callback
|
|
* client.getBans(server, function(err, bans){
|
|
* if(!err){
|
|
* for(var user of bans){
|
|
* console.log(user.username + " was banned from " + server.name);
|
|
* }
|
|
* }
|
|
* });
|
|
* @example
|
|
* // loop through banned users - promise
|
|
* client.getBans(server)
|
|
* .then(bans => {
|
|
* for(var user of bans){
|
|
* console.log(user.username + " was banned from " + server.name);
|
|
* }
|
|
* })
|
|
* .catch(err => console.log("couldn't get bans"));
|
|
*/Client.prototype.getBans = function getBans(server){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, bans*/{}:arguments[1];return this.internal.getBans(server).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Sends a file (embedded if possible) to the specified channel.
|
|
* @param {TextChannelResolvable} destination channel to send the file to
|
|
* @param {FileResolvable} attachment the file to send
|
|
* @param {string} name name of the file, especially including the extension
|
|
* @param {function(err: Error, msg: Message)} [callback] callback to the method
|
|
* @returns {Promise<msg: Message, err: Error>} resolves with the sent file as a message if successful, otherwise rejects with an error
|
|
* @example
|
|
* // send a file - callback
|
|
* client.sendFile(channel, new Buffer("Hello this a text file"), "file.txt", function(err, msg){
|
|
* if(err){
|
|
* console.log("Couldn't send file!");
|
|
* }
|
|
* });
|
|
* @example
|
|
* // send a file - promises
|
|
* client.sendFile(channel, "C:/path/to/file.txt", "file.txt")
|
|
* .then(msg => console.log("sent file!"))
|
|
* .catch(err => console.log("couldn't send file!"));
|
|
*/Client.prototype.sendFile = function sendFile(destination,attachment,name){var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, m*/{}:arguments[3];if(typeof name === "function"){ // name is the callback
|
|
callback = name;name = undefined; // Will get resolved into original filename in internal
|
|
}return this.internal.sendFile(destination,attachment,name).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Client accepts the specified invite to join a server. If the Client is already in the server, the promise/callback resolve immediately.
|
|
* @param {InviteIDResolvable} invite invite to the server
|
|
* @param {function(err: Error, server: Server)} [callback] callback to the method.
|
|
* @returns {Promise<Server, Error>} resolves with the newly joined server if succesful, rejects with an error if not.
|
|
* @example
|
|
* // join a server - callback
|
|
* client.joinServer("https://discord.gg/0BwZcrFhUKZ55bJL", function(err, server){
|
|
* if(!err){
|
|
* console.log("Joined " + server.name);
|
|
* }
|
|
* });
|
|
* @example
|
|
* // join a server - promises
|
|
* client.joinServer("https://discord.gg/0BwZcrFhUKZ55bJL")
|
|
* .then(server => console.log("Joined " + server.name))
|
|
* .catch(err => console.log("Couldn't join!"));
|
|
*/Client.prototype.joinServer = function joinServer(invite){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, srv*/{}:arguments[1];return this.internal.joinServer(invite).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Creates a Discord Server and joins it
|
|
* @param {string} name the name of the server
|
|
* @param {region} [region=london] the region of the server
|
|
* @param {function(err: Error, server: Server)} [callback] callback to the method
|
|
* @returns {Promise<Server, Error>} resolves with the newly created server if successful, rejects with an error if not.
|
|
* @example
|
|
* //creating a server - callback
|
|
* client.createServer("discord.js", "london", function(err, server){
|
|
* if(err){
|
|
* console.log("could not create server");
|
|
* }
|
|
* });
|
|
* @example
|
|
* //creating a server - promises
|
|
* client.createServer("discord.js", "london")
|
|
* .then(server => console.log("Made server!"))
|
|
* .catch(error => console.log("Couldn't make server!"));
|
|
*/Client.prototype.createServer = function createServer(name){var region=arguments.length <= 1 || arguments[1] === undefined?"london":arguments[1];var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, srv*/{}:arguments[2];return this.internal.createServer(name,region).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Leaves a Discord Server
|
|
* @param {ServerResolvable} server the server to leave
|
|
* @param {function(err: Error)} [callback] callback to the method
|
|
* @returns {Promise<null, Error>} resolves null if successful, otherwise rejects with an error.
|
|
*/Client.prototype.leaveServer = function leaveServer(server){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.leaveServer(server).then(dataCallback(callback),errorCallback(callback));}; // def updateServer
|
|
Client.prototype.updateServer = function updateServer(server,name,region){var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, srv*/{}:arguments[3];if(typeof region === "function"){ // region is the callback
|
|
callback = region;region = undefined;}return this.internal.updateServer(server,name,region).then(dataCallback(callback),errorCallback(callback));}; /**
|
|
* Deletes a Discord Server
|
|
* @param {ServerResolvable} server the server to leave
|
|
* @param {function(err: Error)} [callback] callback to the method
|
|
* @returns {Promise<null, Error>} resolves null if successful, otherwise rejects with an error.
|
|
*/Client.prototype.deleteServer = function deleteServer(server){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.deleteServer(server).then(dataCallback(callback),errorCallback(callback));}; // def createChannel
|
|
Client.prototype.createChannel = function createChannel(server,name){var type=arguments.length <= 2 || arguments[2] === undefined?"text":arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, channel*/{}:arguments[3];if(typeof type === "function"){ // options is the callback
|
|
callback = type;type = "text";}return this.internal.createChannel(server,name,type).then(dataCallback(callback),errorCallback(callback));}; // def deleteChannel
|
|
Client.prototype.deleteChannel = function deleteChannel(channel){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.deleteChannel(channel).then(dataCallback(callback),errorCallback(callback));}; // def banMember
|
|
Client.prototype.banMember = function banMember(user,server){var length=arguments.length <= 2 || arguments[2] === undefined?1:arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, {}*/{}:arguments[3];if(typeof length === "function"){ // length is the callback
|
|
callback = length;length = 1;}return this.internal.banMember(user,server,length).then(dataCallback(callback),errorCallback(callback));}; // def unbanMember
|
|
Client.prototype.unbanMember = function unbanMember(user,server){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.unbanMember(user,server).then(dataCallback(callback),errorCallback(callback));}; // def kickMember
|
|
Client.prototype.kickMember = function kickMember(user,server){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.kickMember(user,server).then(dataCallback(callback),errorCallback(callback));}; // def moveMember
|
|
Client.prototype.moveMember = function moveMember(user,channel){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.moveMember(user,channel).then(dataCallback(callback),errorCallback(callback));}; // def createRole
|
|
Client.prototype.createRole = function createRole(server){var data=arguments.length <= 1 || arguments[1] === undefined?null:arguments[1];var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, role*/{}:arguments[2];if(typeof data === "function"){ // data is the callback
|
|
callback = data;data = null;}return this.internal.createRole(server,data).then(dataCallback(callback),errorCallback(callback));}; // def updateRole
|
|
Client.prototype.updateRole = function updateRole(role){var data=arguments.length <= 1 || arguments[1] === undefined?null:arguments[1];var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, role*/{}:arguments[2];if(typeof data === "function"){ // data is the callback
|
|
callback = data;data = null;}return this.internal.updateRole(role,data).then(dataCallback(callback),errorCallback(callback));}; // def deleteRole
|
|
Client.prototype.deleteRole = function deleteRole(role){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.deleteRole(role).then(dataCallback(callback),errorCallback(callback));}; // def addMemberToRole
|
|
Client.prototype.addMemberToRole = function addMemberToRole(member,role){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.addMemberToRole(member,role).then(dataCallback(callback),errorCallback(callback));}; // def addUserToRole
|
|
Client.prototype.addUserToRole = function addUserToRole(member,role){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.addMemberToRole(member,role,callback);}; // def addUserToRole
|
|
Client.prototype.memberHasRole = function memberHasRole(member,role){return this.internal.memberHasRole(member,role);}; // def addUserToRole
|
|
Client.prototype.userHasRole = function userHasRole(member,role){return this.memberHasRole(member,role);}; // def removeMemberFromRole
|
|
Client.prototype.removeMemberFromRole = function removeMemberFromRole(member,role){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.removeMemberFromRole(member,role).then(dataCallback(callback),errorCallback(callback));}; // def removeUserFromRole
|
|
Client.prototype.removeUserFromRole = function removeUserFromRole(member,role){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.removeMemberFromRole(member,role,callback);}; // def createInvite
|
|
Client.prototype.createInvite = function createInvite(chanServ,options){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, invite*/{}:arguments[2];if(typeof options === "function"){ // options is the callback
|
|
callback = options;options = undefined;}return this.internal.createInvite(chanServ,options).then(dataCallback(callback),errorCallback(callback));}; // def deleteInvite
|
|
Client.prototype.deleteInvite = function deleteInvite(invite){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.deleteInvite(invite).then(dataCallback(callback),errorCallback(callback));}; // def getInvite
|
|
Client.prototype.getInvite = function getInvite(invite){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, inv*/{}:arguments[1];return this.internal.getInvite(invite).then(dataCallback(callback),errorCallback(callback));}; // def getInvites
|
|
Client.prototype.getInvites = function getInvites(channel){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, inv*/{}:arguments[1];return this.internal.getInvites(channel).then(dataCallback(callback),errorCallback(callback));}; // def overwritePermissions
|
|
Client.prototype.overwritePermissions = function overwritePermissions(channel,role){var options=arguments.length <= 2 || arguments[2] === undefined?{}:arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, {}*/{}:arguments[3];return this.internal.overwritePermissions(channel,role,options).then(dataCallback(callback),errorCallback(callback));}; // def setStatus
|
|
Client.prototype.setStatus = function setStatus(idleStatus,game){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];if(typeof game === "function"){ // game is the callback
|
|
callback = game;game = null;}else if(typeof idleStatus === "function"){ // idleStatus is the callback
|
|
callback = idleStatus;game = null;}return this.internal.setStatus(idleStatus,game).then(dataCallback(callback),errorCallback(callback));}; // def sendTyping
|
|
Client.prototype.sendTyping = function sendTyping(channel){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.sendTyping(channel).then(dataCallback(callback),errorCallback(callback));}; // def setChannelTopic
|
|
Client.prototype.setChannelTopic = function setChannelTopic(channel,topic){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.setChannelTopic(channel,topic).then(dataCallback(callback),errorCallback(callback));}; // def setChannelName
|
|
Client.prototype.setChannelName = function setChannelName(channel,name){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.setChannelName(channel,name).then(dataCallback(callback),errorCallback(callback));}; // def setChannelNameAndTopic
|
|
Client.prototype.setChannelNameAndTopic = function setChannelNameAndTopic(channel,name,topic){var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, {}*/{}:arguments[3];return this.internal.setChannelNameAndTopic(channel,name,topic).then(dataCallback(callback),errorCallback(callback));}; // def setChannelPosition
|
|
Client.prototype.setChannelPosition = function setChannelPosition(channel,position){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.setChannelPosition(channel,position).then(dataCallback(callback),errorCallback(callback));}; // def updateChannel
|
|
Client.prototype.updateChannel = function updateChannel(channel,data){var callback=arguments.length <= 2 || arguments[2] === undefined?function() /*err, {}*/{}:arguments[2];return this.internal.updateChannel(channel,data).then(dataCallback(callback),errorCallback(callback));}; // def startTyping
|
|
Client.prototype.startTyping = function startTyping(channel){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.startTyping(channel).then(dataCallback(callback),errorCallback(callback));}; // def stopTyping
|
|
Client.prototype.stopTyping = function stopTyping(channel){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.stopTyping(channel).then(dataCallback(callback),errorCallback(callback));}; // def updateDetails
|
|
Client.prototype.updateDetails = function updateDetails(details){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.updateDetails(details).then(dataCallback(callback),errorCallback(callback));}; // def setUsername
|
|
Client.prototype.setUsername = function setUsername(name){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.setUsername(name).then(dataCallback(callback),errorCallback(callback));}; // def setAvatar
|
|
Client.prototype.setAvatar = function setAvatar(avatar){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.internal.setAvatar(avatar).then(dataCallback(callback),errorCallback(callback));}; // def joinVoiceChannel
|
|
Client.prototype.joinVoiceChannel = function joinVoiceChannel(channel){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, channel*/{}:arguments[1];return this.internal.joinVoiceChannel(channel).then(dataCallback(callback),errorCallback(callback));}; // def leaveVoiceChannel
|
|
Client.prototype.leaveVoiceChannel = function leaveVoiceChannel(){var callback=arguments.length <= 0 || arguments[0] === undefined?function() /*err, {}*/{}:arguments[0];return this.internal.leaveVoiceChannel().then(dataCallback(callback),errorCallback(callback));}; // def awaitResponse
|
|
Client.prototype.awaitResponse = function awaitResponse(msg){var toSend=arguments.length <= 1 || arguments[1] === undefined?null:arguments[1];var _this2=this;var options=arguments.length <= 2 || arguments[2] === undefined?null:arguments[2];var callback=arguments.length <= 3 || arguments[3] === undefined?function() /*err, newMsg*/{}:arguments[3];var ret;if(toSend){if(typeof toSend === "function"){ // (msg, callback)
|
|
callback = toSend;toSend = null;options = null;}else { // (msg, toSend, ...)
|
|
if(options){if(typeof options === "function"){ //(msg, toSend, callback)
|
|
callback = options;options = null;ret = this.sendMessage(msg,toSend);}else { //(msg, toSend, options, callback)
|
|
ret = this.sendMessage(msg,toSend,options);}}else { // (msg, toSend) promise
|
|
ret = this.sendMessage(msg,toSend);}}}if(!ret){ret = Promise.resolve();} // (msg) promise
|
|
return ret.then(function(){return _this2.internal.awaitResponse(msg);}).then(dataCallback(callback),errorCallback(callback));};Client.prototype.setStatusIdle = function setStatusIdle(){var callback=arguments.length <= 0 || arguments[0] === undefined?function() /*err, {}*/{}:arguments[0];return this.internal.setStatus("idle").then(dataCallback(callback),errorCallback(callback));};Client.prototype.setStatusOnline = function setStatusOnline(){var callback=arguments.length <= 0 || arguments[0] === undefined?function() /*err, {}*/{}:arguments[0];return this.internal.setStatus("online").then(dataCallback(callback),errorCallback(callback));};Client.prototype.setStatusActive = function setStatusActive(callback){return this.setStatusOnline(callback);};Client.prototype.setStatusHere = function setStatusHere(callback){return this.setStatusOnline(callback);};Client.prototype.setStatusAvailable = function setStatusAvailable(callback){return this.setStatusOnline(callback);};Client.prototype.setStatusAway = function setStatusAway(callback){return this.setStatusIdle(callback);};Client.prototype.setPlayingGame = function setPlayingGame(game){var callback=arguments.length <= 1 || arguments[1] === undefined?function() /*err, {}*/{}:arguments[1];return this.setStatus(null,game,callback);}; //def forceFetchUsers
|
|
Client.prototype.forceFetchUsers = function forceFetchUsers(callback){return this.internal.forceFetchUsers().then(callback);};_createClass(Client,[{key:"users",get:function get(){return this.internal.users;} /**
|
|
* The server channels the Client is aware of. Only available after `ready` event has been emitted.
|
|
* @type {Cache<ServerChannel>} a Cache of the Server Channels
|
|
* @readonly
|
|
* @example
|
|
* // log the names of the channels and the server they belong to
|
|
* for(var channel of client.channels){
|
|
* console.log(`${channel.name} is part of ${channel.server.name}`)
|
|
* }
|
|
*/},{key:"channels",get:function get(){return this.internal.channels;} /**
|
|
* The servers the Client is aware of. Only available after `ready` event has been emitted.
|
|
* @type {Cache<Server>} a Cache of the Servers
|
|
* @readonly
|
|
* @example
|
|
* // log the names of the servers
|
|
* for(var server of client.servers){
|
|
* console.log(server.name)
|
|
* }
|
|
*/},{key:"servers",get:function get(){return this.internal.servers;} /**
|
|
* The PM/DM chats the Client is aware of. Only available after `ready` event has been emitted.
|
|
* @type {Cache<PMChannel>} a Cache of the PM/DM Channels.
|
|
* @readonly
|
|
* @example
|
|
* // log the names of the users the client is participating in a PM with
|
|
* for(var pm of client.privateChannels){
|
|
* console.log(`Participating in a DM with ${pm.recipient}`)
|
|
* }
|
|
*/},{key:"privateChannels",get:function get(){return this.internal.private_channels;} /**
|
|
* The active voice connection of the Client, or null if not applicable. Only available after `ready` event has been emitted.
|
|
* @type {VoiceConnection|null} the voice connection (if any).
|
|
*/},{key:"voiceConnection",get:function get(){return this.internal.voiceConnection;} /**
|
|
* Unix timestamp of when the Client first emitted the `ready `event. Only available after `ready` event has been emitted.
|
|
* @type {Number} timestamp of ready time
|
|
* @example
|
|
* // output when the client was ready
|
|
* console.log("I was first ready at " + client.readyTime);
|
|
*/},{key:"readyTime",get:function get(){return this.internal.readyTime;} /**
|
|
* How long the client has been ready for in milliseconds. Only available after `ready` event has been emitted.
|
|
* @type {Number} number in milliseconds representing uptime of the client
|
|
* @example
|
|
* // log how long the client has been up for
|
|
* console.log("I have been online for " + client.uptime + " milliseconds");
|
|
*/},{key:"uptime",get:function get(){return this.internal.uptime;} /**
|
|
* A User object that represents the account the client is logged into. Only available after `ready` event has been emitted.
|
|
* @type {User} user representing logged in account of client.
|
|
* @example
|
|
* // log username of logged in account of client
|
|
* console.log("Logged in as " + client.user.username);
|
|
*/},{key:"user",get:function get(){return this.internal.user;} /**
|
|
* Object containing user-agent information required for API requests. If not modified, it will use discord.js's defaults.
|
|
* @type {UserAgent}
|
|
* @example
|
|
* // log the stringified user-agent:
|
|
* console.log(client.userAgent.full);
|
|
*/},{key:"userAgent",get:function get(){return this.internal.userAgent;}, /**
|
|
* Set the user-agent information provided. Follows the UserAgent typedef format excluding the `full` property.
|
|
* @type {UserAgent}
|
|
*/set:function set(userAgent){this.internal.userAgent = userAgent;}}]);return Client;})(_events2["default"]);exports["default"] = Client;module.exports = exports["default"];
|