Merge branch 'master' into 1.0.0

2022-05-04 11:13:17 +06:00 · 2022-05-04 11:13:17 +06:00 · a2206b99a2
parent 721c3f2430 90e0b1ac81
commit a2206b99a2
8 changed files with 154 additions and 104 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -47,6 +47,22 @@ __All the `tgbotapi.extensions.*` packages have been removed__
 * `BehaviourBuilder`:
    * `SimpleFilter` now is a `fun interface` instead of just callback (fix of [#546](https://github.com/InsanusMokrassar/TelegramBotAPI/issues/546))

+## 0.38.20
+
+* `BehaviourBuilder FSM`:
+    * Hotfixes
+* `WebApps`:
+    * New extension `TelegramBot#answerWebAppQuery`
+    * New function `handleResult`
+
+## 0.38.19
+
+* `BehaviourBuilder`:
+    * Hotfixes
+* `BehaviourBuilder FSM`:
+    * `BehaviourContextWithFSMBuilder` deprecated in favor to `BehaviourContextWithFSM`
+    * Now it is possible to define additional handlers in subcontexts of `BehaviourBuilderWithFSM`
+
 ## 0.38.18

 * `Core`:
--- a/tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSM.kt
+++ b/tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSM.kt
@ -9,6 +9,8 @@ import dev.inmo.micro_utils.coroutines.accumulatorFlow
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.*
+import kotlin.jvm.JvmName
+import kotlin.reflect.KClass

 /**
 * Interface which combine [BehaviourContext] and [StatesMachine]. Subcontext of triggers and states contexts must have
@ -26,10 +28,31 @@ interface BehaviourContextWithFSM<T : State> : BehaviourContext, StatesMachine<T
        handlers: List<BehaviourWithFSMStateHandlerHolder<*, T>>
    ): T? {
        return handlers.firstOrNull { it.checkHandleable(state) } ?.run {
-            handleState(contextUpdatesFlow, state)
+            doInSubContext(updatesUpstreamFlow = contextUpdatesFlow) {
+                handleState(state)
+            }
        }
    }

+    /**
+     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
+     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see onStateOrSubstate
+     */
+    fun <I : T> add(kClass: KClass<I>, strict: Boolean = false, handler: BehaviourWithFSMStateHandler<I, T>)
+
+    /**
+     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
+     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
+     * requirements
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see strictlyOn
+     */
+    fun <I : T> addStrict(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) = add(kClass, strict = true, handler)
+
    override fun copy(
        bot: TelegramBot,
        scope: CoroutineScope,
@ -48,6 +71,28 @@ interface BehaviourContextWithFSM<T : State> : BehaviourContext, StatesMachine<T
    }
 }

+
+/**
+ * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
+ * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
+ *
+ * @see BehaviourWithFSMStateHandlerHolder
+ * @see BehaviourContextWithFSM.add
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+inline fun <reified I : O, O: State> BehaviourContextWithFSM<O>.onStateOrSubstate(handler: BehaviourWithFSMStateHandler<I, O>) = add(I::class, strict = false, handler)
+
+/**
+ * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
+ * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
+ * requirements
+ *
+ * @see BehaviourWithFSMStateHandlerHolder
+ * @see BehaviourContextWithFSM.addStrict
+ */
+@Suppress("MemberVisibilityCanBePrivate")
+inline fun <reified I : O, O: State> BehaviourContextWithFSM<O>.strictlyOn(handler: BehaviourWithFSMStateHandler<I, O>) = addStrict(I::class, handler)
+
 /**
 * Default realization of [BehaviourContextWithFSM]. It uses [behaviourContext] as a base for this object as
 * [BehaviourContext], but managing substates contexts updates for avoiding of updates lost between states
@ -58,6 +103,9 @@ class DefaultBehaviourContextWithFSM<T : State>(
    private val handlers: List<BehaviourWithFSMStateHandlerHolder<*, T>>
 ) : BehaviourContext by behaviourContext, BehaviourContextWithFSM<T> {
    private val updatesFlows = mutableMapOf<Any, Flow<Update>>()
+    private val additionalHandlers = mutableListOf<BehaviourWithFSMStateHandlerHolder<*, T>>()
+    private var actualHandlersList = additionalHandlers + handlers
+
    private fun getContextUpdatesFlow(context: Any) = updatesFlows.getOrPut(context) {
        allUpdatesFlow.accumulatorFlow(scope)
    }
@ -65,12 +113,17 @@ class DefaultBehaviourContextWithFSM<T : State>(
    override suspend fun StatesMachine<in T>.handleState(state: T): T? = launchStateHandling(
        state,
        allUpdatesFlow,
-        handlers
+        actualHandlersList
    )

+    override fun <I : T> add(kClass: KClass<I>, strict: Boolean, handler: BehaviourWithFSMStateHandler<I, T>) {
+        additionalHandlers.add(BehaviourWithFSMStateHandlerHolder(kClass, strict, handler))
+        actualHandlersList = additionalHandlers + handlers
+    }
+
    override fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
        val statePerformer: suspend (T) -> Unit = { state: T ->
-            val newState = launchStateHandling(state, getContextUpdatesFlow(state.context), handlers)
+            val newState = launchStateHandling(state, getContextUpdatesFlow(state.context), actualHandlersList)
            if (newState != null) {
                statesManager.update(state, newState)
            } else {
@ -94,6 +147,26 @@ class DefaultBehaviourContextWithFSM<T : State>(
            launch { statePerformer(it) }
        }
    }
+    /**
+     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
+     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see BehaviourContextWithFSM.add
+     */
+    @Suppress("MemberVisibilityCanBePrivate")
+    inline fun <reified I : T> onStateOrSubstate(handler: BehaviourWithFSMStateHandler<I, T>) = add(I::class, strict = false, handler)
+
+    /**
+     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
+     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
+     * requirements
+     *
+     * @see BehaviourWithFSMStateHandlerHolder
+     * @see BehaviourContextWithFSM.addStrict
+     */
+    @Suppress("MemberVisibilityCanBePrivate")
+    inline fun <reified I : T> strictlyOn(handler: BehaviourWithFSMStateHandler<I, T>) = addStrict(I::class, handler)

    override suspend fun startChain(state: T) {
        statesManager.startChain(state)
@ -106,7 +179,7 @@ class DefaultBehaviourContextWithFSM<T : State>(
        onBufferOverflow: BufferOverflow,
        upstreamUpdatesFlow: Flow<Update>?,
        updatesFilter: BehaviourContextAndTypeReceiver<Boolean, Update>?
-    ): BehaviourContextWithFSM<T> = BehaviourContextWithFSM(
+    ): DefaultBehaviourContextWithFSM<T> = BehaviourContextWithFSM(
        behaviourContext.copy(bot, scope, broadcastChannelsSize, onBufferOverflow, upstreamUpdatesFlow, updatesFilter),
        handlers,
        statesManager
--- a/tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSMBuilder.kt
+++ b/tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSMBuilder.kt
@ -14,70 +14,8 @@ import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.Flow
 import kotlin.reflect.KClass

-class BehaviourContextWithFSMBuilder<T : State> internal constructor(
-    private val resultBehaviourContext: BehaviourContextWithFSM<T>,
-    private val handlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>>
-) : BehaviourContextWithFSM<T> by resultBehaviourContext {
-    internal constructor(
-        baseBehaviourContext: BehaviourContext,
-        statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-        handlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf()
-    ) : this(DefaultBehaviourContextWithFSM(baseBehaviourContext, statesManager, handlers), handlers)
-
-    /**
-     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
-     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see onStateOrSubstate
-     */
-    fun <I : T> add(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) {
-        handlers.add(BehaviourWithFSMStateHandlerHolder(kClass, false, handler))
-    }
-
-    /**
-     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
-     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
-     * requirements
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see strictlyOn
-     */
-    fun <I : T> addStrict(kClass: KClass<I>, handler: BehaviourWithFSMStateHandler<I, T>) {
-        handlers.add(BehaviourWithFSMStateHandlerHolder(kClass, true, handler))
-    }
-
-
-    /**
-     * Add NON STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Non strict means that
-     * for input [State] will be used [KClass.isInstance] and any inheritor of [kClass] will pass this requirement
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see BehaviourContextWithFSMBuilder.add
-     */
-    @Suppress("MemberVisibilityCanBePrivate")
-    inline fun <reified I : T> onStateOrSubstate(handler: BehaviourWithFSMStateHandler<I, T>) {
-        add(I::class, handler)
-    }
-
-    /**
-     * Add STRICT [handler] to list of available in future [BehaviourContextWithFSM]. Strict means that
-     * for input [State] will be used [State]::class == [kClass] and any [State] with exactly the same type will pass
-     * requirements
-     *
-     * @see BehaviourWithFSMStateHandlerHolder
-     * @see BehaviourContextWithFSMBuilder.addStrict
-     */
-    @Suppress("MemberVisibilityCanBePrivate")
-    inline fun <reified I : T> strictlyOn(handler: BehaviourWithFSMStateHandler<I, T>) {
-        addStrict(I::class, handler)
-    }
-
-    /**
-     * Returns completed [resultBehaviourContext], [handlers] and [statesManager]
-     */
-    internal fun build() = resultBehaviourContext
-}
+@Deprecated("Will be removed soon")
+typealias BehaviourContextWithFSMBuilder<T> = BehaviourContextWithFSM<T>

 /**
 * Creates [BehaviourContextWithFSM] via creating of [DefaultBehaviourContext] with [this] as [TelegramBot],
@ -94,17 +32,17 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
    scope: CoroutineScope = defaultCoroutineScopeProvider(),
    defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
    statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
-): BehaviourContextWithFSM<T> = BehaviourContextWithFSMBuilder(
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
+): DefaultBehaviourContextWithFSM<T> = BehaviourContextWithFSM(
    DefaultBehaviourContext(
        this,
        defaultExceptionsHandler ?.let { scope + ContextSafelyExceptionHandler(it) } ?: scope,
        upstreamUpdatesFlow = upstreamUpdatesFlow
    ),
-    statesManager,
-    presetHandlers
-).apply { block() }.build()
+    presetHandlers,
+    statesManager
+).apply { block() }

 /**
 * Use [buildBehaviourWithFSM] to create [BehaviourContextWithFSM] and launch getting of updates
@ -116,9 +54,9 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
    scope: CoroutineScope = defaultCoroutineScopeProvider(),
    defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
    statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
-): Pair<BehaviourContextWithFSM<T>, Job> = buildBehaviourWithFSM(
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
+): Pair<DefaultBehaviourContextWithFSM<T>, Job> = buildBehaviourWithFSM(
    upstreamUpdatesFlow,
    scope,
    defaultExceptionsHandler,
@ -147,8 +85,8 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
 * @see BehaviourContext
 * @see BehaviourContextWithFSM
 * @see longPolling
- * @see BehaviourContextWithFSMBuilder.strictlyOn
- * @see BehaviourContextWithFSMBuilder.onStateOrSubstate
+ * @see BehaviourContextWithFSM.strictlyOn
+ * @see BehaviourContextWithFSM.onStateOrSubstate
 */
@PreviewFeature
 suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
@ -156,17 +94,17 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
    scope: CoroutineScope = defaultCoroutineScopeProvider(),
    defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
    statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
-): BehaviourContextWithFSM<T> = BehaviourContextWithFSMBuilder(
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
+): DefaultBehaviourContextWithFSM<T> = BehaviourContextWithFSM(
    DefaultBehaviourContext(
        this,
        defaultExceptionsHandler ?.let { scope + ContextSafelyExceptionHandler(it) } ?: scope,
        upstreamUpdatesFlow = flowUpdatesFilter.allUpdatesFlow
    ),
-    statesManager,
-    presetHandlers
-).apply { block() }.build()
+    presetHandlers,
+    statesManager
+).apply { block() }

 /**
 * Use [buildBehaviourWithFSM] to create [BehaviourContextWithFSM] and launch getting of updates
@ -176,16 +114,16 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
 * @see buildBehaviourWithFSMAndStartLongPolling
 * @see BehaviourContext
 * @see longPolling
- * @see BehaviourContextWithFSMBuilder.strictlyOn
- * @see BehaviourContextWithFSMBuilder.onStateOrSubstate
+ * @see BehaviourContextWithFSM.strictlyOn
+ * @see BehaviourContextWithFSM.onStateOrSubstate
 */
@PreviewFeature
 suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
    scope: CoroutineScope = defaultCoroutineScopeProvider(),
    defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
    statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ) = FlowsUpdatesFilter().let {
    buildBehaviourWithFSM(
        it,
--- a/tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourWithFSMStateHandlerHolder.kt
+++ b/tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourWithFSMStateHandlerHolder.kt
@ -34,20 +34,11 @@ class BehaviourWithFSMStateHandlerHolder<I : O, O : State>(

    /**
     * Handling of state :)
-     *
-     * @param contextUpdatesFlow This [Flow] will be used as source of updates. By contract, this [Flow] must be common
-     * for all [State]s of incoming [state] [State.context] and for the whole chain inside of [BehaviourContextWithFSM]
     */
    suspend fun BehaviourContextWithFSM<in O>.handleState(
-        contextUpdatesFlow: Flow<Update>,
        state: O
-    ): O? {
-        val subscope = scope.LinkedSupervisorScope()
-        return with(copy(scope = subscope, upstreamUpdatesFlow = contextUpdatesFlow)) {
-            with(delegateTo) {
-                handleState(state as I)
-            }
-        }
+    ): O? = with(delegateTo) {
+        handleState(state as I)
    }
 }

--- a/tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/TelegramBotWithFSM.kt
+++ b/tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/TelegramBotWithFSM.kt
@ -37,9 +37,9 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
    builder: KtorRequestsExecutorBuilder.() -> Unit = {},
    defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
    statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
    testServer: Boolean = false,
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): TelegramBot = telegramBot(
    token,
    apiUrl,
@ -74,9 +74,9 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSMAndStartLongPolling(
    builder: KtorRequestsExecutorBuilder.() -> Unit = {},
    defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
    statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
-    presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
+    presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
    testServer: Boolean = false,
-    block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
+    block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): Pair<TelegramBot, Job> {
    return telegramBot(
        token,
--- a/tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/answers/AnswerWebAppQuery.kt
+++ b/tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/answers/AnswerWebAppQuery.kt
@ -6,6 +6,9 @@ import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.abstracts.InlineQ
 import dev.inmo.tgbotapi.types.webapps.query.SentWebAppMessage
 import kotlinx.serialization.*

+/**
+ * @param webAppQueryId [dev.inmo.tgbotapi.webapps.WebAppInitData.queryId]
+ */
@Serializable
 data class AnswerWebAppQuery(
    @SerialName(webAppQueryIdField)
--- a/tgbotapi.webapps/src/jsMain/kotlin/dev/inmo/tgbotapi/webapps/AnswerWebAppQuery.kt
+++ b/tgbotapi.webapps/src/jsMain/kotlin/dev/inmo/tgbotapi/webapps/AnswerWebAppQuery.kt
@ -0,0 +1,11 @@
+package dev.inmo.tgbotapi.webapps
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.answers.AnswerWebAppQuery
+import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.abstracts.InlineQueryResult
+
+suspend fun TelegramBot.answerWebAppQuery(
+    result: InlineQueryResult
+) = webApp.initDataUnsafe.queryId ?.let {
+    execute(AnswerWebAppQuery(it, result))
+}
--- a/tgbotapi.webapps/src/jsMain/kotlin/dev/inmo/tgbotapi/webapps/SendData.kt
+++ b/tgbotapi.webapps/src/jsMain/kotlin/dev/inmo/tgbotapi/webapps/SendData.kt
@ -0,0 +1,18 @@
+package dev.inmo.tgbotapi.webapps
+
+import dev.inmo.tgbotapi.types.WebAppQueryId
+
+/**
+ * @param onSendData Should return the data which must be used in [WebApp.sendData]. If returns null, data will not be sent
+ * @param onAnswerWebAppQuery In case if [WebAppInitData.queryId] is presented in [WebApp.initDataUnsafe], will be called
+ * that callback. Before and after calling of this callback will not be used any method of answering to the telegram
+ * system, so, you must use something like [answerWebAppQuery] by yourself to send the result
+ */
+inline fun handleResult(
+    onSendData: () -> String?,
+    onAnswerWebAppQuery: (WebAppQueryId) -> Unit
+) {
+    webApp.initDataUnsafe.queryId ?.let {
+        onAnswerWebAppQuery(it)
+    } ?: webApp.sendData(onSendData() ?: return)
+}