hspylib-clitt 0.9.116__py3-none-any.whl → 0.9.118__py3-none-any.whl

build/lib/build/lib/clitt/core/tui/mdashboard/menu_dashboard.py

@@ -1,154 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.mdashboard
-      @file: menu_dashboard.py
-   @created: Tue, 4 May 2021
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-from clitt.core.icons.font_awesome.nav_icons import NavIcons
-from clitt.core.term.commons import Direction, Portion
-from clitt.core.tui.mdashboard.dashboard_builder import DashboardBuilder
-from clitt.core.tui.mdashboard.dashboard_item import DashboardItem
-from clitt.core.tui.tui_component import TUIComponent
-from hspylib.core.preconditions import check_state
-from hspylib.modules.cli.keyboard import Keyboard
-from typing import List, Optional, TypeAlias
-
-DashboardMatrix: TypeAlias = List[List[str]]
-
-
-class MenuDashBoard(TUIComponent):
-    """A dashboard is a type of graphical user interface which provides at-a-glance views."""
-
-    # fmt: off
-    ICN = "x"  # x mars the spot if the icon.
-
-    # Selected cell template.
-    CELL_TPL = [
-        [" ", " ", " ", " ", " ", " ", " "],
-        [" ", " ", " ", ICN, " ", " ", " "],
-        [" ", " ", " ", " ", " ", " ", " "],
-    ]
-
-    # Unselected cell template.
-    SEL_CELL_TPL = [
-        [" ", "╭", " ", " ", " ", "╮", " "],
-        [" ", " ", " ", ICN, " ", " ", " "],
-        [" ", "╰", " ", " ", " ", "╯", " "],
-    ]
-    # fmt: on
-
-    NAV_ICONS = NavIcons.compose(NavIcons.LEFT, NavIcons.DOWN, NavIcons.UP, NavIcons.RIGHT)
-
-    COLUMN_OFFSET = 10
-
-    MIN_COLUMNS = 2
-
-    @classmethod
-    def builder(cls) -> DashboardBuilder:
-        return DashboardBuilder()
-
-    def __init__(self, title: str, items: List[DashboardItem]):
-        super().__init__(title)
-        self._items = items
-        self._tab_index = 0
-        check_state(
-            len(self.CELL_TPL) == len(self.SEL_CELL_TPL) and len(self.CELL_TPL[0]) == len(self.SEL_CELL_TPL[0]),
-            "Invalid CELL definitions. Selected and Unselected matrices should have the same lengths.",
-        )
-
-    def execute(self) -> Optional[DashboardItem]:
-        if (len(self._items)) == 0:
-            return None
-
-        self._prepare_render()
-        keypress = self._loop()
-        selected = self._items[self._tab_index] if keypress == Keyboard.VK_ENTER else None
-
-        if selected and selected.on_trigger:
-            selected.on_trigger()
-
-        return selected
-
-    def render(self) -> None:
-        self.cursor.restore()
-        self.writeln(f"{self.prefs.title_color.placeholder}{self.title}%EOL%%NC%")
-
-        for idx, item in enumerate(self._items):
-            self._draw_item(
-                idx, item, MenuDashBoard.CELL_TPL if self._tab_index != idx else MenuDashBoard.SEL_CELL_TPL
-            )
-
-        self.cursor.erase(Portion.LINE)
-        self.cursor.move_to(column=1)
-        self.draw_navbar(self.navbar())
-        self._re_render = False
-
-    def navbar(self, **kwargs) -> str:
-        return (
-            f"{NavIcons.POINTER} %GREEN%{self._items[self._tab_index].tooltip}%NC%"
-            f"%EOL%{self.prefs.navbar_color.placeholder}%EOL%"
-            f"[Enter] Select  Navigate  {self.NAV_ICONS}  Next  [Tab]  [Esc] Quit %NC%"
-        )
-
-    def handle_keypress(self) -> Keyboard:
-        length = len(self._items)
-        if keypress := Keyboard.wait_keystroke():
-            match keypress:
-                case _ as key if key in [Keyboard.VK_ESC, Keyboard.VK_ENTER]:
-                    self._done = True
-                case Keyboard.VK_UP:
-                    self._tab_index = max(0, self._tab_index - self._items_per_line())
-                case Keyboard.VK_DOWN:
-                    self._tab_index = min(length - 1, self._tab_index + self._items_per_line())
-                case _ as key if key in [Keyboard.VK_LEFT, Keyboard.VK_SHIFT_TAB]:
-                    self._tab_index = max(0, self._tab_index - 1)
-                case _ as key if key in [Keyboard.VK_RIGHT, Keyboard.VK_TAB]:
-                    self._tab_index = min(length - 1, self._tab_index + 1)
-
-        self._re_render = True
-
-        return keypress
-
-    def _draw_item(
-        self,
-        item_idx: int,
-        item: DashboardItem,
-        cell_template: DashboardMatrix) -> None:
-        """Print the specified dashboard item at the given index.
-        :param item_idx: the item index.
-        :param item: the dashboard item.
-        :param cell_template: the template of the dashboard cell (selected or unselected).
-        """
-
-        num_cols, num_rows = len(cell_template[0]), len(cell_template)
-
-        for row in range(0, num_rows):
-            for col in range(0, num_cols):
-                cur_cell = cell_template[row][col]
-                # Print current cell
-                self.write(f"{item.icon if cur_cell == self.ICN else cur_cell}")
-            # Move to the next the next row
-            self.cursor.move(1, Direction.DOWN)
-            self.cursor.move(num_cols, Direction.LEFT)
-
-        if item_idx > 0 and (item_idx + 1) % self._items_per_line() == 0:
-            # Break the line
-            self.cursor.move(1, Direction.DOWN)
-            self.cursor.move(num_cols * self._items_per_line(), Direction.LEFT)
-        elif item_idx + 1 < len(self._items):
-            # Continue on the same line
-            self.cursor.move(num_rows, Direction.UP)
-            self.cursor.move(num_cols, Direction.RIGHT)
-
-    def _items_per_line(self) -> int:
-        """TODO"""
-        screen_columns = self.screen.columns - self.COLUMN_OFFSET
-        return max(self.MIN_COLUMNS, min(self.prefs.items_per_line, screen_columns))

build/lib/build/lib/clitt/core/tui/menu/__init__.py

@@ -1,16 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.build.lib.clitt.core.tui.menu
-"""Package initialization."""
-
-__all__ = [
-    'tui_menu', 
-    'tui_menu_action', 
-    'tui_menu_factory', 
-    'tui_menu_item', 
-    'tui_menu_ui', 
-    'tui_menu_view'
-]
-__version__ = '0.9.116'

build/lib/build/lib/clitt/core/tui/menu/tui_menu.py

@@ -1,111 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.menu
-      @file: tui_menu.py
-   @created: Tue, 4 May 2021
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-
-from abc import ABC
-from clitt.core.icons.font_awesome.nav_icons import NavIcons
-from clitt.core.tui.minput.input_validator import InputValidator
-from clitt.core.tui.minput.menu_input import MenuInput
-from clitt.core.tui.minput.minput import minput
-from clitt.core.tui.tui_component import TUIComponent
-from hspylib.core.namespace import Namespace
-from hspylib.modules.cli.keyboard import Keyboard
-from typing import Callable, Optional, TypeAlias
-
-OnTrigger_Cb: TypeAlias = Callable[["TUIMenu"], Optional["TUIMenu"]]
-
-
-class TUIMenu(TUIComponent, ABC):
-    """Provide a base class for terminal UI menus."""
-
-    @staticmethod
-    def prompt(
-        label: str, dest: str = None, min_length: int = 1, max_length: int = 32, validator: InputValidator = None
-    ) -> Optional[Namespace]:
-        # fmt: off
-        form_fields = (
-            MenuInput.builder()
-                .field()
-                .label(label)
-                .dest(dest or label)
-                .validator(validator or InputValidator.words())
-                .min_max_length(min_length, max_length)
-                .build()
-            .build()
-        )
-        # fmt: on
-
-        return minput(form_fields)
-
-    def __init__(
-        self,
-        parent: Optional["TUIMenu"] = None,
-        title: str = "",
-        tooltip: str = "",
-        default_on_trigger_cb: OnTrigger_Cb = None,
-    ):
-        super().__init__(title)
-        self._tooltip = tooltip
-        self._parent = parent
-        self._on_trigger = default_on_trigger_cb or self._default_trigger_cb
-
-    def __str__(self) -> str:
-        return self._title
-
-    def __repr__(self) -> str:
-        return str(self)
-
-    @property
-    def parent(self) -> Optional["TUIMenu"]:
-        return self._parent
-
-    @property
-    def tooltip(self) -> str:
-        return self._tooltip
-
-    def handle_keypress(self) -> Keyboard:
-        if keypress := Keyboard.wait_keystroke():
-            match keypress:
-                case Keyboard.VK_ENTER | Keyboard.VK_ESC:
-                    self._done = True
-
-        return keypress
-
-    def navbar(self, **kwargs) -> str:
-        return (
-            f"%EOL%{self.breadcrumb()}%ED0%"
-            f"%EOL%{self.prefs.navbar_color.placeholder}%EOL%"
-            f"[Enter] Back  [Esc] Quit  %EL0%%EOL%%EOL%%NC%"
-        )
-
-    def breadcrumb(self) -> str:
-        """Provide a breadcrumb of menus for navigation purposes."""
-        return (
-            f"{self.prefs.breadcrumb_color.placeholder}"
-            f" {NavIcons.BREADCRUMB} {self.title} %NC%"
-            f"{self.prefs.tooltip_color.placeholder}"
-        )
-
-    def wait_keystroke(self, wait_message: str = "%YELLOW%%EOL%Press any key to continue%EOL%%NC%") -> None:
-        """Wait for a keypress (blocking).
-        :param wait_message: the message to present to the user.
-        """
-        self.writeln(wait_message)
-        Keyboard.wait_keystroke()
-
-    def _default_trigger_cb(self, source: Optional["TUIMenu"]) -> Optional["TUIMenu"]:
-        """Provide a default trigger callback when a menu is activated. Provided a source menu, returns it's parent.
-        :param source: the source which invoked this menu.
-        """
-        return self.parent

build/lib/build/lib/clitt/core/tui/menu/tui_menu_action.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.menu
-      @file: tui_menu_action.py
-   @created: Tue, 4 May 2021
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-from clitt.core.tui.menu.tui_menu import OnTrigger_Cb, TUIMenu
-from clitt.core.tui.menu.tui_menu_ui import TUIMenuUi
-from typing import Optional
-
-
-class TUIMenuAction(TUIMenu):
-    """Represent a menu item action. Each action trigger a callback function."""
-
-    def execute(self) -> Optional[TUIMenu]:
-        self.render()
-        ret_menu = self._on_trigger(self._parent)
-        if not ret_menu:
-            self.wait_keystroke()
-        return ret_menu if ret_menu else self._default_trigger_cb(self)
-
-    def render(self) -> None:
-        self.screen.cursor.restore()
-        TUIMenuUi.render_app_title()
-
-    def __init__(
-        self,
-        parent: TUIMenu,
-        title: Optional[str] = None,
-        tooltip: Optional[str] = None,
-        on_trigger: OnTrigger_Cb = None,
-    ):
-        super().__init__(parent, title, tooltip)
-        self._parent = parent
-        self._on_trigger: OnTrigger_Cb = on_trigger or super()._default_trigger_cb
-
-    def on_trigger(self, cb_on_trigger: OnTrigger_Cb) -> None:
-        """Setter for the on_trigger callback. It is called when a menu item is triggered."""
-        self._on_trigger = cb_on_trigger

build/lib/build/lib/clitt/core/tui/menu/tui_menu_factory.py

@@ -1,117 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.menu
-      @file: tui_menu_factory.py
-   @created: Tue, 4 May 2021
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-
-from clitt.core.tui.menu.tui_menu import TUIMenu
-from clitt.core.tui.menu.tui_menu_action import OnTrigger_Cb, TUIMenuAction
-from clitt.core.tui.menu.tui_menu_item import TUIMenuItem
-from clitt.core.tui.menu.tui_menu_view import TUIMenuView
-from hspylib.core.preconditions import check_not_none
-from typing import List, TypeAlias, Union
-
-MenuBuilder: TypeAlias = Union[
-    "TUIMenuFactory.TUIMenuBuilder", "TUIMenuFactory.TUIMenuItemBuilder", "TUIMenuFactory.TUIMenuViewBuilder"
-]
-
-
-class TUIMenuFactory:
-    """TODO"""
-
-    _main_menu = None
-
-    class TUIMenuBuilder:
-        """TODO"""
-
-        def __init__(self, parent: "TUIMenuFactory", main_menu: TUIMenuItem):
-            check_not_none((parent, main_menu))
-            self._parent = parent
-            self._main_menu: TUIMenuItem = main_menu
-
-        def with_item(self, title: str, tooltip: str | None = None) -> "TUIMenuFactory.TUIMenuItemBuilder":
-            return TUIMenuFactory.TUIMenuItemBuilder(self, self._main_menu, title, tooltip)
-
-        def with_action(self, title: str, tooltip: str | None = None) -> "TUIMenuFactory.TUIMenuActionBuilder":
-            return TUIMenuFactory.TUIMenuActionBuilder(self, self._main_menu, title, tooltip)
-
-        def with_view(self, title: str, tooltip: str | None = None) -> "TUIMenuFactory.TUIMenuViewBuilder":
-            return TUIMenuFactory.TUIMenuViewBuilder(self, self._main_menu, title, tooltip)
-
-        def then(self) -> "TUIMenuFactory":
-            return self._parent
-
-    class TUIMenuItemBuilder:
-        """TODO"""
-
-        def __init__(
-            self, parent: MenuBuilder, parent_item: TUIMenuItem, title: str = None, tooltip: str | None = None
-        ):
-            check_not_none((parent, parent_item))
-            self._parent = parent
-            self._menu_item = TUIMenuItem(parent_item, title, tooltip)
-            self._items: List[TUIMenu] = []
-            parent_item.add_items(self._menu_item)
-
-        def with_item(self, title: str, tooltip: str | None = None) -> "TUIMenuFactory.TUIMenuItemBuilder":
-            return TUIMenuFactory.TUIMenuItemBuilder(self, self._menu_item, title, tooltip)
-
-        def with_action(self, title: str, tooltip: str | None = None) -> "TUIMenuFactory.TUIMenuActionBuilder":
-            return TUIMenuFactory.TUIMenuActionBuilder(self, self._menu_item, title, tooltip)
-
-        def with_view(self, title: str, tooltip: str | None = None) -> "TUIMenuFactory.TUIMenuViewBuilder":
-            return TUIMenuFactory.TUIMenuViewBuilder(self, self._menu_item, title, tooltip)
-
-        def then(self) -> MenuBuilder:
-            return self._parent
-
-    class TUIMenuViewBuilder:
-        """TODO"""
-
-        def __init__(
-            self, parent: MenuBuilder, parent_item: TUIMenuItem, title: str = None, tooltip: str | None = None
-        ):
-            check_not_none((parent, parent_item))
-            self._parent = parent
-            self._menu_view = TUIMenuView(parent_item, title, tooltip)
-            parent_item.add_items(self._menu_view)
-
-        def on_render(self, on_render: str | OnTrigger_Cb) -> "TUIMenuFactory.TUIMenuItemBuilder":
-            self._menu_view.on_render(on_render)
-            return self._parent
-
-    class TUIMenuActionBuilder:
-        """TODO"""
-
-        def __init__(
-            self, parent: MenuBuilder, parent_item: TUIMenuItem, title: str = None, tooltip: str | None = None
-        ):
-            check_not_none((parent, parent_item))
-            self._parent = parent
-            self._menu_action = TUIMenuAction(parent_item, title, tooltip)
-            self._parent_item = parent_item
-            parent_item.add_items(self._menu_action)
-
-        def on_trigger(self, action: OnTrigger_Cb) -> "TUIMenuFactory.TUIMenuItemBuilder":
-            check_not_none(action)
-            self._menu_action.on_trigger(action)
-            return self._parent
-
-    @classmethod
-    def create_main_menu(cls, title: str = None, tooltip: str | None = None) -> "TUIMenuBuilder":
-        cls._main_menu = TUIMenuItem(title=title, tooltip=tooltip)
-        factory = TUIMenuFactory()
-
-        return cls.TUIMenuBuilder(factory, cls._main_menu)
-
-    def build(self) -> TUIMenuItem:
-        return self._main_menu

build/lib/build/lib/clitt/core/tui/menu/tui_menu_item.py

@@ -1,196 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.menu
-      @file: tui_menu_item.py
-   @created: Tue, 4 May 2021
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-
-from clitt.core.icons.font_awesome.nav_icons import NavIcons
-from clitt.core.term.commons import Direction, Portion
-from clitt.core.tui.menu.tui_menu import TUIMenu
-from clitt.core.tui.menu.tui_menu_ui import TUIMenuUi
-from functools import cached_property
-from hspylib.core.tools.dict_tools import get_or_default
-from hspylib.modules.cli.keyboard import Keyboard
-from typing import List, Optional
-
-
-class TUIMenuItem(TUIMenu):
-    """Represent a menu item with submenus. Each sub-item must belong to the TUIMenu class and can be an instance of
-    TUIMenuItem, TUIMenuAction or TUIMenuView.
-    """
-
-    ROW_OFFSET = 5
-
-    NAV_ICONS = NavIcons.compose(NavIcons.UP, NavIcons.DOWN)
-
-    def __init__(
-        self,
-        parent: Optional[TUIMenu] = None,
-        title: str = "Sub Menu",
-        tooltip: str = None,
-        items: List[TUIMenu] = None,
-    ):
-        super().__init__(parent, title, tooltip or f"Access the '{title}' menu")
-        self._show_from: int = 0
-        self._show_to: int = self.screen.lines - self.ROW_OFFSET
-        self._diff_index: int = self._show_to - self._show_from
-        self._sel_index: int = 0
-        self._items: List[TUIMenu] = items or []
-        self._max_line_length = max(len(str(menu)) for menu in self._items) if self._items else len(str(self))
-
-    @property
-    def items(self) -> List[TUIMenu]:
-        return self._items
-
-    def add_items(self, *items: TUIMenu) -> None:
-        """Add submenu items to the menu."""
-        list(map(self._items.append, items))
-
-    def execute(self) -> Optional[TUIMenu]:
-        # Wait for user interaction
-        while not self._done:
-            if not self._items:
-                return self._on_trigger(self._parent)
-
-            # Menu Renderization
-            if self._re_render:
-                self.render()
-
-            # Navigation input
-            if self.handle_keypress() == Keyboard.VK_ENTER:
-                return self._on_trigger(self._parent)
-
-        return None
-
-    def render(self) -> None:
-        length = len(self._items)
-        self.cursor.restore()
-        TUIMenuUi.render_app_title()
-
-        if length > 0:
-            for idx in range(self._show_from, self._show_to):
-                if idx >= length:
-                    break  # When the number of items is lower than the max_rows, skip the other lines
-                option_line = str(self._items[idx])
-                self.cursor.erase(Portion.LINE)
-                # Print the selector if the index is currently selected
-                selector = self.draw_selector(is_selected=(idx == self._sel_index), has_bg_color=False)
-                # fmt: off
-                line_fmt = (
-                    "  {:>" + f"{len(str(length))}" + "}  "
-                    + "{:>" + f"{len(selector)}" + "}  "
-                    + "{:<" + f"{self._max_line_length}" + "}  "
-                )
-                # fmt: on
-                self.draw_line(line_fmt, idx + 1, selector, option_line)
-
-        self.draw_navbar(self.navbar(to=length))
-        self._re_render = False
-
-    def navbar(self, **kwargs) -> str:
-        menu = get_or_default(self.items, self._sel_index, None)
-        tooltip = menu.tooltip if menu else None
-        return (
-            f"%EOL%%GREEN%{self.breadcrumb()} "
-            f"{tooltip + ' ' if tooltip else ''}%ED0%%NC%"
-            f"%EOL%{self.prefs.navbar_color.placeholder}%EOL%"
-            f"[Enter] Select  Navigate  [{self.NAV_ICONS}]  "
-            f"[Esc] Quit  [1..{kwargs['to']}] Goto: %NC%%EL0%%EOL%%EOL%"
-        )
-
-    def handle_keypress(self) -> Keyboard:
-        """Handle a keyboard press."""
-        if keypress := Keyboard.wait_keystroke():
-            match keypress:
-                case Keyboard.VK_ESC:
-                    self._done = True
-                case Keyboard.VK_UP:
-                    self._handle_key_up()
-                case Keyboard.VK_DOWN:
-                    self._handle_key_down()
-                case Keyboard.VK_TAB:
-                    self._handle_tab()
-                case Keyboard.VK_SHIFT_TAB:
-                    self._handle_shift_tab()
-                case _ as key if key in self._digits:
-                    self._handle_digit(keypress)
-            self._re_render = True
-
-        return keypress
-
-    def _handle_key_up(self) -> None:
-        """Handle a key up (arrow up) press."""
-        if self._sel_index == self._show_from and self._show_from > 0:
-            self._show_from -= 1
-            self._show_to -= 1
-        if self._sel_index - 1 >= 0:
-            self._sel_index -= 1
-            self._re_render = True
-
-    def _handle_key_down(self) -> None:
-        """Handle a key down (arrow down) press."""
-        length = len(self.items)
-        if self._sel_index + 1 == self._show_to and self._show_to < length:
-            self._show_from += 1
-            self._show_to += 1
-        if self._sel_index + 1 < length:
-            self._sel_index += 1
-            self._re_render = True
-
-    def _handle_tab(self) -> None:
-        """Handle a tab keypress."""
-        length = len(self.items)
-        page_index = min(self._show_to + self._diff_index, length)
-        self._show_to = max(page_index, self._diff_index)
-        self._show_from = self._show_to - self._diff_index
-        self._sel_index = self._show_from
-        self._re_render = True
-
-    def _handle_shift_tab(self) -> None:
-        """Handle a shift tab keypress."""
-        page_index = max(self._show_from - self._diff_index, 0)
-        self._show_from = min(page_index, self._diff_index)
-        self._show_to = self._show_from + self._diff_index
-        self._sel_index = self._show_from
-        self._re_render = True
-
-    def _handle_digit(self, digit: Keyboard) -> None:
-        """Handle a digit keypress.
-        :param digit: the digit pressed.
-        """
-        length = len(self._items)
-        typed_index = digit.value
-        self.write(digit.value)  # echo the digit typed
-        index_len = 1
-        while len(typed_index) < len(str(length)):
-            keystroke = Keyboard.wait_keystroke()
-            if not keystroke or not keystroke.isdigit():
-                typed_index = None if keystroke != Keyboard.VK_ENTER else typed_index
-                break
-            typed_index = f"{typed_index}{keystroke.value if keystroke else ''}"
-            self.write(f"{keystroke.value if keystroke else ''}")
-            index_len += 1
-        # Erase the index typed by the user
-        self.cursor.move(index_len, Direction.LEFT)
-        self.cursor.erase(Direction.RIGHT)
-        if typed_index and 1 <= int(typed_index) <= length:
-            self._show_to = max(int(typed_index), self._diff_index)
-            self._show_from = self._show_to - self._diff_index
-            self._sel_index = int(typed_index) - 1
-            self._re_render = True
-
-    def _default_trigger_cb(self, source: TUIMenu) -> Optional["TUIMenu"]:
-        return get_or_default(self._items, self._sel_index, self._parent)
-
-    @cached_property
-    def _digits(self) -> List[Keyboard]:
-        return Keyboard.digits()