@grammy-x/conversations 0.1.0

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@grammy-x/conversations",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "private": false,
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "dependencies": {
+    "@grammy-x/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "grammy": "^1.24.0",
+    "@grammyjs/conversations": "^1",
+    "@grammyjs/hydrate": "^1.4.1"
+  }
+}

package/src/conversation.ts

@@ -0,0 +1,27 @@
+import type { ConversationConfig } from "@grammyjs/conversations"
+import { createConversation } from "@grammyjs/conversations"
+import type { Conversation } from "@grammyjs/conversations"
+import { hydrate } from "@grammyjs/hydrate"
+import type { MiddlewareFn } from "grammy"
+import type { GrammyXFlavor } from "@grammy-x/core"
+
+export type ConversationFn<C extends GrammyXFlavor = GrammyXFlavor> = (
+    conversation: Conversation<C>,
+    ctx: C
+) => unknown | Promise<unknown>
+
+export function createCustomConversation<C extends GrammyXFlavor = GrammyXFlavor>(
+    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

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

package/src/question-helper.ts

@@ -0,0 +1,453 @@
+import type { Conversation } from "@grammyjs/conversations"
+import { CallbackQueryContext, Context, InlineKeyboard, Keyboard } from "grammy"
+import type { ChatAdministratorRights, ChatShared } from "grammy/types"
+import { smartReply } from "@grammy-x/core"
+import type { GrammyXFlavor } from "@grammy-x/core"
+
+type MaybePromise<T> = PromiseLike<T> | T
+type ButtonsMarkup = InlineKeyboard | Keyboard
+
+interface QuestionParameters {
+    markup?: ButtonsMarkup
+    autoBold?: boolean
+    entities?: any[]
+    fastMenu?: boolean
+    fastMenuCallbackData?: string
+    fastMenuText?: string
+    newMessage?: boolean
+}
+
+interface QuestionCallbackParameters extends QuestionParameters {
+    columnCount?: number
+    noChoiceAllowed?: boolean
+    rowCount?: number
+    continueButton?: string
+    pagination?: {
+        enabled: boolean
+        extraControls?: boolean
+    }
+}
+
+interface QuestionMultiParameters extends QuestionCallbackParameters {
+    continueInlineEnd?: boolean
+}
+
+interface QuestionChatParameters extends QuestionParameters {
+    chat: {
+        requiredUserRights?: ChatAdministratorRights
+        requiredBotRights?: ChatAdministratorRights
+        botIsMember?: boolean
+        isChannel: boolean
+    }
+}
+
+type QuestionUniversalParameters = Partial<QuestionMultiParameters & QuestionChatParameters>
+
+interface QuestionInternalParameters extends QuestionUniversalParameters {
+    continueButton?: string
+    sendContinueButton?: boolean
+}
+
+export interface TextParserResult<R> {
+    result?: R
+    callbackQuery?: string
+    answerCtx?: any
+    message?: any
+}
+
+interface QuestionHelperSession {
+    questionHelper: {
+        currentChoices: Set<string>
+        currentPage: number
+    }
+}
+
+function randomInteger(minimum: number, maximum: number): number {
+    return Math.floor(Math.random() * (maximum - minimum + 1) + minimum)
+}
+
+export class QuestionHelper<
+    C extends GrammyXFlavor = GrammyXFlavor,
+    T extends Conversation<C> = Conversation<C>,
+> {
+    private conversation: T
+    private config: QuestionUniversalParameters
+    private ctx: C
+    public message_id?: number
+
+    constructor(conversation: T, ctx: C, config?: QuestionUniversalParameters) {
+        this.conversation = conversation
+        this.config = config ?? {}
+        this.ctx = ctx
+    }
+
+    private updateCtx = <U extends GrammyXFlavor>(ctx: U) => {
+        Object.keys(this.ctx).forEach((key) => delete (this.ctx as any)[key])
+        Object.assign(this.ctx, ctx)
+    }
+
+    delete = async () => {
+        if (this.message_id) {
+            await this.ctx.api.deleteMessage(this.ctx.from!.id, this.message_id)
+        }
+    }
+
+    private reply = async (text: string, options?: QuestionInternalParameters) => {
+        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 ?? "↩️ В главное меню", mergedOptions.fastMenuCallbackData ?? "start")
+        }
+        if (
+            options?.sendContinueButton &&
+            mergedOptions.continueInlineEnd &&
+            mergedOptions.markup instanceof InlineKeyboard
+        ) {
+            const markup = mergedOptions.markup
+            markup.text(options?.continueButton ?? "➡️ Продолжить", "continue")
+        }
+
+        const message = await smartReply(this.ctx, text, {
+            options: {
+                entities: mergedOptions.entities,
+                reply_markup: mergedOptions.markup as any,
+            },
+            messageToEdit: this.message_id,
+            newMessage: mergedOptions?.newMessage,
+            embolden: false,
+            dedent: false,
+        })
+        this.message_id = message?.message_id ?? this.message_id
+        return message
+    }
+
+    private getCallbackDataFromKeyboard = (keyboard: ButtonsMarkup | undefined): string[] => {
+        if (keyboard && keyboard instanceof InlineKeyboard)
+            return keyboard.inline_keyboard
+                .flat()
+                .map((b: any) => b.callback_data)
+                .filter(Boolean)
+        return []
+    }
+
+    private textParser = async <R>(
+        text: string,
+        parser: (data: string) => R,
+        validator: (result: R) => boolean,
+        options?: QuestionParameters
+    ) => {
+        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 }
+
+        const result = parser((answer as any).msg!.text) as NonNullable<R>
+        await this.ctx.api.deleteMessage(this.ctx.from!.id, (answer as any).msg!.message_id).catch(() => {})
+        if (!validator(result)) return await this.conversation.skip()
+        return { result, answerCtx: answer, message }
+    }
+
+    text = (text: string, options?: QuestionParameters): Promise<TextParserResult<string>> =>
+        this.textParser(
+            text,
+            (r) => r,
+            () => true,
+            options
+        ) as Promise<TextParserResult<string>>
+
+    int = (text: string, options?: QuestionParameters): Promise<TextParserResult<number>> =>
+        this.textParser(text, parseInt, (r) => !isNaN(r), options) as Promise<TextParserResult<number>>
+
+    float = (text: string, options?: QuestionParameters): Promise<TextParserResult<number>> =>
+        this.textParser(text, parseFloat, (r) => !isNaN(r), options) as Promise<TextParserResult<number>>
+
+    chat = async (text: string, options: QuestionChatParameters) => {
+        const chat = options.chat
+        const markup = new Keyboard()
+            .requestChat("Выбрать чат 🔍", randomInteger(0, 999999), {
+                chat_is_channel: chat.isChannel,
+                bot_administrator_rights: chat.requiredBotRights,
+                bot_is_member: chat.botIsMember,
+                request_username: 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 as any)?.delete?.().catch?.(() => {})
+        return answer.msg.chat_shared as ChatShared
+    }
+
+    private renderPaginationButtons = (
+        pagesCount: number,
+        currentPage: number,
+        markup: InlineKeyboard,
+        columnCount: number,
+        extraControls: boolean
+    ) => {
+        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 ? "⋘" : " ", "first")
+        }
+        markup.text(currentPage > 1 ? "←" : " ", "prev")
+        markup.text(currentPage + " / " + pagesCount, "page")
+        markup.text(currentPage < pagesCount ? "→" : " ", "next")
+        if (extraControls) {
+            markup.text(currentPage < pagesCount - 1 ? "⋙" : " ", "last")
+        }
+        for (let i = 0; i < emptyColumns; i++) {
+            markup.text(" ", " ")
+        }
+        return markup.row()
+    }
+
+    private resetChoice = (session: QuestionHelperSession) => {
+        session.questionHelper = {
+            currentChoices: new Set(),
+            currentPage: 1,
+        }
+    }
+
+    private async basicChoice<const R extends string>(
+        text: string,
+        choices: [string, R][],
+        multi: false,
+        options?: QuestionParameters,
+        inProgress?: boolean
+    ): Promise<{ result: R; message: any }>
+    private async basicChoice<const R extends string>(
+        text: string | ((choices: R[], currentPage: number, pagesCount: number) => MaybePromise<string>),
+        choices: [string, R][],
+        multi: true,
+        options?: QuestionParameters,
+        inProgress?: boolean
+    ): Promise<{
+        result: R[]
+        callbackQuery?: string
+        message: any
+    }>
+    private async basicChoice<const R extends string>(
+        text: string | ((choices: R[], currentPage: number, pagesCount: number) => MaybePromise<string>),
+        choices: [string, R][],
+        multi: boolean = false,
+        options?: QuestionMultiParameters,
+        inProgress?: boolean
+    ): Promise<
+        | {
+              result: R[]
+              callbackQuery?: string
+              message: any
+          }
+        | {
+              result: R
+              message: any
+          }
+    > {
+        const markup = new InlineKeyboard()
+        const session = (await this.conversation.external(
+            () => this.ctx.session
+        )) as unknown as QuestionHelperSession
+        if (!session.questionHelper) this.resetChoice(session)
+        await this.conversation.external(() => !inProgress && this.resetChoice(session))
+        let currentRow: [string, string][] = []
+        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" as unknown as R]
+                  )
+              )
+            : choices
+        const pagesCount = Math.ceil(choices.length / (columnCount * rowCount))
+        const currentPage = session.questionHelper.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.questionHelper.currentChoices.has(choice[1])
+            currentRow.push([`${choice[0]}${checked ? " ✅" : ""}`, 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.questionHelper.currentChoices.size > 0
+        const continueInlineEnd = options?.continueInlineEnd ?? (this.config as any).continueInlineEnd
+        if (multi && !options?.noChoiceAllowed && !continueInlineEnd && sendContinueButton)
+            markup.text(options?.continueButton ?? "➡️ Продолжить", "continue").row()
+
+        const messageText =
+            typeof text === "function"
+                ? await text(
+                      Array.from(session.questionHelper.currentChoices) as R[],
+                      session.questionHelper.currentPage,
+                      pagesCount
+                  )
+                : text
+        const message = await this.reply(messageText, {
+            ...options,
+            markup,
+            continueButton: options?.continueButton,
+            continueInlineEnd,
+            sendContinueButton: continueInlineEnd && sendContinueButton,
+        })
+        let additionalTriggerCalled: boolean
+        let answer: CallbackQueryContext<C>
+
+        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 callbackData = answer.callbackQuery.data
+            additionalTriggerCalled = additionalTriggers.includes(callbackData)
+
+            if (callbackData == "continue" || additionalTriggerCalled) {
+                const choices = Array.from(session.questionHelper.currentChoices)
+                ;(this.ctx.session as unknown as QuestionHelperSession).questionHelper.currentChoices = new Set()
+                if (additionalTriggerCalled) return { result: choices as R[], callbackQuery: callbackData, message }
+                return { result: choices as R[], message }
+            }
+        } while (additionalTriggerCalled)
+
+        const questionData = session.questionHelper
+        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 as unknown as QuestionHelperSession).questionHelper = session.questionHelper =
+                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 as unknown as QuestionHelperSession).questionHelper.currentChoices = new Set()
+            return {
+                result: data as R,
+                message,
+            }
+        }
+
+        //@ts-expect-error bruh typescript
+        return this.basicChoice(text, choices, multi, options, true)
+    }
+
+    choice = async <const R extends string>(
+        text: string,
+        choices: [string, R][],
+        options?: QuestionCallbackParameters
+    ): Promise<{
+        result: R
+        message: any
+    }> => this.basicChoice(text, choices, false, options)
+
+    multi = async <const R extends string>(
+        text: string | ((choices: R[], currentPage: number, pagesCount: number) => MaybePromise<string>),
+        choices: [string, R][],
+        options?: QuestionCallbackParameters
+    ): Promise<{
+        result: R[]
+        callbackData?: string
+        message: any
+    }> => this.basicChoice(text, choices, true, options)
+
+    boolean = async (text: string, yesNoStrings?: string[], options?: QuestionCallbackParameters) => {
+        const { result, message } = await this.choice(
+            text,
+            [
+                [yesNoStrings?.[0] ?? "✅ Да", "true"],
+                [yesNoStrings?.[1] ?? "❌ Нет", "false"],
+            ],
+            { columnCount: 2, ...options }
+        )
+        const boolResult = result === "true"
+        return { result: boolResult, message }
+    }
+
+    photo = async (text: string, options?: QuestionParameters) => {
+        const message = await this.reply(text, options)
+        const answer = await this.conversation.waitFor(":photo")
+        this.updateCtx(answer)
+        await (answer?.msg as any)?.delete?.().catch?.(() => {})
+        return answer.msg.photo[0].file_id
+    }
+
+    file = async (text: string, options?: QuestionParameters) => {
+        const message = await this.reply(text, options)
+        const answer = await this.conversation.waitFor(":file")
+        this.updateCtx(answer)
+        await (answer?.msg as any)?.delete?.().catch?.(() => {})
+        return answer.msg.document?.file_id as string
+    }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}