rubika 1.0.0

package/src/methods/index.ts

@@ -0,0 +1,223 @@
+import Bot from "../bot";
+
+// types
+
+import * as BotMethods from "./bot";
+import * as Advanced from "./advanced";
+import * as Utilities from "./utilities";
+import * as Files from "./files";
+import * as Messages from "./messages";
+import * as Chat from "./chat";
+import * as Settings from "./settings";
+
+import * as Types from "../types/interfaces";
+
+export default class Methods {
+  // advanced
+  async builder(
+    this: Bot,
+    ...args: Parameters<typeof Advanced.builder>
+  ): Promise<any> {
+    return Advanced.builder.apply(this, args);
+  }
+
+  // bot
+  async getMe(
+    this: Bot,
+    ...args: Parameters<typeof BotMethods.getMe>
+  ): Promise<Types.Bot> {
+    return BotMethods.getMe.apply(this, args);
+  }
+
+  // files
+  async getFile(
+    this: Bot,
+    ...args: Parameters<typeof Files.getFile>
+  ): Promise<any> {
+    return Files.getFile.apply(this, args);
+  }
+  async requestSendFile(
+    this: Bot,
+    ...args: Parameters<typeof Files.requestSendFile>
+  ): Promise<{ upload_url: string }> {
+    return Files.requestSendFile.apply(this, args);
+  }
+
+  async uploadFile(
+    this: Bot,
+    ...args: Parameters<typeof Files.uploadFile>
+  ): Promise<Types.UploadFile> {
+    return Files.uploadFile.apply(this, args);
+  }
+
+  async _sendFile(
+    this: Bot,
+    ...args: Parameters<typeof Files._sendFile>
+  ): Promise<Types.SendMessage> {
+    return Files._sendFile.apply(this, args);
+  }
+
+  async sendMessage(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendMessage>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendMessage.apply(this, args);
+  }
+  async sendMusic(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendMusic>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendMusic.apply(this, args);
+  }
+  async sendFile(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendFile>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendFile.apply(this, args);
+  }
+  async sendGif(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendGif>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendGif.apply(this, args);
+  }
+  async sendImage(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendImage>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendImage.apply(this, args);
+  }
+  async sendSticker(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendSticker>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendSticker.apply(this, args);
+  }
+  async sendVideo(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendVideo>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendVideo.apply(this, args);
+  }
+  async sendVoice(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendVoice>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendVoice.apply(this, args);
+  }
+
+  async sendPoll(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendPoll>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendPoll.apply(this, args);
+  }
+
+  async sendLocation(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendLocation>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendLocation.apply(this, args);
+  }
+
+  async sendContact(
+    this: Bot,
+    ...args: Parameters<typeof Messages.sendContact>
+  ): Promise<Types.SendMessage> {
+    return Messages.sendContact.apply(this, args);
+  }
+
+  async forwardMessage(
+    this: Bot,
+    ...args: Parameters<typeof Messages.forwardMessage>
+  ): Promise<Types.SendMessage> {
+    return Messages.forwardMessage.apply(this, args);
+  }
+
+  async editMessageText(
+    this: Bot,
+    ...args: Parameters<typeof Messages.editMessageText>
+  ): Promise<Types.SendMessage> {
+    return Messages.editMessageText.apply(this, args);
+  }
+
+  async deleteMessage(
+    this: Bot,
+    ...args: Parameters<typeof Messages.deleteMessage>
+  ): Promise<Types.SendMessage> {
+    return Messages.deleteMessage.apply(this, args);
+  }
+
+  async editMessageKeypad(
+    this: Bot,
+    ...args: Parameters<typeof Messages.editMessageKeypad>
+  ): Promise<Types.SendMessage> {
+    return Messages.editMessageKeypad.apply(this, args);
+  }
+
+  async editChatKeypad(
+    this: Bot,
+    ...args: Parameters<typeof Messages.editChatKeypad>
+  ): Promise<Types.SendMessage> {
+    return Messages.editChatKeypad.apply(this, args);
+  }
+
+  // chat
+  async getChat(
+    this: Bot,
+    ...args: Parameters<typeof Chat.getChat>
+  ): Promise<Types.Chat> {
+    return Chat.getChat.apply(this, args);
+  }
+
+  // utilities
+  async start(
+    this: Bot,
+    ...args: Parameters<typeof Utilities.start>
+  ): Promise<any> {
+    return Utilities.start.apply(this, args);
+  }
+
+  async run(
+    this: Bot,
+    ...args: Parameters<typeof Utilities.run>
+  ): Promise<any> {
+    return Utilities.run.apply(this, args);
+  }
+
+  async getUpdates(
+    this: Bot,
+    ...args: Parameters<typeof Utilities.getUpdates>
+  ): Promise<any> {
+    return Utilities.getUpdates.apply(this, args);
+  }
+
+  async __setupWebhook(
+    this: Bot,
+    ...args: Parameters<typeof Utilities.setupWebhook>
+  ): Promise<any> {
+    return Utilities.setupWebhook.apply(this, args);
+  }
+
+  async __polling(
+    this: Bot,
+    ...args: Parameters<typeof Utilities.polling>
+  ): Promise<any> {
+    return Utilities.polling.apply(this, args);
+  }
+
+  // settings
+  async setCommands(
+    this: Bot,
+    ...args: Parameters<typeof Settings.setCommands>
+  ): Promise<any> {
+    return Settings.setCommands.apply(this, args);
+  }
+
+  async updateBotEndpoints(
+    this: Bot,
+    ...args: Parameters<typeof Settings.updateBotEndpoints>
+  ): Promise<any> {
+    return Settings.updateBotEndpoints.apply(this, args);
+  }
+}

package/src/methods/messages/deleteMessage.ts

@@ -0,0 +1,14 @@
+import Bot from '../..';
+
+async function deleteMessage(
+	this: Bot,
+	chat_id: string,
+	message_id: string,
+) {
+	return await this.builder('deleteMessage', {
+		chat_id,
+		message_id,
+	});
+}
+
+export default deleteMessage;

package/src/methods/messages/editChatKeypad.ts

@@ -0,0 +1,20 @@
+import Bot from "../..";
+import { Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum } from "../../types/enums";
+
+async function editChatKeypad(
+  this: Bot,
+  chat_id: string,
+  chat_keypad: Keypad,
+  chat_keypad_type: ChatKeypadTypeEnum = ChatKeypadTypeEnum.New
+) {
+  const data = {
+    chat_id,
+    chat_keypad,
+    chat_keypad_type,
+  };
+
+  return await this.builder("editChatKeypad", data);
+}
+
+export default editChatKeypad;

package/src/methods/messages/editMessageKeypad.ts

@@ -0,0 +1,19 @@
+import Bot from "../..";
+import { InlineKeypad } from "../../types/interfaces";
+
+async function editMessageKeypad(
+  this: Bot,
+  chat_id: string,
+  message_id: string,
+  inline_keypad?: InlineKeypad
+) {
+  const data = {
+    chat_id,
+    message_id,
+    inline_keypad,
+  };
+
+  return await this.builder("editMessageKeypad", data);
+}
+
+export default editMessageKeypad;

package/src/methods/messages/editMessageText.ts

@@ -0,0 +1,16 @@
+import Bot from "../..";
+
+async function editMessageText(
+  this: Bot,
+  chat_id: string,
+  text: string,
+  message_id: string
+) {
+  return await this.builder("editMessageText", {
+    chat_id,
+    message_id,
+    text,
+  });
+}
+
+export default editMessageText;

package/src/methods/messages/forwardMessage.ts

@@ -0,0 +1,18 @@
+import Bot from "../..";
+
+async function forwardMessage(
+  this: Bot,
+  from_chat_id: string,
+  message_id: string,
+  to_chat_id: string,
+  disable_notification = false
+) {
+  return await this.builder("forwardMessage", {
+    from_chat_id,
+    message_id,
+    to_chat_id,
+    disable_notification,
+  });
+}
+
+export default forwardMessage;

package/src/methods/messages/index.ts

@@ -0,0 +1,36 @@
+import deleteMessage from './deleteMessage';
+import editChatKeypad from './editChatKeypad';
+import editMessageKeypad from './editMessageKeypad';
+import editMessageText from './editMessageText';
+import forwardMessage from './forwardMessage';
+import sendContact from './sendContact';
+import sendFile from './sendFile';
+import sendGif from './sendGif';
+import sendImage from './sendImage';
+import sendLocation from './sendLocation';
+import sendMessage from './sendMessage';
+import sendMusic from './sendMusic';
+import sendPoll from './sendPoll';
+import sendSticker from './sendSticker';
+import sendVideo from './sendVideo';
+import sendVoice from './sendVoice';
+
+
+export {
+	sendMessage,
+	sendPoll,
+	sendLocation,
+	sendContact,
+	forwardMessage,
+	editMessageText,
+	deleteMessage,
+	editMessageKeypad,
+	editChatKeypad,
+	sendMusic,
+	sendFile,
+	sendGif,
+	sendImage,
+	sendSticker,
+	sendVideo,
+	sendVoice,
+};

package/src/methods/messages/sendContact.ts

@@ -0,0 +1,40 @@
+import Bot from '../..';
+import { Keypad } from '../../types/interfaces';
+import { ChatKeypadTypeEnum } from '../../types/enums';
+
+async function sendContact(
+	this: Bot,
+	chat_id: string,
+	first_name: string,
+	last_name: string,
+	phone_number: string,
+	chat_keypad?: Keypad,
+	inline_keypad?: Keypad,
+	disable_notification = false,
+	reply_to_message_id?: string,
+	chat_keypad_type?: ChatKeypadTypeEnum,
+) {
+	const data = {
+		chat_id,
+		first_name,
+		last_name,
+		phone_number,
+		chat_keypad,
+		inline_keypad,
+		disable_notification,
+		reply_to_message_id,
+		chat_keypad_type,
+	};
+
+	if (chat_keypad && !chat_keypad_type) {
+		data.chat_keypad_type = ChatKeypadTypeEnum.New;
+	}
+
+	if (inline_keypad && chat_keypad_type) {
+		data.chat_keypad_type = ChatKeypadTypeEnum.None;
+	}
+
+	return await this.builder('sendContact', data);
+}
+
+export default sendContact;

package/src/methods/messages/sendFile.ts

@@ -0,0 +1,30 @@
+import Bot from "../..";
+import { InlineKeypad, Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum, FileTypeEnum } from "../../types/enums";
+import { FileSource } from "../../types/methods";
+
+async function sendFile(
+  this: Bot,
+  chat_id: string,
+  file: FileSource,
+  text?: string,
+  chat_keypad?: Keypad,
+  inline_keypad?: InlineKeypad,
+  disable_notification = false,
+  reply_to_message_id?: string,
+  chat_keypad_type?: ChatKeypadTypeEnum
+) {
+  return await this._sendFile(
+    chat_id,
+    file,
+    text,
+    FileTypeEnum.File,
+    chat_keypad,
+    inline_keypad,
+    disable_notification,
+    reply_to_message_id,
+    chat_keypad_type
+  );
+}
+
+export default sendFile;

package/src/methods/messages/sendGif.ts

@@ -0,0 +1,30 @@
+import Bot from '../..';
+import { InlineKeypad, Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum, FileTypeEnum } from "../../types/enums";
+import { FileSource } from "../../types/methods";
+
+async function sendGif(
+	this: Bot,
+	chat_id: string,
+	file: FileSource,
+	text?: string,
+	chat_keypad?: Keypad,
+	inline_keypad?: InlineKeypad,
+	disable_notification = false,
+	reply_to_message_id?: string,
+	chat_keypad_type?: ChatKeypadTypeEnum,
+) {
+	return await this._sendFile(
+		chat_id,
+		file,
+		text,
+		FileTypeEnum.Gif,
+		chat_keypad,
+		inline_keypad,
+		disable_notification,
+		reply_to_message_id,
+		chat_keypad_type,
+	);
+}
+
+export default sendGif;

package/src/methods/messages/sendImage.ts

@@ -0,0 +1,30 @@
+import Bot from '../..';
+import { InlineKeypad, Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum, FileTypeEnum } from "../../types/enums";
+import { FileSource } from "../../types/methods";
+
+async function sendImage(
+	this: Bot,
+	chat_id: string,
+	file: FileSource,
+	text?: string,
+	chat_keypad?: Keypad,
+	inline_keypad?: InlineKeypad,
+	disable_notification = false,
+	reply_to_message_id?: string,
+	chat_keypad_type?: ChatKeypadTypeEnum,
+) {
+	return await this._sendFile(
+		chat_id,
+		file,
+		text,
+		FileTypeEnum.Image,
+		chat_keypad,
+		inline_keypad,
+		disable_notification,
+		reply_to_message_id,
+		chat_keypad_type,
+	);
+}
+
+export default sendImage;

package/src/methods/messages/sendLocation.ts

@@ -0,0 +1,38 @@
+import Bot from "../..";
+import { Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum } from "../../types/enums";
+
+async function sendLocation(
+  this: Bot,
+  chat_id: string,
+  latitude: string,
+  longitude: string,
+  chat_keypad?: Keypad,
+  inline_keypad?: Keypad,
+  disable_notification = false,
+  reply_to_message_id?: string,
+  chat_keypad_type?: ChatKeypadTypeEnum
+) {
+  const data = {
+    chat_id,
+    latitude,
+    longitude,
+    chat_keypad,
+    inline_keypad,
+    disable_notification,
+    reply_to_message_id,
+    chat_keypad_type,
+  };
+
+  if (chat_keypad && !chat_keypad_type) {
+    data.chat_keypad_type = ChatKeypadTypeEnum.New;
+  }
+
+  if (inline_keypad && chat_keypad_type) {
+    data.chat_keypad_type = ChatKeypadTypeEnum.None;
+  }
+
+  return await this.builder("sendLocation", data);
+}
+
+export default sendLocation;

package/src/methods/messages/sendMessage.ts

@@ -0,0 +1,41 @@
+import Bot from "../..";
+import { InlineKeypad, Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum } from "../../types/enums";
+import { SendType } from "../../types/methods";
+import Markdown from "../../utils/parser";
+
+
+async function sendMessage(
+  this: Bot,
+  chat_id: string,
+  text: string,
+  chat_keypad?: Keypad,
+  inline_keypad?: InlineKeypad,
+  disable_notification = false,
+  reply_to_message_id?: string,
+  chat_keypad_type?: ChatKeypadTypeEnum
+) {
+  
+  let data: SendType = {
+    chat_id,
+    disable_notification,
+  };
+
+  if (text) data = { ...data, ...Markdown.toMetadata(text.trim()) };  
+  if (chat_keypad) data.chat_keypad = chat_keypad;
+  if (inline_keypad) data.inline_keypad = inline_keypad;
+  if (chat_keypad_type) data.chat_keypad_type = chat_keypad_type;
+  if (reply_to_message_id) data.reply_to_message_id = reply_to_message_id;
+
+  if (chat_keypad && !chat_keypad_type) {
+    data.chat_keypad_type = ChatKeypadTypeEnum.New;
+  }
+
+  if (inline_keypad && chat_keypad_type) {
+    data.chat_keypad_type = ChatKeypadTypeEnum.None;
+  }
+
+  return await this.builder("sendMessage", data);
+}
+
+export default sendMessage;

package/src/methods/messages/sendMusic.ts

@@ -0,0 +1,30 @@
+import Bot from '../..';
+import { InlineKeypad, Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum, FileTypeEnum } from "../../types/enums";
+import { FileSource } from "../../types/methods";
+
+async function sendMusic(
+	this: Bot,
+	chat_id: string,
+	file: FileSource,
+	text?: string,
+	chat_keypad?: Keypad,
+	inline_keypad?: InlineKeypad,
+	disable_notification = false,
+	reply_to_message_id?: string,
+	chat_keypad_type?: ChatKeypadTypeEnum,
+) {
+	return await this._sendFile(
+		chat_id,
+		file,
+		text,
+		FileTypeEnum.Music,
+		chat_keypad,
+		inline_keypad,
+		disable_notification,
+		reply_to_message_id,
+		chat_keypad_type,
+	);
+}
+
+export default sendMusic;

package/src/methods/messages/sendPoll.ts

@@ -0,0 +1,12 @@
+import Bot from "../..";
+
+async function sendPoll(
+  this: Bot,
+  chat_id: string,
+  question: string,
+  options: string[]
+) {
+  return await this.builder("sendPoll", { chat_id, question, options });
+}
+
+export default sendPoll;

package/src/methods/messages/sendSticker.ts

@@ -0,0 +1,38 @@
+import Bot from "../..";
+import { SendType } from "../../types/methods";
+import { ChatKeypadTypeEnum } from "../../types/enums";
+import { InlineKeypad, Keypad } from "../../types/interfaces";
+
+async function sendSticker(
+  this: Bot,
+  chat_id: string,
+  sticker_id: string,
+  chat_keypad?: Keypad,
+  inline_keypad?: InlineKeypad,
+  disable_notification = false,
+  reply_to_message_id?: string,
+  chat_keypad_type?: ChatKeypadTypeEnum
+) {
+  let data: SendType = {
+    chat_id,
+    sticker_id,
+    disable_notification,
+  };
+
+  if (chat_keypad) data.chat_keypad = chat_keypad;
+  if (inline_keypad) data.inline_keypad = inline_keypad;
+  if (chat_keypad_type) data.chat_keypad_type = chat_keypad_type;
+  if (reply_to_message_id) data.reply_to_message_id = reply_to_message_id;
+
+  if (chat_keypad && !chat_keypad_type) {
+    data.chat_keypad_type = ChatKeypadTypeEnum.New;
+  }
+
+  if (inline_keypad && chat_keypad_type) {
+    data.chat_keypad_type = ChatKeypadTypeEnum.None;
+  }
+
+  return await this.builder("sendSticker", data);
+}
+
+export default sendSticker;

package/src/methods/messages/sendVideo.ts

@@ -0,0 +1,30 @@
+import Bot from '../..';
+import { InlineKeypad, Keypad } from "../../types/interfaces";
+import { ChatKeypadTypeEnum, FileTypeEnum } from "../../types/enums";
+import { FileSource } from "../../types/methods";
+
+async function sendVideo(
+	this: Bot,
+	chat_id: string,
+	file: FileSource,
+	text?: string,
+	chat_keypad?: Keypad,
+	inline_keypad?: InlineKeypad,
+	disable_notification = false,
+	reply_to_message_id?: string,
+	chat_keypad_type?: ChatKeypadTypeEnum,
+) {
+	return await this._sendFile(
+		chat_id,
+		file,
+		text,
+		FileTypeEnum.Video,
+		chat_keypad,
+		inline_keypad,
+		disable_notification,
+		reply_to_message_id,
+		chat_keypad_type,
+	);
+}
+
+export default sendVideo;