From 333fa1e40280c24ae122bc65f022c39b592048b4 Mon Sep 17 00:00:00 2001 From: phillips1012 Date: Mon, 18 May 2015 20:32:47 -0600 Subject: [PATCH] add typings for node-irc --- node-irc/node-irc-tests.ts | 52 +++ node-irc/node-irc.d.ts | 877 +++++++++++++++++++++++++++++++++++++ 2 files changed, 929 insertions(+) create mode 100644 node-irc/node-irc-tests.ts create mode 100644 node-irc/node-irc.d.ts diff --git a/node-irc/node-irc-tests.ts b/node-irc/node-irc-tests.ts new file mode 100644 index 0000000000..1ea58c2ddd --- /dev/null +++ b/node-irc/node-irc-tests.ts @@ -0,0 +1,52 @@ +// https://github.com/martynsmith/node-irc/blob/master/example/bot.js +import irc = require('irc'); + +let bot = new irc.Client('irc.dollyfish.net.nz', 'nodebot', { + debug: true, + channels: ['#blah', '#test'] +}); + +bot.addListener('error', ((message) => { + console.error('ERROR: %s: %s', message.command, message.args.join(' ')); +})); + +bot.addListener('message#blah', ((from, message) => { + console.log('<%s> %s', from, message); +})); + +bot.addListener('message', ((from, to, message) => { + console.log('%s => %s: %s', from, to, message); + + if (to.match(/^[#&]/)) { + // channel message + if (message.match(/hello/i)) { + bot.say(to, 'Hello there ' + from); + } + if (message.match(/dance/)) { + setTimeout(() => { bot.say(to, '\u0001ACTION dances: :D\\-<\u0001'); }, 1000); + setTimeout(() => { bot.say(to, '\u0001ACTION dances: :D|-<\u0001'); }, 2000); + setTimeout(() => { bot.say(to, '\u0001ACTION dances: :D/-<\u0001'); }, 3000); + setTimeout(() => { bot.say(to, '\u0001ACTION dances: :D|-<\u0001'); }, 4000); + } + } + else { + // private message + console.log('private message'); + } +})); + +bot.addListener('pm', ((nick, message) => { + console.log('Got private message from %s: %s', nick, message); +})); + +bot.addListener('join', ((channel, who) => { + console.log('%s has joined %s', who, channel); +})); + +bot.addListener('part', ((channel, who, reason) => { + console.log('%s has left %s: %s', who, channel, reason); +})); + +bot.addListener('kick', ((channel, who, by, reason) => { + console.log('%s was kicked from %s by %s: %s', who, channel, by, reason); +})); diff --git a/node-irc/node-irc.d.ts b/node-irc/node-irc.d.ts new file mode 100644 index 0000000000..a5a3666434 --- /dev/null +++ b/node-irc/node-irc.d.ts @@ -0,0 +1,877 @@ +// Type definitions for node-irc v0.3.12 +// Project: https://github.com/martynsmith/node-irc +// Definitions by: phillips1012 +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/** This library provides IRC client functionality. */ +declare module 'irc' { + import events = require('events'); + import crypto = require('crypto'); + import net = require('net'); + + /** This library provides IRC client functionality. */ + module NodeIRC { + /** A nick connect to an IRC server. */ + export class Client extends events.EventEmitter { + /** + * Socket to the server. Rarely, if ever needed. Use Client#send + * instead. + */ + public conn: net.Socket + + /** + * Channels joined. Includes channel modes, user list, and topic + * information. Only updated after the server recognizes the join. + */ + public chans: { + [index: string]: { + key: string; + serverName: string; + users: { + [index: string]: string; + }; + mode: string; + created: string; + } + } + + /** Features supported by the server */ + public supported: { + channel: { + idlength: string[]; + length: number; + limit: string[]; + modes: { + [index: string]: string; + } + types: string; + }; + + kicklength: number; + maxlist: number[]; + maxtargets: string[]; + modes: number; + nicklength: number + topiclength: number; + usermodes: string; + } + + /** + * The current nick of the client. Updated if the nick changes + */ + public nick: string; + + /** Channel listing data. */ + public channellist: IChannel[]; + + /** IRC server MOTD */ + public motd: string; + + /** Maximum line length */ + public maxLineLength: number; + + /** Bot options */ + public opt: IClientOpts; + + /** Host mask */ + public hostMask: string; + + /** + * Connect to an IRC server + * @param server - server hostname + * @param nick - nickname + * @param opts + */ + constructor( + server: string, + nick: string, + opts?: IClientOpts + ); + + /** + * Send a raw message to the server; generally speaking, it’s best + * not to use this method unless you know what you’re doing. + * @param command - irc command + * @param args - command arguments (splat) + */ + public send( + command: string, + ...args: string[] + ): void; + + /** + * Join the specified channel + * @param channel - channel to join + * @param callback + */ + public join( + channel: string, + callback?: handlers.IJoinChannel + ): void; + + /** + * Part the specified channel + * @param channel - channel to part + * @param message - optional message to send + * @param callback + */ + public part( + channel: string, + message: string, + callback: handlers.IPartChannel + ): void; + + /** + * Send a message to the specified target + * @param target - nick or channel + * @param message - message to send + */ + public say( + target: string, + message: string + ): void; + + /** + * Send a CTCP message to the specified target + * @param target - nick or channel + * @param type - "privmsg" for PRIVMSG, anything else for NOTICE + * @param text - CTCP message + */ + public ctcp( + target: string, + type: string, + text: string + ): void; + + /** + * Send an action to the specified target + * @param target - target + * @param message - message + */ + public action( + target: string, + message: string + ): void; + + /** + * Send a notice to the specified target. + * @param target - nick or channel + * @param message - message to send + */ + public notice( + target: string, + message: string + ): void; + + /** + * Request a whois for the specified nick + * @param nick - nickname + * @param callback + */ + public whois( + nick: string, + callback: handlers.IWhois + ): void; + + /** + * Request a channel listing from the server. The arguments for this + * are farily server specific, this method passes them as specified. + * + * Responses from the server are available via `channellist_start`, + * `channellist_item`, and `channellist` events. + * + * @param args - arguments + */ + public list( + ...args: string[] + ): void; + + /** + * Connect to the server. Use when `autoConnect` is false. + * @param retryCount - times to retry + * @param callback + */ + public connect( + retryCount?: number, + callback?: handlers.IRaw + ): void; + + /** + * Disconnect from the IRC server + * @param message - message to send + * @param callback + */ + public disconnect( + message: string, + callback: () => void + ): void; + + /** + * Activate flood protection “after the fact”. You can also use + * floodProtection while instantiating the Client to enable flood + * protection, and floodProtectionDelay to set the default message + * interval. + * @param interval - ms to wait between messages + */ + public activateFloodProtection( + interval: number + ): void; + } + + /** Client options object */ + export interface IClientOpts { + /** + * IRC username + * @default 'nodebot' + */ + userName?: string; + + /** + * IRC "real name" + * @default 'nodeJS IRC client' + */ + realName?: string; + + /** + * IRC connection port. See + * https://nodejs.org/api/net.html#net_socket_remoteport + * @default 6667 + */ + port?: number; + + /** + * Local interface to bind to for network connections. See + * https://nodejs.org/api/net.html#net_socket_localaddress + */ + localAddress?: string; + + /** + * Should we output debug messages to STDOUT? + * @default false + */ + debug?: boolean; + + /** + * Should we output IRC errors? + * @default false + */ + showErrors?: boolean; + + /** + * Should we auto-rejoin channels? + * @default false + */ + autoRejoin?: boolean; + + /** + * Should we auto-reconnect to networks? + * @default true + */ + autoConnect?: boolean; + + /** + * Channels to join + * @default [] + */ + channels?: string[]; + + /** + * Should SSL be used? Can either be true or crypto credentials. + * @default false + */ + secure?: boolean | crypto.Credentials; + + /** + * Should we accept self-signed certificates? + * @default false + */ + selfSigned?: boolean; + + + /** + * Should we accept expired certificates? + * @default false + */ + certExpired?: boolean; + + /** + * Should we queue our messages to ensure we don't get kicked? + * @default false + */ + floodProtection?: boolean; + + /** + * Delay between messages when flood protection is active + * @default 1000 + */ + floodProtectionDelay?: number; + + /** + * Should we use SASL authentication? + * @default false + */ + sasl?: boolean; + + /** + * Should we strip mIRC colors from the output messages? + * @default false + */ + stripColors?: boolean; + + /** + * Channel prefix + * @default '&#' + */ + channelPrefixes?: string; + + /** + * Characters to split a message at. + * @default 512 + */ + messageSplit?: number; + + /** + * Encoding to use. See + * https://nodejs.org/api/stream.html#stream_readable_setencoding_encoding + * @default 'utf-8' + */ + encoding?: string; + } + + /** Command types */ + export enum CommandType { + normal, reply, error + } + + /** Parsed IRC message. */ + export interface IMessage { + /** Prefix */ + prefix?: string; + + /** Mapped IRC command */ + command: string; + + /** Raw IRC command */ + rawCommand: string; + + /** Command type */ + commandType: CommandType; + + /** Command arguments */ + args: string[]; + } + + /** Whois data */ + export interface IWhoisData { + /** Nickname */ + nick: string; + + /** Username */ + user: string; + + /** Hostnamej */ + host: string; + + /** Real name" */ + realname: string; + + /** Channels */ + channels: string[]; + + /** Server */ + server: string; + + /** Server description string */ + serverinfo: string; + + /** Is this user an operator? */ + operator: string; + } + + /** A channel returned by a channel listing. */ + export interface IChannel { + /** Channel name */ + name: string; + + /** User count */ + users: string; + + /** Topic string */ + topic: string; + } + + /** + * Handler functions for Client. + */ + module handlers { + /** + * 'registered': Emitted when the server sends the initial 001 line, + * indicating you’ve connected to the server. See the raw event for + * details on the message object. + */ + export interface IRegistered { + /** + * @param message - raw message + */ + (message: IMessage): void; + } + + /** + * 'motd': Emitted when the server sends the message of the day to + * clients. + */ + export interface IMotd { + /** + * @param motd - motd string + */ + (motd: string): void; + } + + /** + * 'names': Emitted when the server sends a list of nicks for a channel + * (which happens immediately after joining and on request. The nicks + * object passed to the callback is keyed by nick names, and has + * values ‘’, ‘+’, or ‘@’ depending on the level of that nick in the + * channel. + */ + export interface INames { + /** + * @param channel - channel name + * @param nicks - nicks list + */ + (channel: string, nicks: string[]): void; + } + + /** + * 'names#*' As per ‘names’ event but only emits for the subscribed + * channel. + */ + export interface INamesChannel { + /** + * @param channel - channel name + * @param nicks - nicks list + */ + (nicks: string[]): void; + } + + /** + * 'topic': Emitted when the server sends the channel topic on joining + * a channel, or when a user changes the topic on a channel. See the + * raw event for details on the message object. + */ + export interface ITopic { + /** + * @param channel - channel name + * @param topic - topic + * @param nick - nick + * @param message - raw message + */ + ( + channel: string, + topic: string, + nick: string, + message: IMessage + ): void; + } + + /** + * 'join': Emitted when a user joins a channel (including when the + * client itself joins a channel). See the raw event for details on the + * message object. + */ + export interface IJoin { + /** + * @param channel - channel name + * @param nick - who joined + * @param message - raw message + */ + (channel: string, nick: string, message: IMessage): void; + } + + /** + * 'join#*': As per ‘join’ event but only emits for the subscribed + * channel. See the raw event for details on the message object. + */ + export interface IJoinChannel { + /** + * @param nick - who joined + * @param message - raw message + */ + (nick: string, message: IMessage): void; + } + + /** + * 'part': Emitted when a user parts a channel (including when the + * client itself parts a channel). See the raw event for details on the + * message object. + */ + export interface IPart { + /** + * @param channel - channel name + * @param nick - who parted + * @param reason - part reason + * @param message - raw message + */ + ( + channel: string, + nick: string, + reason: string, + message: IMessage + ): void + } + + /** + * 'part': As per ‘part’ event but only emits for the subscribed + * channel. See the raw event for details on the message object. + */ + export interface IPartChannel { + /** + * @param nick - who parted + * @param reason - part reason + * @param message - raw message + */ + ( + nick: string, + reason: string, + message: IMessage + ): void + } + + /** + * 'kick': Emitted when a user is kicked from a channel. See the raw + * event for details on the message object. + */ + export interface IKick { + /** + * @param channel - channel name + * @param nick - who was kicked + * @param by - kicker + * @param reason - kick reason + * @param message - raw message + */ + ( + channel: string, + nick: string, + by: string, + reason: string, + message: IMessage + ): void; + } + + /** + * 'kick#*': Emitted when a user is kicked from a channel. See the raw + * event for details on the message object. + */ + export interface IKickChannel { + /** + * @param nick - who was kicked + * @param by - kicker + * @param reason - kick reason + * @param message - raw message + */ + ( + nick: string, + by: string, + reason: string, + message: IMessage + ): void; + } + + /** + * 'message': Emitted when a message is sent. to can be either a nick + * (which is most likely this clients nick and means a private message), + * or a channel (which means a message to that channel). See the raw + * event for details on the message object. + */ + export interface IRecievedMessage { + /** + * @param nick - who sent the message + * @param to - to whom was the message sent + * @param text - message text + * @param message - raw message + */ + ( + nick: string, to: string, text: string, message: IMessage + ): void; + } + + /** + * 'message#': Emitted when a message is sent to any channel (i.e. + * exactly the same as the message event but excluding private + * messages. See the raw event for details on the message object. + */ + export interface IMessageAllChannels { + /** + * @param nick - who sent the message + * @param to - to whom was the message sent + * @param text - message text + * @param message - raw message + */ + ( + nick: string, to: string, text: string, message: IMessage + ): void; + } + + /** + * 'message#*': As per ‘message’ event but only emits for the + * subscribed channel. See the raw event for details on the message + * object. + */ + export interface IMessageChannel { + /** + * @param nick - who sent the message + * @param text - message text + * @param message - raw message + */ + (nick: string, text: string, message: IMessage): void; + } + + /** + * 'selfMessage': Emitted when a message is sent from the client. + * `to` is who the message was sent to. It can be either a nick + * (which most likely means a private message), or a channel (which + * means a message to that channel). + */ + export interface ISelfMessage { + (to: string, text: string): void; + } + + /** + * 'notice': Emitted when a notice is sent. to can be either a nick + * (which is most likely this clients nick and means a private + * message), or a channel (which means a message to that channel). nick + * is either the senders nick or null which means that the notice comes + * from the server. See the raw event for details on the message object. + */ + export interface INotice { + /** + * @param nick - from + * @param to - to + * @param text - text + * @param message - raw message + */ + (nick: string, to: string, text: string, message: IMessage): void; + } + + /** + * 'ping': Emitted when a server PINGs the client. The client will + * automatically send a PONG request just before this is emitted. + */ + export interface IPing { + /** + * @param server - server that adiministered the ping + */ + (server: string): void; + } + + /** + * 'pm': As per ‘message’ event but only emits when the message is + * direct to the client. See the raw event for details on the message + * object. + */ + export interface IPm { + /** + * @param nick - sender + * @param text - message text + * @param message - raw message + */ + (nick: string, text: string, message: IMessage): void; + } + + /** + * 'ctcp': Emitted when a CTCP notice or privmsg was received (type + * is either ‘notice’ or ‘privmsg’). See the raw event for details + * on the message object. + */ + export interface ICtcp { + /** + * @param from - sender + * @param to - recievier + * @param text - ctcp text + * @param type - ctcp type + * @param message - raw message + */ + ( + from: string, + to: string, + text: string, + type: string, + message: IMessage + ): void; + } + + + /** + * 'ctcp-*': Emitted when a specific type of CTCP request was + * recieved. + */ + export interface ICtcpSpecific { + /** + * @param from - sender + * @param to - recievier + * @param message - raw message + */ + ( + from: string, + to: string, + text: string, + message: IMessage + ): void; + + ( + from: string, + to: string, + text: string, + type: string, + message: IMessage + ): void; + } + + /** + * 'nick': Emitted when a user changes nick along with the channels + * the user is in. See the raw event for details on the message + * object. + */ + export interface INick { + /** + * @param oldnick - old nickname + * @param newnick - new nickname + * @param channels - channels the nick changed in + * @param message - raw message + */ + ( + oldnick: string, + newnick: string, + channels: string[], + message: IMessage + ): void; + } + + /** + * 'invite': Emitted when the client receives an /invite. See the + * raw event for details on the message object. + */ + export interface IInvite { + /** + * @param channel - channel user was invited to + * @param from - user who invited + * @param message - raw message + */ + (channel: string, from: string, message: IMessage): void; + } + + /** + * '+mode'/'-mode': Emitted when a mode is added or removed from a user or + * channel. channel is the channel which the mode is being set on/in + * . by is the user setting the mode. mode is the single character + * mode identifier. If the mode is being set on a user, argument is + * the nick of the user. If the mode is being set on a channel, + * argument is the argument to the mode. If a channel mode doesn’t + * have any arguments, argument will be ‘undefined’. See the raw + * event for details on the message object. + */ + export interface IModeChange { + /** + * @param channel - channel + * @param by - nick that changed mode + * @param mode - single character mode identifier + * @param argument - mode argument + * @param message - raw message + */ + ( + channel: string, + by: string, + mode: string, + argument: string, + message: IMessage + ): void; + } + + /** + * 'whois': Emitted whenever the server finishes outputting a WHOIS + * response. + */ + export interface IWhois { + (info: IWhoisData): void; + } + + /** + * 'channellist': Emitted when the server has finished returning a + * channel list. The channel_list array is simply a list of the + * objects that were returned in the intervening channellist_item + * events. + * + * This data is also available via the Client.channellist property + * after this event has fired. + */ + export interface IChannelList { + /** + * @param list - channels + */ + ( + list: IChannel[] + ): void; + } + + /** + * 'raw': Emitted when ever the client receives a “message” from + * the server. A message is a parsed line from the server. + */ + export interface IRaw { + /** + * @param message - raw message + */ + (message: IMessage): void; + } + + /** + * 'error': Emitted when ever the server responds with an error-type message. The message parameter is exactly as in the ‘raw’ event. + */ + export interface IError { + /** + * @param message - raw message + */ + (message: IMessage): void; + } + + /** + * 'action': Emitted whenever a user performs an action + * (e.g. /me waves). + */ + export interface IAction { + /** + * @param from - sender + * @param to - reciever + * @param text - text + * @param message - raw message + */ + ( + from: string, to: string, text: string, message: IMessage + ): void; + } + } + } + + /** Colors */ + module NodeIRC.colors { + /** + * Takes a color by name, text, and optionally what color to return. + * @param color - name of color + * @param text - text to color + * @param reset_color - color to set after text + */ + export function wrap( + color: string, text: string, reset_color?: string + ): string; + + /** + * This contains the set of colors available and a function to wrap + * text in a color. + */ + export const codes: { + [index: string]: string; + }; + } + + export = NodeIRC; +}