@mks2508/telegram-message-builder 0.2.0 → 0.3.1

package/src/types.test.ts

@@ -0,0 +1,539 @@
+import { describe, it, expect } from "bun:test";
+import type {
+  ParseMode,
+  ITelegramMessage,
+  IInlineKeyboardButton,
+  IInlineKeyboardMarkup,
+  IKeyboardButton,
+  IReplyKeyboardMarkup,
+  IForceReplyMarkup,
+} from "./types";
+import { TelegramMessageBuilder } from "./builder";
+import { TelegramKeyboardBuilder } from "./keyboard";
+import * as fmt from "../src";
+
+describe("Type Validation Tests", () => {
+  describe("ParseMode Type", () => {
+    it("should accept 'html' as valid ParseMode", () => {
+      const mode: ParseMode = "html";
+      expect(mode).toBe("html");
+    });
+
+    it("should accept 'markdown' as valid ParseMode", () => {
+      const mode: ParseMode = "markdown";
+      expect(mode).toBe("markdown");
+    });
+
+    it("should accept 'markdownv2' as valid ParseMode", () => {
+      const mode: ParseMode = "markdownv2";
+      expect(mode).toBe("markdownv2");
+    });
+
+    it("should reject invalid ParseMode values at compile time", () => {
+      // @ts-expect-error - Invalid ParseMode
+      const invalidMode: ParseMode = "invalid";
+      expect(invalidMode).not.toBe("html");
+    });
+  });
+
+  describe("ITelegramMessage Interface", () => {
+    it("should create valid TelegramMessage structure", () => {
+      const message: ITelegramMessage = {
+        text: "Test message",
+        parse_mode: "html",
+      };
+
+      expect(message.text).toBe("Test message");
+      expect(message.parse_mode).toBe("html");
+    });
+
+    it("should accept optional properties in TelegramMessage", () => {
+      const message: ITelegramMessage = {
+        text: "Test",
+        parse_mode: "markdown",
+        disable_web_page_preview: true,
+        disable_notification: false,
+        protect_content: true,
+      };
+
+      expect(message.disable_web_page_preview).toBe(true);
+      expect(message.disable_notification).toBe(false);
+      expect(message.protect_content).toBe(true);
+    });
+
+    it("should allow extra properties for Telegram Bot API options", () => {
+      const message: ITelegramMessage = {
+        text: "Test",
+        parse_mode: "html",
+        reply_to_message_id: 123,
+        allow_sending_without_reply: true,
+      };
+
+      expect(message.reply_to_message_id).toBe(123);
+      expect(message.allow_sending_without_reply).toBe(true);
+    });
+  });
+
+  describe("IInlineKeyboardButton Interface", () => {
+    it("should create URL button", () => {
+      const button: IInlineKeyboardButton = {
+        text: "Visit Website",
+        url: "https://example.com",
+      };
+
+      expect(button.text).toBe("Visit Website");
+      expect(button.url).toBe("https://example.com");
+    });
+
+    it("should create callback button", () => {
+      const button: IInlineKeyboardButton = {
+        text: "Click Me",
+        callback_data: "callback_123",
+      };
+
+      expect(button.text).toBe("Click Me");
+      expect(button.callback_data).toBe("callback_123");
+    });
+
+    it("should create web app button", () => {
+      const button: IInlineKeyboardButton = {
+        text: "Open Web App",
+        web_app: { url: "https://example.com/app" },
+      };
+
+      expect(button.web_app?.url).toBe("https://example.com/app");
+    });
+
+    it("should create login button", () => {
+      const button: IInlineKeyboardButton = {
+        text: "Login",
+        login_url: {
+          url: "https://example.com/auth",
+          forward_text: "Continue",
+          bot_username: "MyBot",
+          request_write_access: true,
+        },
+      };
+
+      expect(button.login_url?.url).toBe("https://example.com/auth");
+      expect(button.login_url?.forward_text).toBe("Continue");
+      expect(button.login_url?.bot_username).toBe("MyBot");
+      expect(button.login_url?.request_write_access).toBe(true);
+    });
+
+    it("should create switch inline query button", () => {
+      const button: IInlineKeyboardButton = {
+        text: "Search in chat",
+        switch_inline_query: "query",
+      };
+
+      expect(button.switch_inline_query).toBe("query");
+    });
+
+    it("should create switch inline query current chat button", () => {
+      const button: IInlineKeyboardButton = {
+        text: "Search here",
+        switch_inline_query_current_chat: "query",
+      };
+
+      expect(button.switch_inline_query_current_chat).toBe("query");
+    });
+
+    it("should create callback game button", () => {
+      const button: IInlineKeyboardButton = {
+        text: "Play Game",
+        callback_game: {},
+      };
+
+      expect(button.callback_game).toBeDefined();
+    });
+
+    it("should create pay button", () => {
+      const button: IInlineKeyboardButton = {
+        text: "Pay $10",
+        pay: true,
+      };
+
+      expect(button.pay).toBe(true);
+    });
+  });
+
+  describe("IInlineKeyboardMarkup Interface", () => {
+    it("should create inline keyboard markup", () => {
+      const markup: IInlineKeyboardMarkup = {
+        inline_keyboard: [
+          [
+            { text: "Button 1", url: "https://example.com" },
+            { text: "Button 2", callback_data: "cb2" },
+          ],
+          [{ text: "Button 3", switch_inline_query: "search" }],
+        ],
+      };
+
+      expect(markup.inline_keyboard).toBeDefined();
+      expect(markup.inline_keyboard?.length).toBe(2);
+      expect(markup.inline_keyboard?.[0].length).toBe(2);
+      expect(markup.inline_keyboard?.[1].length).toBe(1);
+    });
+
+    it("should accept empty inline_keyboard", () => {
+      const markup: IInlineKeyboardMarkup = {
+        inline_keyboard: [],
+      };
+
+      expect(markup.inline_keyboard).toEqual([]);
+    });
+  });
+
+  describe("IKeyboardButton Interface", () => {
+    it("should create text button", () => {
+      const button: IKeyboardButton = {
+        text: "Button",
+      };
+
+      expect(button.text).toBe("Button");
+    });
+
+    it("should create request contact button", () => {
+      const button: IKeyboardButton = {
+        text: "Share Contact",
+        request_contact: true,
+      };
+
+      expect(button.request_contact).toBe(true);
+    });
+
+    it("should create request location button", () => {
+      const button: IKeyboardButton = {
+        text: "Share Location",
+        request_location: true,
+      };
+
+      expect(button.request_location).toBe(true);
+    });
+
+    it("should create request poll button", () => {
+      const button: IKeyboardButton = {
+        text: "Create Poll",
+        request_poll: { type: "quiz" },
+      };
+
+      expect(button.request_poll?.type).toBe("quiz");
+    });
+
+    it("should create web app button (reply keyboard)", () => {
+      const button: IKeyboardButton = {
+        text: "Open App",
+        web_app: { url: "https://example.com/app" },
+      };
+
+      expect(button.web_app?.url).toBe("https://example.com/app");
+    });
+  });
+
+  describe("IReplyKeyboardMarkup Interface", () => {
+    it("should create reply keyboard markup", () => {
+      const markup: IReplyKeyboardMarkup = {
+        keyboard: [
+          [{ text: "Button 1" }, { text: "Button 2" }],
+          [{ text: "Button 3" }],
+        ],
+        resize_keyboard: true,
+        one_time_keyboard: false,
+      };
+
+      expect(markup.keyboard).toBeDefined();
+      expect(markup.resize_keyboard).toBe(true);
+      expect(markup.one_time_keyboard).toBe(false);
+    });
+
+    it("should accept all optional properties", () => {
+      const markup: IReplyKeyboardMarkup = {
+        keyboard: [[{ text: "Button" }]],
+        resize_keyboard: true,
+        one_time_keyboard: true,
+        input_field_placeholder: "Enter text...",
+        selective: true,
+      };
+
+      expect(markup.input_field_placeholder).toBe("Enter text...");
+      expect(markup.selective).toBe(true);
+    });
+  });
+
+  describe("IForceReplyMarkup Interface", () => {
+    it("should create force reply markup", () => {
+      const markup: IForceReplyMarkup = {
+        force_reply: true,
+      };
+
+      expect(markup.force_reply).toBe(true);
+    });
+
+    it("should accept selective property", () => {
+      const markup: IForceReplyMarkup = {
+        force_reply: true,
+        selective: true,
+        input_field_placeholder: "Type something...",
+      };
+
+      expect(markup.selective).toBe(true);
+      expect(markup.input_field_placeholder).toBe("Type something...");
+    });
+  });
+
+  describe("Builder Return Types", () => {
+    it("should return correct type from TelegramMessageBuilder.build()", () => {
+      const builder = TelegramMessageBuilder.text();
+      const message = builder.build();
+
+      // Type assertion to verify the structure
+      expect(message).toHaveProperty("text");
+      expect(message).toHaveProperty("parse_mode");
+      expect(typeof message.text).toBe("string");
+      expect(typeof message.parse_mode).toBe("string");
+    });
+
+    it("should return correct type from TelegramKeyboardBuilder.buildMarkup()", () => {
+      const keyboard = TelegramKeyboardBuilder.inline()
+        .urlButton("Test", "https://example.com")
+        .buildMarkup();
+
+      expect(keyboard).toHaveProperty("inline_keyboard");
+      expect(Array.isArray(keyboard.inline_keyboard)).toBe(true);
+    });
+
+    it("should return correct type from TelegramKeyboardBuilder.buildReplyMarkup()", () => {
+      const keyboard = TelegramKeyboardBuilder.reply()
+        .textButton("Test")
+        .buildReplyMarkup();
+
+      expect(keyboard).toHaveProperty("keyboard");
+      expect(Array.isArray(keyboard.keyboard)).toBe(true);
+    });
+
+    it("should return correct type from TelegramKeyboardBuilder.buildForceReplyMarkup()", () => {
+      const keyboard =
+        TelegramKeyboardBuilder.forceReply().buildForceReplyMarkup();
+
+      expect(keyboard).toHaveProperty("force_reply");
+      expect(keyboard.force_reply).toBe(true);
+    });
+  });
+
+  describe("Formatter Return Types", () => {
+    it("should return string from all HTML formatters", () => {
+      expect(typeof fmt.bold("test")).toBe("string");
+      expect(typeof fmt.italic("test")).toBe("string");
+      expect(typeof fmt.underline("test")).toBe("string");
+      expect(typeof fmt.strikethrough("test")).toBe("string");
+      expect(typeof fmt.spoiler("test")).toBe("string");
+      expect(typeof fmt.code("test")).toBe("string");
+      expect(typeof fmt.pre("test")).toBe("string");
+      expect(typeof fmt.codeBlock("test")).toBe("string");
+      expect(typeof fmt.link("test", "url")).toBe("string");
+      expect(typeof fmt.mention(123)).toBe("string");
+      expect(typeof fmt.hashtag("test")).toBe("string");
+      expect(typeof fmt.email("test@test.com")).toBe("string");
+      expect(typeof fmt.url("https://test.com")).toBe("string");
+      expect(typeof fmt.customEmoji("123")).toBe("string");
+    });
+
+    it("should return string from all Markdown formatters", () => {
+      expect(typeof fmt.boldMD("test")).toBe("string");
+      expect(typeof fmt.italicMD("test")).toBe("string");
+      expect(typeof fmt.codeMD("test")).toBe("string");
+      expect(typeof fmt.codeBlockMD("test")).toBe("string");
+      expect(typeof fmt.linkMD("test", "url")).toBe("string");
+      expect(typeof fmt.mentionMD(123)).toBe("string");
+      expect(typeof fmt.hashtagMD("test")).toBe("string");
+      expect(typeof fmt.rawMD("test")).toBe("string");
+    });
+
+    it("should return string from all MarkdownV2 formatters", () => {
+      expect(typeof fmt.boldMDv2("test")).toBe("string");
+      expect(typeof fmt.italicMDv2("test")).toBe("string");
+      expect(typeof fmt.underlineMDv2("test")).toBe("string");
+      expect(typeof fmt.strikethroughMDv2("test")).toBe("string");
+      expect(typeof fmt.spoilerMDv2("test")).toBe("string");
+      expect(typeof fmt.codeMDv2("test")).toBe("string");
+      expect(typeof fmt.codeBlockMDv2("test")).toBe("string");
+      expect(typeof fmt.linkMDv2("test", "url")).toBe("string");
+      expect(typeof fmt.mentionMDv2(123)).toBe("string");
+      expect(typeof fmt.hashtagMDv2("test")).toBe("string");
+      expect(typeof fmt.rawMDv2("test")).toBe("string");
+    });
+
+    it("should return string from escape functions", () => {
+      expect(typeof fmt.escapeHTML("test")).toBe("string");
+      expect(typeof fmt.escapeMarkdown("test")).toBe("string");
+      expect(typeof fmt.escapeMarkdownV2("test")).toBe("string");
+      expect(typeof fmt.escape("test")).toBe("string");
+    });
+  });
+
+  describe("Fluent API Chaining Types", () => {
+    it("should allow method chaining on TelegramMessageBuilder", () => {
+      const message = TelegramMessageBuilder.text()
+        .title("Test")
+        .newline()
+        .section("Section")
+        .line("Key", "Value", { bold: true })
+        .codeBlock("code")
+        .listItem("item")
+        .separator()
+        .text("text")
+        .link("Link", "url")
+        .mention(123)
+        .hashtag("tag")
+        .setParseMode("html")
+        .setOption("key", "value")
+        .setOptions({ key2: "value2" })
+        .build();
+
+      expect(message.text).toBeDefined();
+      expect(message.parse_mode).toBe("html");
+    });
+
+    it("should allow method chaining on TelegramKeyboardBuilder (inline)", () => {
+      const keyboard = TelegramKeyboardBuilder.inline()
+        .urlButton("Button", "url")
+        .row()
+        .callbackButton("Button2", "data")
+        .row()
+        .webAppButton("Button3", "url")
+        .buildMarkup();
+
+      expect(keyboard.inline_keyboard).toBeDefined();
+    });
+
+    it("should allow method chaining on TelegramKeyboardBuilder (reply)", () => {
+      const keyboard = TelegramKeyboardBuilder.reply()
+        .textButton("Button1")
+        .row()
+        .textButton("Button2")
+        .textButton("Button3")
+        .buildReplyMarkup();
+
+      expect(keyboard.keyboard).toBeDefined();
+      expect(keyboard.resize_keyboard).toBe(true);
+    });
+
+    it("should allow method chaining on TelegramKeyboardBuilder (force reply)", () => {
+      const keyboard =
+        TelegramKeyboardBuilder.forceReply().buildForceReplyMarkup();
+
+      expect(keyboard.force_reply).toBe(true);
+    });
+  });
+
+  describe("Type Guards and Validation", () => {
+    it("should validate parse_mode at runtime", () => {
+      const validModes: ParseMode[] = ["html", "markdown", "markdownv2"];
+
+      validModes.forEach((mode) => {
+        const builder = TelegramMessageBuilder.text().setParseMode(mode);
+        expect(builder.getParseMode()).toBe(mode);
+      });
+    });
+
+    it("should validate message structure", () => {
+      const message = TelegramMessageBuilder.text().title("Test").build();
+
+      // Runtime validation of message structure
+      expect(message).toBeDefined();
+      expect(typeof message.text).toBe("string");
+      expect(typeof message.parse_mode).toBe("string");
+      expect(["html", "markdown", "markdownv2"]).toContain(message.parse_mode);
+    });
+
+    it("should validate keyboard structure", () => {
+      const keyboard = TelegramKeyboardBuilder.inline()
+        .urlButton("Test", "url")
+        .buildMarkup();
+
+      // Runtime validation of keyboard structure
+      expect(keyboard).toBeDefined();
+      expect(keyboard.inline_keyboard).toBeDefined();
+      expect(Array.isArray(keyboard.inline_keyboard)).toBe(true);
+    });
+  });
+
+  describe("Export Validation", () => {
+    it("should export all types from index", () => {
+      // This test validates that types are properly exported
+      // If this compiles, the exports are correct
+      type TypesExported = {
+        ParseMode: ParseMode;
+        ITelegramMessage: ITelegramMessage;
+        IInlineKeyboardButton: IInlineKeyboardButton;
+        IInlineKeyboardMarkup: IInlineKeyboardMarkup;
+        IKeyboardButton: IKeyboardButton;
+        IReplyKeyboardMarkup: IReplyKeyboardMarkup;
+        IForceReplyMarkup: IForceReplyMarkup;
+      };
+
+      const dummy: TypesExported = {} as TypesExported;
+      expect(dummy).toBeDefined();
+    });
+
+    it("should export TelegramMessageBuilder", () => {
+      expect(TelegramMessageBuilder).toBeDefined();
+      expect(typeof TelegramMessageBuilder.text).toBe("function");
+    });
+
+    it("should export TelegramKeyboardBuilder", () => {
+      expect(TelegramKeyboardBuilder).toBeDefined();
+      expect(typeof TelegramKeyboardBuilder.inline).toBe("function");
+      expect(typeof TelegramKeyboardBuilder.reply).toBe("function");
+      expect(typeof TelegramKeyboardBuilder.forceReply).toBe("function");
+    });
+
+    it("should export fmt object with all formatters", () => {
+      expect(fmt).toBeDefined();
+      expect(typeof fmt.bold).toBe("function");
+      expect(typeof fmt.italic).toBe("function");
+      expect(typeof fmt.link).toBe("function");
+      expect(typeof fmt.escape).toBe("function");
+    });
+  });
+
+  describe("Type Compatibility", () => {
+    it("should be compatible with Telegram Bot API types", () => {
+      // Simulate sending to Telegram Bot API
+      const message = TelegramMessageBuilder.text()
+        .title("Test")
+        .setOption("disable_notification", true)
+        .build();
+
+      // This should match the expected Telegram Bot API structure
+      const apiPayload = {
+        text: message.text,
+        parse_mode: message.parse_mode,
+        disable_notification: message.disable_notification,
+      };
+
+      expect(apiPayload.text).toBeDefined();
+      expect(apiPayload.parse_mode).toBeDefined();
+      expect(apiPayload.disable_notification).toBe(true);
+    });
+
+    it("should handle keyboard markup with messages", () => {
+      const message = TelegramMessageBuilder.text().title("Test").build();
+
+      const keyboard = TelegramKeyboardBuilder.inline()
+        .urlButton("Button", "url")
+        .buildMarkup();
+
+      // Simulate sending message with keyboard
+      const payload = {
+        text: message.text,
+        parse_mode: message.parse_mode,
+        reply_markup: keyboard,
+      };
+
+      expect(payload.reply_markup).toBeDefined();
+      expect(payload.reply_markup.inline_keyboard).toBeDefined();
+    });
+  });
+});

package/src/utils/index.d.ts

@@ -3,4 +3,4 @@
  *
  * @module
  */
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/src/utils/index.ts

@@ -1,5 +0,0 @@
-/**
- * Utilidades locales del package telegram-message-builder/core.
- *
- * @module
- */