@grammy-x/conversations 0.2.0 → 2.0.1

package/dist/index.js

@@ -0,0 +1,423 @@
+// src/question-helper.ts
+import { Context, InlineKeyboard, Keyboard } from "grammy";
+import { smartReply, GlobalMenuRegistry } from "@grammy-x/core";
+function randomInteger(minimum, maximum) {
+  return Math.floor(Math.random() * (maximum - minimum + 1) + minimum);
+}
+var QuestionHelper = class {
+  conversation;
+  config;
+  ctx;
+  message_id;
+  constructor(conversation, ctx, config) {
+    this.conversation = conversation;
+    this.config = config ?? {};
+    this.ctx = ctx;
+  }
+  updateCtx = (ctx) => {
+    Object.keys(this.ctx).forEach((key) => delete this.ctx[key]);
+    Object.assign(this.ctx, ctx);
+  };
+  delete = async () => {
+    if (this.message_id) {
+      await this.ctx.api.deleteMessage(this.ctx.from.id, this.message_id);
+    }
+  };
+  back = async () => {
+    const gx = this.ctx.session?._gx;
+    if (gx?.history.length > 0) {
+      gx.history.pop();
+    }
+    const targetId = gx?.history.length > 0 ? gx.history.pop() : void 0;
+    if (targetId) {
+      const menu = GlobalMenuRegistry.get(targetId);
+      if (menu) return menu.send(this.ctx);
+    }
+  };
+  reply = async (text, options) => {
+    let newText = text;
+    const mergedOptions = { ...this.config, ...options };
+    if (mergedOptions.autoBold !== false) newText = `<b>${newText}</b>`;
+    if (options?.markup instanceof InlineKeyboard) mergedOptions.markup = options.markup;
+    if (!mergedOptions.markup) mergedOptions.markup = new InlineKeyboard();
+    if (mergedOptions.markup instanceof InlineKeyboard && this.config.markup instanceof InlineKeyboard)
+      mergedOptions.markup.append(this.config.markup);
+    if (mergedOptions.fastMenu && mergedOptions.markup instanceof InlineKeyboard) {
+      const markup = mergedOptions.markup;
+      markup.text(mergedOptions.fastMenuText ?? this.config?.fastMenuText ?? "Main Menu", mergedOptions.fastMenuCallbackData ?? "start");
+    }
+    if (options?.sendContinueButton && mergedOptions.continueInlineEnd && mergedOptions.markup instanceof InlineKeyboard) {
+      const markup = mergedOptions.markup;
+      markup.text(options?.continueButton ?? this.config?.continueButton ?? "Continue", "continue");
+    }
+    const message = await smartReply(this.ctx, text, {
+      options: {
+        entities: mergedOptions.entities,
+        reply_markup: mergedOptions.markup
+      },
+      messageToEdit: this.message_id,
+      newMessage: mergedOptions?.newMessage,
+      embolden: false,
+      dedent: false
+    });
+    this.message_id = message?.message_id ?? this.message_id;
+    return message;
+  };
+  getCallbackDataFromKeyboard = (keyboard) => {
+    if (keyboard && keyboard instanceof InlineKeyboard)
+      return keyboard.inline_keyboard.flat().map((b) => b.callback_data).filter(Boolean);
+    return [];
+  };
+  textParser = async (text, parser, validator, options) => {
+    const message = await this.reply(text, options);
+    const additionalTriggers = this.getCallbackDataFromKeyboard(options?.markup);
+    const answer = await this.conversation.waitUntil(
+      (ctx) => Context.has.callbackQuery(additionalTriggers)(ctx) || ctx.has(":text")
+    );
+    this.updateCtx(answer);
+    const callbackQuery = answer.callbackQuery?.data;
+    if (callbackQuery) return { callbackQuery, answerCtx: answer, message };
+    if (answer.message?.text?.startsWith("/")) {
+      await this.ctx.api.deleteMessage(this.ctx.from.id, answer.message.message_id).catch(() => {
+      });
+      const cmd = answer.message.text.split(" ")[0];
+      const err = new Error(`CommandInterrupt:${cmd}`);
+      err.name = "CommandInterruptError";
+      err.ctx = answer;
+      throw err;
+    }
+    const result = parser(answer.msg.text);
+    await this.ctx.api.deleteMessage(this.ctx.from.id, answer.msg.message_id).catch(() => {
+    });
+    if (!validator(result)) return await this.conversation.skip();
+    return { result, answerCtx: answer, message };
+  };
+  text = (text, options) => this.textParser(
+    text,
+    (r) => r,
+    () => true,
+    options
+  );
+  int = (text, options) => this.textParser(text, parseInt, (r) => !isNaN(r), options);
+  float = (text, options) => this.textParser(text, parseFloat, (r) => !isNaN(r), options);
+  chat = async (text, options) => {
+    const chat = options.chat;
+    const markup = new Keyboard().requestChat("\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u0447\u0430\u0442 \u{1F50D}", randomInteger(0, 999999), {
+      chat_is_channel: chat.isChannel,
+      bot_administrator_rights: chat.requiredBotRights,
+      bot_is_member: chat.botIsMember,
+      request_photo: chat.requestPhoto,
+      request_title: chat.requestTitle,
+      request_username: chat.requestUsername ?? true,
+      user_administrator_rights: chat.requiredUserRights
+    }).oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":chat_shared");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.chat_shared;
+  };
+  user = async (text, options) => {
+    const user = options?.user;
+    const markup = new Keyboard().requestUsers("\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F \u{1F50D}", randomInteger(0, 999999), {
+      max_quantity: 1,
+      request_name: user?.requestName,
+      request_photo: user?.requestPhoto,
+      request_username: user?.requestUsername ?? true,
+      user_is_bot: user?.isBot,
+      user_is_premium: user?.isPremium
+    }).oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":users_shared");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.users_shared?.users[0];
+  };
+  users = async (text, options) => {
+    const users = options?.users;
+    const markup = new Keyboard().requestUsers("\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u0435\u0439 \u{1F50D}", randomInteger(0, 999999), {
+      max_quantity: users?.maxQuantity,
+      request_name: users?.requestName,
+      request_photo: users?.requestPhoto,
+      request_username: users?.requestUsername ?? true,
+      user_is_bot: users?.isBot,
+      user_is_premium: users?.isPremium
+    }).oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":users_shared");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.users_shared;
+  };
+  contact = async (text, options) => {
+    const markup = new Keyboard().requestContact("\u041F\u043E\u0434\u0435\u043B\u0438\u0442\u044C\u0441\u044F \u043A\u043E\u043D\u0442\u0430\u043A\u0442\u043E\u043C \u{1F4DE}").oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":contact");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.contact;
+  };
+  location = async (text, options) => {
+    const markup = new Keyboard().requestLocation("\u041F\u043E\u0434\u0435\u043B\u0438\u0442\u044C\u0441\u044F \u0433\u0435\u043E\u043F\u043E\u0437\u0438\u0446\u0438\u0435\u0439 \u{1F4CD}").oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":location");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.location;
+  };
+  poll = async (text, options) => {
+    const pollType = options?.poll?.type;
+    const markup = new Keyboard().requestPoll("\u041E\u0442\u043F\u0440\u0430\u0432\u0438\u0442\u044C \u043E\u043F\u0440\u043E\u0441 \u{1F4CA}", pollType).oneTime(true).resized(true);
+    const message = await this.reply(text, { ...options, markup });
+    const answer = await this.conversation.waitFor(":poll");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.poll;
+  };
+  renderPaginationButtons = (pagesCount, currentPage, markup, columnCount, extraControls) => {
+    const oddColumnCount = columnCount % 2 === 0 ? columnCount + 1 : columnCount;
+    const emptyColumns = oddColumnCount >= 5 ? extraControls ? 0 : 1 : 0;
+    for (let i = 0; i < emptyColumns; i++) {
+      markup.text(" ", " ");
+    }
+    if (extraControls) {
+      markup.text(currentPage > 2 ? "\u22D8" : " ", "first");
+    }
+    markup.text(currentPage > 1 ? "\u2190" : " ", "prev");
+    markup.text(currentPage + " / " + pagesCount, "page");
+    markup.text(currentPage < pagesCount ? "\u2192" : " ", "next");
+    if (extraControls) {
+      markup.text(currentPage < pagesCount - 1 ? "\u22D9" : " ", "last");
+    }
+    for (let i = 0; i < emptyColumns; i++) {
+      markup.text(" ", " ");
+    }
+    return markup.row();
+  };
+  resetChoice = (session) => {
+    if (!session._gx.conversations) session._gx.conversations = {
+      currentChoices: /* @__PURE__ */ new Set(),
+      currentPage: 1
+    };
+    else {
+      session._gx.conversations.currentChoices = /* @__PURE__ */ new Set();
+      session._gx.conversations.currentPage = 1;
+    }
+  };
+  async basicChoice(text, choices, multi = false, options, inProgress) {
+    const markup = new InlineKeyboard();
+    const session = await this.conversation.external(
+      () => this.ctx.session
+    );
+    if (!session._gx.conversations) this.resetChoice(session);
+    await this.conversation.external(() => !inProgress && this.resetChoice(session));
+    let currentRow = [];
+    const columnCount = options?.columnCount ?? this.config.columnCount ?? 1;
+    const rowCount = options?.rowCount ?? this.config.rowCount ?? 3;
+    const filledChoices = options?.pagination?.enabled ? choices.concat(
+      Array.from({ length: columnCount * rowCount - choices.length % (columnCount * rowCount) }).map(
+        () => [" ", "empty"]
+      )
+    ) : choices;
+    const pagesCount = Math.ceil(choices.length / (columnCount * rowCount));
+    const currentPage = session._gx.conversations.currentPage ?? 1;
+    let currentRowId = 0;
+    for (const [choiceId, choice] of filledChoices.entries()) {
+      if (options?.pagination?.enabled && choiceId < (currentPage - 1) * columnCount * rowCount) continue;
+      const checked = session._gx.conversations.currentChoices.has(choice[1]);
+      currentRow.push([`${choice[0]}${checked ? " \u2705" : ""}`, choice[1]]);
+      if (currentRow.length === columnCount) {
+        currentRow.forEach(
+          ([label, value]) => markup.text(label, value == "empty" ? "empty" : `answer:${value}`)
+        );
+        markup.row();
+        currentRow = [];
+        currentRowId++;
+        if (options?.pagination?.enabled && (currentRowId === rowCount || choiceId === filledChoices.length - 1)) {
+          this.renderPaginationButtons(
+            pagesCount,
+            currentPage,
+            markup,
+            columnCount,
+            options?.pagination?.extraControls ?? false
+          );
+          break;
+        }
+      }
+    }
+    if (currentRow.length > 0) {
+      currentRow.forEach(([label, value]) => {
+        markup.text(label, `answer:${value}`);
+      });
+      markup.row();
+    }
+    const additionalTriggers = this.getCallbackDataFromKeyboard(options?.markup);
+    if (options?.markup instanceof InlineKeyboard) markup.append(options.markup).row();
+    const sendContinueButton = session._gx.conversations.currentChoices.size > 0;
+    const continueInlineEnd = options?.continueInlineEnd ?? this.config.continueInlineEnd;
+    if (multi && !options?.noChoiceAllowed && !continueInlineEnd && sendContinueButton)
+      markup.text(options?.continueButton ?? this.config?.continueButton ?? "Continue", "continue").row();
+    const messageText = typeof text === "function" ? await text(
+      Array.from(session._gx.conversations.currentChoices),
+      session._gx.conversations.currentPage,
+      pagesCount
+    ) : text;
+    const message = await this.reply(messageText, {
+      ...options,
+      markup,
+      continueButton: options?.continueButton,
+      continueInlineEnd,
+      sendContinueButton: continueInlineEnd && sendContinueButton
+    });
+    let additionalTriggerCalled;
+    let answer;
+    const paginationsCallbacks = ["prev", "next", "page", "empty", "first", "last"];
+    do {
+      answer = await this.conversation.waitForCallbackQuery([
+        ...choices.map((c) => `answer:${c[1]}`),
+        ...multi ? ["continue"] : [],
+        ...options?.pagination?.enabled ? paginationsCallbacks : [],
+        ...additionalTriggers
+      ]);
+      this.updateCtx(answer);
+      const callbackData2 = answer.callbackQuery.data;
+      additionalTriggerCalled = additionalTriggers.includes(callbackData2);
+      if (callbackData2 == "continue" || additionalTriggerCalled) {
+        const choices2 = Array.from(session._gx.conversations.currentChoices);
+        this.ctx.session._gx.conversations.currentChoices = /* @__PURE__ */ new Set();
+        if (additionalTriggerCalled) return { result: choices2, callbackQuery: callbackData2, message };
+        return { result: choices2, message };
+      }
+    } while (additionalTriggerCalled);
+    const questionData = session._gx.conversations;
+    const callbackData = answer.callbackQuery.data;
+    const data = callbackData.split(":")[1];
+    const skip = await this.conversation.external(async () => {
+      if (callbackData == "prev") questionData.currentPage = Math.max(currentPage - 1, 1);
+      if (callbackData == "next") questionData.currentPage = Math.min(currentPage + 1, pagesCount);
+      if (callbackData == "first") questionData.currentPage = 1;
+      if (callbackData == "last") questionData.currentPage = pagesCount;
+      if (data) {
+        if (questionData.currentChoices.has(data)) questionData.currentChoices.delete(data);
+        else questionData.currentChoices.add(data);
+      }
+      ;
+      this.ctx.session._gx.conversations = questionData;
+      if (paginationsCallbacks.includes(callbackData) && questionData.currentPage == currentPage) {
+        await this.ctx.answerCallbackQuery();
+        return true;
+      }
+    });
+    if (skip) return this.conversation.skip({ drop: true });
+    if (!multi && data) {
+      ;
+      this.ctx.session._gx.conversations.currentChoices = /* @__PURE__ */ new Set();
+      return {
+        result: data,
+        message
+      };
+    }
+    return this.basicChoice(text, choices, multi, options, true);
+  }
+  choice = async (text, choices, options) => this.basicChoice(text, choices, false, options);
+  multi = async (text, choices, options) => this.basicChoice(text, choices, true, options);
+  boolean = async (text, yesNoStrings, options) => {
+    const { result, message } = await this.choice(
+      text,
+      [
+        [yesNoStrings?.[0] ?? "\u2705 \u0414\u0430", "true"],
+        [yesNoStrings?.[1] ?? "\u274C \u041D\u0435\u0442", "false"]
+      ],
+      { columnCount: 2, ...options }
+    );
+    const boolResult = result === "true";
+    return { result: boolResult, message };
+  };
+  photo = async (text, options) => {
+    const message = await this.reply(text, options);
+    const answer = await this.conversation.waitFor(":photo");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    const photo = answer.msg.photo?.[0];
+    if (!photo) {
+      throw new Error("No photo found in update");
+    }
+    return photo.file_id;
+  };
+  file = async (text, options) => {
+    const message = await this.reply(text, options);
+    const answer = await this.conversation.waitFor(":file");
+    this.updateCtx(answer);
+    await answer?.msg?.delete?.().catch?.(() => {
+    });
+    return answer.msg.document?.file_id;
+  };
+};
+
+// src/conversation.ts
+import { createConversation } from "@grammyjs/conversations";
+import { hydrate } from "@grammyjs/hydrate";
+import { GlobalMenuRegistry as GlobalMenuRegistry2, getGrammyXOptions } from "@grammy-x/core";
+function createCustomConversation(builder, config) {
+  let cfg = typeof config === "string" ? { id: config } : config;
+  cfg = cfg ?? {};
+  const id = cfg.id ?? builder.name;
+  cfg.id = id;
+  GlobalMenuRegistry2.register({
+    menuName: id,
+    send: async (ctx) => {
+      if (!ctx.conversation) {
+        console.error(`[Grammy-X] Cannot enter conversation '${id}': ctx.conversation is undefined. Make sure bot.use(conversations()) is registered before components that use it.`);
+        return;
+      }
+      if (ctx.conversation.active) {
+        await ctx.conversation.exit();
+      }
+      return ctx.conversation.enter(id);
+    }
+  });
+  return createConversation(
+    (async (conversation, ctx) => {
+      await conversation.run(hydrate());
+      const gx = ctx.session?._gx;
+      if (gx && gx.history[gx.history.length - 1] !== id) {
+        gx.history.push(id);
+        if (gx.history.length > 20) gx.history.shift();
+      }
+      try {
+        return await builder(conversation, ctx);
+      } catch (e) {
+        if (e.name === "CommandInterruptError") {
+          const cmd = e.message.split(":")[1];
+          const opts = getGrammyXOptions(e.ctx);
+          const targetMenu = opts?.interruptCommands?.[cmd];
+          if (targetMenu) {
+            try {
+              if (typeof targetMenu === "string") {
+                await e.ctx.menu.nav(targetMenu);
+              } else if (typeof targetMenu.send === "function") {
+                await targetMenu.send(e.ctx);
+              }
+            } catch (err) {
+              console.error(`Could not auto-nav to target menu for command ${cmd}`, err);
+            }
+          }
+          return;
+        }
+        throw e;
+      }
+    }),
+    cfg
+  );
+}
+export {
+  QuestionHelper,
+  createCustomConversation
+};

package/package.json

@@ -1,19 +1,42 @@
 {
   "name": "@grammy-x/conversations",
-  "version": "0.2.0",
+  "version": "2.0.1",
+
   "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+
   "private": false,
+
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
+
   "dependencies": {
-    "@grammy-x/core": "0.1.3"
+    "@grammy-x/core": "0.2.1"
   },
+
   "peerDependencies": {
     "grammy": "^1.24.0",
     "@grammyjs/conversations": "^1",
     "@grammyjs/hydrate": "^1.4.1"
+  },
+
+  "files": [
+    "dist"
+  ],
+
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean"
   }
-}
+}

package/src/conversation.ts

@@ -1,26 +0,0 @@
-import type { ConversationConfig } from "@grammyjs/conversations"
-import { createConversation } from "@grammyjs/conversations"
-import type { Conversation } from "@grammyjs/conversations"
-import { hydrate } from "@grammyjs/hydrate"
-import type { Context, MiddlewareFn } from "grammy"
-
-export type ConversationFn<C extends Context = Context> = (
-    conversation: Conversation<C>,
-    ctx: C
-) => unknown | Promise<unknown>
-
-export function createCustomConversation<C extends Context = Context>(
-    builder: ConversationFn<C>,
-    config?: string | ConversationConfig
-): MiddlewareFn<any> {
-    let cfg = typeof config === "string" ? { id: config } : config
-    cfg = cfg ?? {}
-    cfg.id = cfg.id ?? builder.name
-    return createConversation(
-        (async (conversation: any, ctx: any) => {
-            await conversation.run(hydrate())
-            return builder(conversation, ctx)
-        }),
-        cfg
-    ) as MiddlewareFn<any>
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export { QuestionHelper } from "./question-helper.js"
-export { createCustomConversation } from "./conversation.js"
-export type { ConversationFn } from "./conversation.js"