@grammy-x/conversations 0.2.0 → 2.0.1

package/src/question-helper.ts

@@ -1,579 +0,0 @@
-import type { Conversation } from "@grammyjs/conversations"
-import { CallbackQueryContext, Context, InlineKeyboard, Keyboard } from "grammy"
-import type {
-    ChatAdministratorRights,
-    ChatShared,
-    Contact,
-    Location,
-    Poll,
-    UsersShared,
-} from "grammy/types"
-import { smartReply } 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
-        requestTitle?: boolean
-        requestUsername?: boolean
-        requestPhoto?: boolean
-    }
-}
-
-interface QuestionUserParameters extends QuestionParameters {
-    user?: {
-        isBot?: boolean
-        isPremium?: boolean
-        requestName?: boolean
-        requestUsername?: boolean
-        requestPhoto?: boolean
-    }
-}
-
-interface QuestionUsersParameters extends QuestionParameters {
-    users?: {
-        maxQuantity?: number
-        isBot?: boolean
-        isPremium?: boolean
-        requestName?: boolean
-        requestUsername?: boolean
-        requestPhoto?: boolean
-    }
-}
-
-interface QuestionPollParameters extends QuestionParameters {
-    poll?: {
-        type?: "regular" | "quiz"
-    }
-}
-
-type QuestionUniversalParameters = Partial<
-    QuestionMultiParameters &
-        QuestionChatParameters &
-        QuestionUserParameters &
-        QuestionUsersParameters &
-        QuestionPollParameters
->
-
-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 Context = Context,
-    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 Context>(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_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 as any)?.delete?.().catch?.(() => {})
-        return answer.msg.chat_shared as ChatShared
-    }
-
-    user = async (text: string, options?: QuestionUserParameters) => {
-        const user = options?.user
-        const markup = new Keyboard()
-            .requestUsers("Выбрать пользователя 🔍", 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 as any)?.delete?.().catch?.(() => {})
-        return answer.msg.users_shared?.users[0] as UsersShared["users"][number]
-    }
-
-    users = async (text: string, options?: QuestionUsersParameters) => {
-        const users = options?.users
-        const markup = new Keyboard()
-            .requestUsers("Выбрать пользователей 🔍", 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 as any)?.delete?.().catch?.(() => {})
-        return answer.msg.users_shared as UsersShared
-    }
-
-    contact = async (text: string, options?: QuestionParameters) => {
-        const markup = new Keyboard().requestContact("Поделиться контактом 📞").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 as any)?.delete?.().catch?.(() => {})
-        return answer.msg.contact as Contact
-    }
-
-    location = async (text: string, options?: QuestionParameters) => {
-        const markup = new Keyboard().requestLocation("Поделиться геопозицией 📍").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 as any)?.delete?.().catch?.(() => {})
-        return answer.msg.location as Location
-    }
-
-    poll = async (text: string, options?: QuestionPollParameters) => {
-        const pollType = options?.poll?.type
-        const markup = new Keyboard().requestPoll("Отправить опрос 📊", 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 as any)?.delete?.().catch?.(() => {})
-        return answer.msg.poll as Poll
-    }
-
-    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 as any).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 as any).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 as any).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 as any).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?.(() => {})
-        const photo = answer.msg.photo?.[0]
-        if (!photo) {
-            throw new Error("No photo found in update")
-        }
-        return photo.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

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