telega

0.9.0
2.3.0 2.2.1 2.2.0 2.1.0 2.0.0 1.2.0 1.1.0 1.0.0 0.15.0 0.14.0 0.13.0 0.12.1 0.12.0 0.11.0 0.10.0 0.9.0 0.8.0 0.7.0 0.6.0 0.5.1 0.5.0 0.4.0 0.3.0 0.2.0 0.1.1 0.1.0 0.0.6 0.0.5 0.0.4 0.0.3 0.0.2 0.0.1
Gleam Telegram Bot Library
HexDocs
Current section
Files
Jump to
Readme 32 Versions 10 Dependencies Dependants Files Activity
telega src telega@keyboard.erl
Raw
src/telega@keyboard.erl

-module(telega@keyboard).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/telega/keyboard.gleam").
-export([new/1, hear/1, to_markup/1, one_time/1, persistent/1, resized/1, placeholder/2, selected/1, button/1, web_app_button/2, new_inline/1, to_inline_markup/1, inline_button/2, inline_web_app_button/2, filter_inline_keyboard_query/1, new_callback_data/3, set_callback_data_delimiter/2, pack_callback/2, unpack_callback/2]).
-export_type([keyboard/0, inline_keyboard/0, keyboard_callback_data/1, keyboard_callback/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " This module contains the keyboard constructors and useful utilities to work with keyboards\n"
    " You can create a keyboard with `new` or `new_inline`.\n"
    "\n"
    " The simplest way to create a keyboard is to use `new` and use `hear` to listen for button presses:\n"
    " ```gleam\n"
    " let keyboard = keyboard.new([\n"
    "   [keyboard.button(\"Button 1\"), keyboard.button(\"Button 2\")],\n"
    "   [keyboard.button(\"Button 3\"), keyboard.button(\"Button 4\")],\n"
    " ])\n"
    " ```\n"
    "\n"
    " If you're using inline keyboard, you can use `new_inline` and `filter_inline_keyboard_query` to listen for button presses:\n"
    "\n"
    " ```gleam\n"
    " let keyboard = keyboard.new_inline([\n"
    "   [keyboard.inline_button(\"Button 1\", keyboard.pack_callback(callback_data, \"data\"))],\n"
    " ])\n"
    "\n"
    " // In handler:\n"
    " let filter = keyboard.filter_inline_keyboard_query(keyboard)\n"
    " ```\n"
).

-opaque keyboard() :: {keyboard,
        list(list(telega@model:keyboard_button())),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        gleam@option:option(binary()),
        gleam@option:option(boolean())}.

-opaque inline_keyboard() :: {inline_keyboard,
        list(list(telega@model:inline_keyboard_button()))}.

-opaque keyboard_callback_data(ANTI) :: {keyboard_callback_data,
        binary(),
        fun((ANTI) -> binary()),
        fun((binary()) -> ANTI),
        binary()}.

-type keyboard_callback(ANTJ) :: {keyboard_callback,
        ANTJ,
        binary(),
        binary(),
        keyboard_callback_data(ANTJ)}.

-file("src/telega/keyboard.gleam", 50).
?DOC(" Create a new keyboard\n").
-spec new(list(list(telega@model:keyboard_button()))) -> keyboard().
new(Buttons) ->
    {keyboard, Buttons, none, none, none, none, none}.

-file("src/telega/keyboard.gleam", 61).
-spec hear(keyboard()) -> telega@bot:hears().
hear(Keyboard) ->
    _pipe = erlang:element(2, Keyboard),
    _pipe@1 = gleam@list:flat_map(
        _pipe,
        fun(Row) ->
            gleam@list:map(Row, fun(Button) -> erlang:element(2, Button) end)
        end
    ),
    {hear_texts, _pipe@1}.

-file("src/telega/keyboard.gleam", 68).
?DOC(" Build a reply markup for `Message` from a keyboard\n").
-spec to_markup(keyboard()) -> telega@model:send_message_reply_markup_parameters().
to_markup(Keyboard) ->
    {send_message_reply_reply_keyboard_markup_parameters,
        {reply_keyboard_markup,
            erlang:element(2, Keyboard),
            erlang:element(3, Keyboard),
            erlang:element(4, Keyboard),
            erlang:element(5, Keyboard),
            erlang:element(6, Keyboard),
            erlang:element(7, Keyboard)}}.

-file("src/telega/keyboard.gleam", 80).
?DOC(" Make the keyboard one-time\n").
-spec one_time(keyboard()) -> keyboard().
one_time(Keyboard) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        {some, true},
        erlang:element(6, _record),
        erlang:element(7, _record)}.

-file("src/telega/keyboard.gleam", 85).
?DOC(" Make the keyboard persistent\n").
-spec persistent(keyboard()) -> keyboard().
persistent(Keyboard) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        {some, true},
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record)}.

-file("src/telega/keyboard.gleam", 90).
?DOC(" Make the keyboard resizable\n").
-spec resized(keyboard()) -> keyboard().
resized(Keyboard) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        erlang:element(3, _record),
        {some, true},
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record)}.

-file("src/telega/keyboard.gleam", 95).
?DOC(" Set the placeholder for the input field\n").
-spec placeholder(keyboard(), binary()) -> keyboard().
placeholder(Keyboard, Text) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        {some, Text},
        erlang:element(7, _record)}.

-file("src/telega/keyboard.gleam", 101).
?DOC(
    " Make the keyboard selective.\n"
    " Use this parameter if you want to show the keyboard to specific users only.\n"
).
-spec selected(keyboard()) -> keyboard().
selected(Keyboard) ->
    _record = Keyboard,
    {keyboard,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        {some, true}}.

-file("src/telega/keyboard.gleam", 106).
?DOC(" Create a new keyboard button\n").
-spec button(binary()) -> telega@model:keyboard_button().
button(Text) ->
    {keyboard_button, Text, none, none, none, none, none, none}.

-file("src/telega/keyboard.gleam", 119).
?DOC(" Create a new web app button\n").
-spec web_app_button(binary(), binary()) -> telega@model:keyboard_button().
web_app_button(Text, Url) ->
    _record = button(Text),
    {keyboard_button,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        {some, {web_app_info, Url}}}.

-file("src/telega/keyboard.gleam", 130).
?DOC(" Create a new inline keyboard\n").
-spec new_inline(list(list(telega@model:inline_keyboard_button()))) -> inline_keyboard().
new_inline(Buttons) ->
    {inline_keyboard, Buttons}.

-file("src/telega/keyboard.gleam", 135).
?DOC(" Build a reply markup for `Message` from an inline keyboard\n").
-spec to_inline_markup(inline_keyboard()) -> telega@model:send_message_reply_markup_parameters().
to_inline_markup(Keyboard) ->
    {send_message_reply_inline_keyboard_markup_parameters,
        {inline_keyboard_markup, erlang:element(2, Keyboard)}}.

-file("src/telega/keyboard.gleam", 144).
?DOC(" Create a new inline button\n").
-spec inline_button(binary(), keyboard_callback(any())) -> telega@model:inline_keyboard_button().
inline_button(Text, Callback_data) ->
    {inline_keyboard_button,
        Text,
        none,
        {some, erlang:element(4, Callback_data)},
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none}.

-file("src/telega/keyboard.gleam", 164).
?DOC(" Create a new web app button\n").
-spec inline_web_app_button(binary(), binary()) -> telega@model:inline_keyboard_button().
inline_web_app_button(Text, Url) ->
    {inline_keyboard_button,
        Text,
        none,
        none,
        {some, {web_app_info, Url}},
        none,
        none,
        none,
        none,
        none,
        none,
        none}.

-file("src/telega/keyboard.gleam", 184).
?DOC(" Filter for inline keyboard queries\n").
-spec filter_inline_keyboard_query(inline_keyboard()) -> telega@bot:callback_query_filter().
filter_inline_keyboard_query(Keyboard) ->
    Options = begin
        _pipe = erlang:element(2, Keyboard),
        _pipe@1 = gleam@list:flat_map(
            _pipe,
            fun(Row) ->
                gleam@list:map(
                    Row,
                    fun(Button) -> erlang:element(4, Button) end
                )
            end
        ),
        _pipe@2 = gleam@option:values(_pipe@1),
        gleam@string:join(_pipe@2, <<"|"/utf8>>)
    end,
    Re@1 = case gleam@regexp:from_string(
        <<<<"^("/utf8, Options/binary>>/binary, ")$"/utf8>>
    ) of
        {ok, Re} -> Re;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"telega/keyboard"/utf8>>,
                        function => <<"filter_inline_keyboard_query"/utf8>>,
                        line => 195,
                        value => _assert_fail,
                        start => 5609,
                        'end' => 5672,
                        pattern_start => 5620,
                        pattern_end => 5626})
    end,
    {callback_query_filter, Re@1}.

-file("src/telega/keyboard.gleam", 221).
?DOC(" Create a new callback data for inline keyboard buttons\n").
-spec new_callback_data(
    binary(),
    fun((ANTQ) -> binary()),
    fun((binary()) -> ANTQ)
) -> keyboard_callback_data(ANTQ).
new_callback_data(Id, Serialize, Deserialize) ->
    {keyboard_callback_data, Id, Serialize, Deserialize, <<":"/utf8>>}.

-file("src/telega/keyboard.gleam", 230).
?DOC(" Change the delimiter for the callback data, usefull if you need to use `:` in the id\n").
-spec set_callback_data_delimiter(keyboard_callback_data(ANTS), binary()) -> keyboard_callback_data(ANTS).
set_callback_data_delimiter(Data, Delimiter) ->
    _record = Data,
    {keyboard_callback_data,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        Delimiter}.

-file("src/telega/keyboard.gleam", 238).
?DOC(" Pack callback data into a callback\n").
-spec pack_callback(keyboard_callback_data(ANTV), ANTV) -> keyboard_callback(ANTV).
pack_callback(Callback_data, Data) ->
    Payload = <<<<(erlang:element(2, Callback_data))/binary,
            (erlang:element(5, Callback_data))/binary>>/binary,
        ((erlang:element(3, Callback_data))(Data))/binary>>,
    {keyboard_callback,
        Data,
        erlang:element(2, Callback_data),
        Payload,
        Callback_data}.

-file("src/telega/keyboard.gleam", 249).
?DOC(" Unpack payload into a callback\n").
-spec unpack_callback(binary(), keyboard_callback_data(ANTY)) -> {ok,
        keyboard_callback(ANTY)} |
    {error, nil}.
unpack_callback(Payload, Callback_data) ->
    gleam@result:'try'(
        gleam@string:split_once(Payload, erlang:element(5, Callback_data)),
        fun(_use0) ->
            {Id, Data} = _use0,
            {ok,
                {keyboard_callback,
                    (erlang:element(4, Callback_data))(Data),
                    Id,
                    Payload,
                    Callback_data}}
        end
    ).
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT