textual-vim-textarea 1.1.0__tar.gz

textual_vim_textarea-1.1.0/.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+.venv/
+*.egg-info/

textual_vim_textarea-1.1.0/.python-version

@@ -0,0 +1 @@
+3.10

textual_vim_textarea-1.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dastageer Siddiqui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

textual_vim_textarea-1.1.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: textual-vim-textarea
+Version: 1.1.0
+Summary: A Vim-style textarea widget for Textual
+Project-URL: Homepage, https://github.com/Dking08/textual-vim-textarea
+Project-URL: Repository, https://github.com/Dking08/textual-vim-textarea
+Project-URL: Issues, https://github.com/Dking08/textual-vim-textarea/issues
+Author-email: Dking08 <dastageer_foss@yahoo.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: editor,textarea,textual,tui,vim
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Terminals
+Requires-Python: >=3.10
+Requires-Dist: textual>=6.4.0
+Provides-Extra: textarea-plus
+Requires-Dist: textual-textarea<0.18,>=0.17; extra == 'textarea-plus'
+Description-Content-Type: text/markdown
+
+# textual-vim-textarea
+
+vim-style editing built on top of Textual's built-in `TextArea`. This is just a subclass that intercepts keys before they hit the default "every keypress inserts a character" behavior.
+
+Built this to eventually wire vim keybindings into a TUI app, but split it out as its own module first so it could be tested properly on its own before touching real app code.
+
+## Two flavors
+
+- **`VimTextArea`** - for plain Textual `TextArea`. Zero extra dependencies beyond `textual` itself.
+- **`VimTextAreaPlus`** - for apps built on [`textual-textarea`](https://github.com/tconbeer/textual-textarea)'s `TextEditor`/`TextAreaPlus` instead of plain `TextArea`. 
+
+Both share the same underlying vim logic (`_modal.VimModalMixin`) - same motions, operators, counts, everything. They only differ in how they hook into their respective base widget's key handling, because the two bases genuinely work differently under the hood (see `textarea_plus.py`'s module docstring if you're curious exactly why).
+
+## What you get
+
+- Modes: `NORMAL`, `INSERT`, `VISUAL`, `VISUAL LINE`, `COMMAND`
+- Motions: `h j k l`, `0`, `^`, `$`, `w`, `b`, `e`, `gg`, `G` (arrow keys work too)
+- Insert entry: `i a I A o O`
+- Editing: `x X`, `dd dw db de`, `d$ / D`, `cc cw cb ce`, `c$ / C`,
+  `yy yw yb ye`, `y$`, `p P`, `u`, `ctrl+r`
+- Visual mode: `v` (charwise) / `V` (linewise), then `d x c y` act on the selection
+- Counts: `3j`, `3dd`, `2dw`, even `2d3w` (counts multiply, like real vim)
+- Command line: `:w`, `:q`, `:wq`, `:n` to jump to line `n` - anything else
+  gets posted as a message so your app can handle its own commands
+- Line numbers - this one's actually just `TextArea`'s built-in
+  `show_line_numbers=True`, not something this module adds
+
+**Not** currently implemented: registers beyond the default one, macros, marks, `:s///` regex substitution, folds, splits.
+
+> If you want to more vim features, you can contribute!
+
+## Project layout
+
+- `src/textual_vim_textarea/_modal.py` - shared vim logic, not meant to be used directly
+- `src/textual_vim_textarea/vim_textarea.py` - `VimTextArea`, built on plain `TextArea`. Primary file.
+- `src/textual_vim_textarea/textarea_plus.py` - `VimTextAreaPlus`, built on `textual-textarea`'s `TextAreaPlus`.
+
+- `examples/dummy_app.py` - standalone playground for `VimTextArea`
+- `examples/dummy_app_plus.py` + `examples/vim_text_editor.py` - standalone playground for `VimTextAreaPlus`, and the `TextEditor` subclass pattern to copy into a real app
+
+- `tests/test_vim_textarea.py`, `tests/test_textarea_plus.py` - headless tests using Textual's `Pilot`
+
+## Try it
+
+```bash
+uv sync
+python examples/dummy_app.py
+```
+
+> Bottom bar shows the mode/pending-command line, same idea as vim's own.
+> `:q` quits, `:w` just fires a notification since there's no real file
+> backing the dummy app.
+
+For the `TextAreaPlus` flavor (needs the extra) - OPTIONAL:
+
+```bash
+uv sync --extra textarea-plus
+python examples/dummy_app_plus.py
+```
+
+## Using it in your own TUI
+
+It's a drop-in replacement for `TextArea`. Use it exactly like you'd use `TextArea`, and listen for a couple of extra messages to keep a status bar in sync and to hook up `:w` / `:q`:
+
+```python
+from textual_vim_textarea import VimTextArea
+
+class MyApp(App):
+    def compose(self):
+        yield VimTextArea("some text", language="python", show_line_numbers=True, id="editor")
+
+    def on_vim_text_area_status_changed(self, message: VimTextArea.StatusChanged):
+        # fires on every NORMAL/VISUAL/COMMAND keystroke it handles -
+        # pending counts, pending operators, the command buffer, etc.
+        self.query_one("#status").update(message.status)
+
+    def on_vim_text_area_mode_changed(self, message: VimTextArea.ModeChanged):
+        # fires only when the mode itself actually changes
+        ...
+
+    def on_vim_text_area_save_requested(self, message: VimTextArea.SaveRequested):
+        # ':w' or ':wq' - do your actual file save here
+        ...
+
+    def on_vim_text_area_quit_requested(self, message: VimTextArea.QuitRequested):
+        # ':q' or ':wq'
+        self.exit()
+
+    def on_vim_text_area_command_entered(self, message: VimTextArea.CommandEntered):
+        # any ':' command that isn't w/q/wq/n - bring your own command palette
+        ...
+```
+
+**Everything else - `.text`, `.document`, `.selection`, themes, syntax highlighting, `language=`, etc. - is untouched `TextArea` API, works exactly as it does normally. This class only takes over key handling while you're not in INSERT mode.**
+
+### One gotcha if you're subclassing further
+
+`VimTextArea` uses `_on_key` as its extension point. If you need to add your own key handling on top, don't fight the binding system - override `_on_key`, check mode, and either fall through to `super()._on_key(event)` or handle it yourself and call `event.stop()` + `event.prevent_default()`. Same pattern this module already uses internally.
+
+`VimTextAreaPlus` is different on purpose - it hooks `on_key`, not `_on_key`, and in INSERT mode does **nothing at all** (not even calling `super()`) so the event cascades naturally through `TextAreaPlus`'s own `on_key` and then base `TextArea`'s `_on_key`. If you're subclassing `VimTextAreaPlus` further, match that: don't call `super().on_key()` manually, just decide whether to `prevent_default()`+`stop()` or leave the event alone entirely. See `textarea_plus.py`'s module docstring for the actual Textual dispatch mechanics this depends on - it's worth reading before you touch it, the ordering isn't obvious from the outside.
+
+### Using VimTextAreaPlus
+
+Same idea, but you also get to decide what `:w`/`:q` actually do, since `TextAreaPlus`'s real save flow lives on an ancestor `TextEditor` widget, not on the text area itself:
+
+```python
+from textual_vim_textarea.textarea_plus import VimTextAreaPlus
+
+class MyCodeEditor(TextEditor):  # from textual_textarea
+    def compose(self):
+        self.text_input = VimTextAreaPlus(language="sql", text=self._initial_text)
+        ...  # rest of TextEditor's own compose() body, unchanged
+
+    def on_vim_text_area_plus_quit_requested(self, message):
+        # ':q' - deliberately just a message. Closing a buffer/tab vs.
+        # quitting the whole app is your call, not this widget's.
+        ...
+```
+
+`:w` already works out of the box - it walks up to whatever ancestor has `action_save` (the real `TextEditor` action ctrl+s also triggers) and calls it directly, since Textual's own `run_action()` won't resolve an un-prefixed action name against an ancestor by default (verified this the hard way, see the integration guide).
+
+## Known rough edges
+
+- Word motions (`w b e`) use a simplified vim "word" definition (keyword run vs punctuation run vs whitespace). Covers the common case, isn't byte-for-byte identical to vim in every corner case.
+- `cw` intentionally behaves like `ce` (doesn't eat trailing whitespace).
+- Only one register (the unnamed one). `dd` then `yy` then `p` pastes whatever you yanked/deleted most recently, same register for everything.
+
+## Running the tests
+
+```bash
+uv run pytest tests -v --asyncio-mode=auto
+```
+
+39 tests, all green as of this writing - 25 for `VimTextArea`, 14 for `VimTextAreaPlus`

textual_vim_textarea-1.1.0/README.md

@@ -0,0 +1,134 @@
+# textual-vim-textarea
+
+vim-style editing built on top of Textual's built-in `TextArea`. This is just a subclass that intercepts keys before they hit the default "every keypress inserts a character" behavior.
+
+Built this to eventually wire vim keybindings into a TUI app, but split it out as its own module first so it could be tested properly on its own before touching real app code.
+
+## Two flavors
+
+- **`VimTextArea`** - for plain Textual `TextArea`. Zero extra dependencies beyond `textual` itself.
+- **`VimTextAreaPlus`** - for apps built on [`textual-textarea`](https://github.com/tconbeer/textual-textarea)'s `TextEditor`/`TextAreaPlus` instead of plain `TextArea`. 
+
+Both share the same underlying vim logic (`_modal.VimModalMixin`) - same motions, operators, counts, everything. They only differ in how they hook into their respective base widget's key handling, because the two bases genuinely work differently under the hood (see `textarea_plus.py`'s module docstring if you're curious exactly why).
+
+## What you get
+
+- Modes: `NORMAL`, `INSERT`, `VISUAL`, `VISUAL LINE`, `COMMAND`
+- Motions: `h j k l`, `0`, `^`, `$`, `w`, `b`, `e`, `gg`, `G` (arrow keys work too)
+- Insert entry: `i a I A o O`
+- Editing: `x X`, `dd dw db de`, `d$ / D`, `cc cw cb ce`, `c$ / C`,
+  `yy yw yb ye`, `y$`, `p P`, `u`, `ctrl+r`
+- Visual mode: `v` (charwise) / `V` (linewise), then `d x c y` act on the selection
+- Counts: `3j`, `3dd`, `2dw`, even `2d3w` (counts multiply, like real vim)
+- Command line: `:w`, `:q`, `:wq`, `:n` to jump to line `n` - anything else
+  gets posted as a message so your app can handle its own commands
+- Line numbers - this one's actually just `TextArea`'s built-in
+  `show_line_numbers=True`, not something this module adds
+
+**Not** currently implemented: registers beyond the default one, macros, marks, `:s///` regex substitution, folds, splits.
+
+> If you want to more vim features, you can contribute!
+
+## Project layout
+
+- `src/textual_vim_textarea/_modal.py` - shared vim logic, not meant to be used directly
+- `src/textual_vim_textarea/vim_textarea.py` - `VimTextArea`, built on plain `TextArea`. Primary file.
+- `src/textual_vim_textarea/textarea_plus.py` - `VimTextAreaPlus`, built on `textual-textarea`'s `TextAreaPlus`.
+
+- `examples/dummy_app.py` - standalone playground for `VimTextArea`
+- `examples/dummy_app_plus.py` + `examples/vim_text_editor.py` - standalone playground for `VimTextAreaPlus`, and the `TextEditor` subclass pattern to copy into a real app
+
+- `tests/test_vim_textarea.py`, `tests/test_textarea_plus.py` - headless tests using Textual's `Pilot`
+
+## Try it
+
+```bash
+uv sync
+python examples/dummy_app.py
+```
+
+> Bottom bar shows the mode/pending-command line, same idea as vim's own.
+> `:q` quits, `:w` just fires a notification since there's no real file
+> backing the dummy app.
+
+For the `TextAreaPlus` flavor (needs the extra) - OPTIONAL:
+
+```bash
+uv sync --extra textarea-plus
+python examples/dummy_app_plus.py
+```
+
+## Using it in your own TUI
+
+It's a drop-in replacement for `TextArea`. Use it exactly like you'd use `TextArea`, and listen for a couple of extra messages to keep a status bar in sync and to hook up `:w` / `:q`:
+
+```python
+from textual_vim_textarea import VimTextArea
+
+class MyApp(App):
+    def compose(self):
+        yield VimTextArea("some text", language="python", show_line_numbers=True, id="editor")
+
+    def on_vim_text_area_status_changed(self, message: VimTextArea.StatusChanged):
+        # fires on every NORMAL/VISUAL/COMMAND keystroke it handles -
+        # pending counts, pending operators, the command buffer, etc.
+        self.query_one("#status").update(message.status)
+
+    def on_vim_text_area_mode_changed(self, message: VimTextArea.ModeChanged):
+        # fires only when the mode itself actually changes
+        ...
+
+    def on_vim_text_area_save_requested(self, message: VimTextArea.SaveRequested):
+        # ':w' or ':wq' - do your actual file save here
+        ...
+
+    def on_vim_text_area_quit_requested(self, message: VimTextArea.QuitRequested):
+        # ':q' or ':wq'
+        self.exit()
+
+    def on_vim_text_area_command_entered(self, message: VimTextArea.CommandEntered):
+        # any ':' command that isn't w/q/wq/n - bring your own command palette
+        ...
+```
+
+**Everything else - `.text`, `.document`, `.selection`, themes, syntax highlighting, `language=`, etc. - is untouched `TextArea` API, works exactly as it does normally. This class only takes over key handling while you're not in INSERT mode.**
+
+### One gotcha if you're subclassing further
+
+`VimTextArea` uses `_on_key` as its extension point. If you need to add your own key handling on top, don't fight the binding system - override `_on_key`, check mode, and either fall through to `super()._on_key(event)` or handle it yourself and call `event.stop()` + `event.prevent_default()`. Same pattern this module already uses internally.
+
+`VimTextAreaPlus` is different on purpose - it hooks `on_key`, not `_on_key`, and in INSERT mode does **nothing at all** (not even calling `super()`) so the event cascades naturally through `TextAreaPlus`'s own `on_key` and then base `TextArea`'s `_on_key`. If you're subclassing `VimTextAreaPlus` further, match that: don't call `super().on_key()` manually, just decide whether to `prevent_default()`+`stop()` or leave the event alone entirely. See `textarea_plus.py`'s module docstring for the actual Textual dispatch mechanics this depends on - it's worth reading before you touch it, the ordering isn't obvious from the outside.
+
+### Using VimTextAreaPlus
+
+Same idea, but you also get to decide what `:w`/`:q` actually do, since `TextAreaPlus`'s real save flow lives on an ancestor `TextEditor` widget, not on the text area itself:
+
+```python
+from textual_vim_textarea.textarea_plus import VimTextAreaPlus
+
+class MyCodeEditor(TextEditor):  # from textual_textarea
+    def compose(self):
+        self.text_input = VimTextAreaPlus(language="sql", text=self._initial_text)
+        ...  # rest of TextEditor's own compose() body, unchanged
+
+    def on_vim_text_area_plus_quit_requested(self, message):
+        # ':q' - deliberately just a message. Closing a buffer/tab vs.
+        # quitting the whole app is your call, not this widget's.
+        ...
+```
+
+`:w` already works out of the box - it walks up to whatever ancestor has `action_save` (the real `TextEditor` action ctrl+s also triggers) and calls it directly, since Textual's own `run_action()` won't resolve an un-prefixed action name against an ancestor by default (verified this the hard way, see the integration guide).
+
+## Known rough edges
+
+- Word motions (`w b e`) use a simplified vim "word" definition (keyword run vs punctuation run vs whitespace). Covers the common case, isn't byte-for-byte identical to vim in every corner case.
+- `cw` intentionally behaves like `ce` (doesn't eat trailing whitespace).
+- Only one register (the unnamed one). `dd` then `yy` then `p` pastes whatever you yanked/deleted most recently, same register for everything.
+
+## Running the tests
+
+```bash
+uv run pytest tests -v --asyncio-mode=auto
+```
+
+39 tests, all green as of this writing - 25 for `VimTextArea`, 14 for `VimTextAreaPlus`

textual_vim_textarea-1.1.0/examples/dummy_app.py

@@ -0,0 +1,100 @@
+"""
+dummy_app.py
+
+A minimal standalone Textual app for interactively trying out VimTextArea
+before it gets wired into a real TUI. Run it with:
+
+    python3 dummy_app.py
+
+Bottom status bar mirrors vim's own mode/command line: shows NORMAL,
+-- INSERT --, -- VISUAL --, -- VISUAL LINE --, pending counts/operators,
+or ":<command>" while typing a command.
+
+:w   -> just shows a notification (no real file I/O in this dummy)
+:q   -> quits the app
+:wq  -> both
+"""
+
+from textual.app import App, ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Footer, Header, Static
+
+from textual_vim_textarea import VimTextArea
+
+SAMPLE_TEXT = """\
+def greet(name):
+    print("hello", name)
+
+
+def main():
+    greet("world")
+    numbers = [1, 2, 3, 4, 5]
+    total = sum(numbers)
+    print(total)
+
+
+if __name__ == "__main__":
+    main()
+"""
+
+
+class StatusBar(Static):
+    pass
+
+
+class DummyVimApp(App):
+    CSS = """
+    Screen {
+        background: #0d1117;
+    }
+    VimTextArea {
+        border: solid #30363d;
+        height: 1fr;
+    }
+    StatusBar {
+        dock: bottom;
+        height: 1;
+        background: #161b22;
+        color: #58a6ff;
+        padding: 0 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical():
+            yield VimTextArea(
+                SAMPLE_TEXT,
+                language="python",
+                id="editor",
+                show_line_numbers=True,
+            )
+            yield StatusBar("NORMAL", id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.query_one("#editor", VimTextArea).focus()
+        self._refresh_status()
+
+    def _refresh_status(self) -> None:
+        editor = self.query_one("#editor", VimTextArea)
+        self.query_one("#status", StatusBar).update(editor.status_text)
+
+    def on_vim_text_area_mode_changed(self, message: VimTextArea.ModeChanged) -> None:
+        self._refresh_status()
+
+    def on_vim_text_area_status_changed(self, message: VimTextArea.StatusChanged) -> None:
+        self.query_one("#status", StatusBar).update(message.status)
+
+    def on_vim_text_area_save_requested(self, message: VimTextArea.SaveRequested) -> None:
+        self.notify("Saved (dummy -- no real file I/O here)")
+
+    def on_vim_text_area_quit_requested(self, message: VimTextArea.QuitRequested) -> None:
+        self.exit()
+
+    def on_vim_text_area_command_entered(self, message: VimTextArea.CommandEntered) -> None:
+        self.notify(f"Unhandled command: :{message.command}")
+
+
+if __name__ == "__main__":
+    DummyVimApp().run()

textual_vim_textarea-1.1.0/examples/dummy_app_plus.py

@@ -0,0 +1,82 @@
+"""
+dummy_app_plus.py
+
+Standalone playground for VimTextAreaPlus -- the variant for apps built
+on textual-textarea's TextEditor/TextAreaPlus rather
+than plain Textual TextArea. Requires the 'textarea-plus' extra:
+
+    pip install textual-vim-textarea[textarea-plus]
+    python3 dummy_app_plus.py
+
+Uses vim_text_editor.VimTextEditor (in this same examples/ folder) --
+a TextEditor subclass that swaps in VimTextAreaPlus. That's the exact
+pattern to copy into a real app's own CodeEditor-equivalent class;
+"""
+
+from textual.app import App, ComposeResult
+from textual.widgets import Footer, Header, Static
+
+from textual_vim_textarea.textarea_plus import VimTextAreaPlus
+from vim_text_editor import VimTextEditor
+
+SAMPLE_TEXT = """\
+select
+    customer_id,
+    sum(amount) as total_amount
+from orders
+where status = 'completed'
+group by customer_id
+order by total_amount desc
+"""
+
+
+class StatusBar(Static):
+    pass
+
+
+class DummyVimPlusApp(App):
+    CSS = """
+    Screen {
+        background: #0d1117;
+    }
+    StatusBar {
+        dock: bottom;
+        height: 1;
+        background: #161b22;
+        color: #58a6ff;
+        padding: 0 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        self.editor = VimTextEditor(language="sql", text=SAMPLE_TEXT)
+        yield self.editor
+        yield StatusBar("NORMAL", id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.editor.text_input.focus()
+        self._refresh_status()
+
+    def _refresh_status(self) -> None:
+        self.query_one("#status", StatusBar).update(self.editor.text_input.status_text)
+
+    def on_vim_text_area_plus_mode_changed(
+        self, message: VimTextAreaPlus.ModeChanged
+    ) -> None:
+        self._refresh_status()
+
+    def on_vim_text_area_plus_status_changed(
+        self, message: VimTextAreaPlus.StatusChanged
+    ) -> None:
+        self.query_one("#status", StatusBar).update(message.status)
+
+    def on_vim_text_area_plus_quit_requested(
+        self, message: VimTextAreaPlus.QuitRequested
+    ) -> None:
+        self.exit()
+
+
+if __name__ == "__main__":
+    DummyVimPlusApp().run()

textual_vim_textarea-1.1.0/examples/vim_text_editor.py

@@ -0,0 +1,44 @@
+"""
+vim_text_editor.py
+
+A drop-in TextEditor subclass that substitutes VimTextAreaPlus for
+TextAreaPlus. 
+Kept as its own small file/class so it can be tested against a *real* TextEditor container in
+isolation first, the same "build it standalone, test it, then integrate"
+approach used for the original vim_textarea.py.
+"""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.widgets import Label
+from textual_textarea import TextEditor
+from textual_textarea.autocomplete import CompletionList
+from textual_textarea.containers import FooterContainer, TextContainer
+
+from textual_vim_textarea.textarea_plus import VimTextAreaPlus
+
+
+class VimTextEditor(TextEditor):
+    """Identical to textual_textarea.TextEditor, except `compose()`
+    mounts VimTextAreaPlus instead of the stock TextAreaPlus as
+    `self.text_input`. Every other TextEditor feature (save/load/find/
+    goto-line footer inputs, autocomplete dropdown wiring, theming) is
+    inherited completely unchanged, since none of it depends on the
+    concrete class of `text_input` -- it only calls TextArea-level
+    methods on it.
+    """
+
+    def compose(self) -> ComposeResult:
+        self.text_container = TextContainer()
+        self.text_input = VimTextAreaPlus(
+            language=self._language, text=self._initial_text, read_only=self.read_only
+        )
+        self.completion_list = CompletionList()
+        self.footer = FooterContainer(classes="hide")
+        self.footer_label = Label("", id="textarea__save_open_input_label")
+        with self.text_container:
+            yield self.text_input
+            yield self.completion_list
+        with self.footer:
+            yield self.footer_label

textual_vim_textarea-1.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "textual-vim-textarea"
+version = "1.1.0"
+description = "A Vim-style textarea widget for Textual"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Dking08", email = "dastageer_foss@yahoo.com" }
+]
+keywords = ["textual", "vim", "tui", "textarea", "editor"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Terminals",
+]
+dependencies = [
+    "textual>=6.4.0",
+]
+
+[project.optional-dependencies]
+# Only needed for textual_vim_textarea.textarea_plus.VimTextAreaPlus --
+# vim mode for apps built on textual-textarea's TextEditor/TextAreaPlus
+# plain Textual TextArea.
+textarea-plus = [
+    "textual-textarea>=0.17,<0.18",
+]
+
+[project.urls]
+Homepage = "https://github.com/Dking08/textual-vim-textarea"
+Repository = "https://github.com/Dking08/textual-vim-textarea"
+Issues = "https://github.com/Dking08/textual-vim-textarea/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "textual-textarea>=0.17,<0.18",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/textual_vim_textarea"]

textual_vim_textarea-1.1.0/src/textual_vim_textarea/__init__.py

@@ -0,0 +1,11 @@
+from .vim_textarea import VimTextArea, Mode
+
+__all__ = ["VimTextArea", "Mode"]
+
+# VimTextAreaPlus is intentionally NOT imported here. It requires
+# textual-textarea (the 'textarea-plus' extra), and importing it
+# unconditionally would force that dependency on every install of this
+# package, even for people only using plain VimTextArea. Import it
+# explicitly if you need it:
+#
+#     from textual_vim_textarea.textarea_plus import VimTextAreaPlus