feat: add "add to dictionary" feature

ui: use default icon button padding
export result to allow custom language check service implementations

Author: andrew-bekhiet-solid

example/lib/main.dart

@@ -20,55 +20,170 @@ class App extends StatefulWidget {
 }
 
 class _AppState extends State<App> {
-  /// Initialize LanguageToolController
-  final LanguageToolController _controller = LanguageToolController();
+  Set<String> _dictionary = {};
+  final _addWordController = TextEditingController();
 
-  static const List<MainAxisAlignment> alignments = [
-    MainAxisAlignment.center,
-    MainAxisAlignment.start,
-    MainAxisAlignment.end,
-  ];
-  int currentAlignmentIndex = 0;
+  LanguageToolController? _spellCheckController;
+
+  LanguageToolController _nonNullController() {
+    return _spellCheckController ??= LanguageToolController(
+      languageCheckService: InMemoryDictionaryLanguageCheckService(
+        getDictionary: () => _dictionary,
+      ),
+    );
+  }
 
   @override
   Widget build(BuildContext context) {
+    final spellCheckController = _nonNullController();
+
     return Material(
       child: Scaffold(
         body: Column(
-          mainAxisAlignment: alignments[currentAlignmentIndex],
+          mainAxisAlignment: MainAxisAlignment.start,
           children: [
             LanguageToolTextField(
-              controller: _controller,
+              controller: spellCheckController,
               language: 'en-US',
+              mistakePopup: MistakePopup(
+                popupRenderer: PopupOverlayRenderer(),
+                mistakeBuilder: _mistakeBuilder,
+              ),
             ),
             ValueListenableBuilder(
-              valueListenable: _controller,
+              valueListenable: spellCheckController,
               builder: (_, __, ___) => CheckboxListTile(
                 title: const Text("Enable spell checking"),
-                value: _controller.isEnabled,
-                onChanged: (value) => _controller.isEnabled = value ?? false,
+                value: spellCheckController.isEnabled,
+                onChanged: (value) =>
+                    spellCheckController.isEnabled = value ?? false,
               ),
             ),
-            DropdownMenu(
-              hintText: "Select alignment...",
-              onSelected: (value) => setState(() {
-                currentAlignmentIndex = value ?? 0;
-              }),
-              dropdownMenuEntries: const [
-                DropdownMenuEntry(value: 0, label: "Center alignment"),
-                DropdownMenuEntry(value: 1, label: "Top alignment"),
-                DropdownMenuEntry(value: 2, label: "Bottom alignment"),
-              ],
+            const SizedBox(height: 20),
+            Card(
+              margin: const EdgeInsets.all(16),
+              child: Padding(
+                padding: const EdgeInsets.all(16),
+                child: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    const Text(
+                      'Dictionary',
+                      style: TextStyle(
+                        fontSize: 18,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    const SizedBox(height: 16),
+                    Row(
+                      children: [
+                        Expanded(
+                          child: TextField(
+                            controller: _addWordController,
+                            decoration: const InputDecoration(
+                              labelText: 'Add word to dictionary',
+                              border: OutlineInputBorder(),
+                            ),
+                            onSubmitted: (_) => _addWord(),
+                          ),
+                        ),
+                        const SizedBox(width: 8),
+                        ElevatedButton(
+                          onPressed: _addWord,
+                          child: const Text('Add'),
+                        ),
+                      ],
+                    ),
+                    const SizedBox(height: 16),
+                    Row(
+                      mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                      children: [
+                        Text(
+                          'Dictionary Words (${_dictionary.length})',
+                          style: const TextStyle(fontWeight: FontWeight.w500),
+                        ),
+                        if (_dictionary.isNotEmpty)
+                          TextButton(
+                            onPressed: _clearAllWords,
+                            child: const Text('Clear All'),
+                          ),
+                      ],
+                    ),
+                    const SizedBox(height: 8),
+                    if (_dictionary.isEmpty)
+                      const Center(
+                        child: Text(
+                          'No words in dictionary',
+                          style: TextStyle(color: Colors.grey),
+                        ),
+                      )
+                    else
+                      for (final word in _dictionary)
+                        ListTile(
+                          title: Text(word),
+                          trailing: IconButton(
+                            icon: const Icon(Icons.delete),
+                            onPressed: () => _removeWord(word),
+                          ),
+                        ),
+                  ],
+                ),
+              ),
             ),
           ],
         ),
       ),
     );
   }
 
+  void _addWord() {
+    final word = _addWordController.text.trim();
+
+    if (word.isNotEmpty && !_dictionary.contains(word)) {
+      setState(() {
+        _dictionary = {..._dictionary, word};
+        _addWordController.clear();
+        _spellCheckController?.recheckText();
+      });
+    }
+  }
+
+  void _removeWord(String word) {
+    setState(() {
+      _dictionary = _dictionary.difference({word});
+      _spellCheckController?.recheckText();
+    });
+  }
+
+  void _clearAllWords() {
+    setState(() {
+      _dictionary = {};
+      _spellCheckController?.recheckText();
+    });
+  }
+
+  Widget _mistakeBuilder({
+    required LanguageToolController controller,
+    required Mistake mistake,
+    required Offset mistakePosition,
+    required PopupOverlayRenderer popupRenderer,
+  }) {
+    return LanguageToolMistakePopup(
+      popupRenderer: popupRenderer,
+      mistake: mistake,
+      mistakePosition: mistakePosition,
+      controller: controller,
+      addWordToDictionary: (word) async {
+        setState(() => _dictionary = {..._dictionary, word});
+      },
+    );
+  }
+
   @override
   void dispose() {
-    _controller.dispose();
+    _spellCheckController?.dispose();
+    _addWordController.dispose();
     super.dispose();
   }
 }

lib/languagetool_textfield.dart

@@ -16,5 +16,7 @@ export 'src/language_check_services/language_tool_service.dart';
 export 'src/presentation/language_tool_text_field.dart';
 export 'src/utils/mistake_popup.dart';
 export 'src/utils/popup_overlay_renderer.dart';
+export 'src/utils/result.dart';
 export 'src/wrappers/debounce_language_check_service.dart';
+export 'src/wrappers/in_memory_dictionary_language_check_service.dart';
 export 'src/wrappers/throttling_language_check_service.dart';

lib/src/core/controllers/language_tool_controller.dart

@@ -59,7 +59,7 @@ class LanguageToolController extends TextEditingController {
     _isEnabled = value;
 
     if (_isEnabled) {
-      _handleTextChange(text, spellCheckSameText: true);
+      recheckText();
     } else {
       _mistakes = [];
       for (final recognizer in _recognizers) {
@@ -182,6 +182,16 @@ class LanguageToolController extends TextEditingController {
     });
   }
 
+  /// Rechecks the current text for spelling and grammar errors.
+  ///
+  /// This method forces a recheck of the existing text
+  /// This is useful when you want to re-evaluate the text without any actual
+  /// text changes, such as after changing language settings or updating
+  /// spell check configurations.
+  void recheckText() {
+    _handleTextChange(text, spellCheckSameText: true);
+  }
+
   /// Clear mistakes list when text mas modified and get a new list of mistakes
   /// via API
   Future<void> _handleTextChange(

lib/src/utils/mistake_popup.dart

@@ -96,7 +96,7 @@ class LanguageToolMistakePopup extends StatelessWidget {
   final ButtonStyle? mistakeStyle;
 
   /// Optional builder that adds additional actions to the header.
-  final List<Widget> Function(BuildContext context)? actionsBuilder;
+  final Future<void> Function(String)? addWordToDictionary;
 
   /// Creates a [LanguageToolMistakePopup].
   const LanguageToolMistakePopup({
@@ -109,7 +109,7 @@ class LanguageToolMistakePopup extends StatelessWidget {
     this.horizontalMargin = _defaultHorizontalMargin,
     this.verticalMargin = _defaultVerticalMargin,
     this.mistakeStyle,
-    this.actionsBuilder,
+    this.addWordToDictionary,
     super.key,
   });
 
@@ -173,11 +173,25 @@ class LanguageToolMistakePopup extends StatelessWidget {
                             ],
                           ),
                         ),
-                        ...?actionsBuilder?.call(context),
+                        if (addWordToDictionary case final addWordToDictionary?)
+                          IconButton(
+                            icon: const Icon(Icons.menu_book),
+                            constraints: const BoxConstraints(),
+                            splashRadius: _dismissSplashRadius,
+                            onPressed: () async {
+                              final word = controller.text.substring(
+                                mistake.offset,
+                                mistake.endOffset,
+                              );
+
+                              await addWordToDictionary(word);
+
+                              _fixTheMistake(word);
+                            },
+                          ),
                         IconButton(
                           icon: const Icon(Icons.close),
                           constraints: const BoxConstraints(),
-                          padding: EdgeInsets.zero,
                           splashRadius: _dismissSplashRadius,
                           onPressed: () {
                             _dismissDialog();

lib/src/wrappers/in_memory_dictionary_language_check_service.dart

@@ -0,0 +1,51 @@
+import 'package:languagetool_textfield/languagetool_textfield.dart';
+
+/// A language-check service that filters LanguageTool suggestions using an in-memory dictionary.
+///
+/// This class wraps a LanguageToolService and extends ThrottlingLanguageCheckService to
+/// limit the frequency of requests. After performing a check with the underlying service,
+/// it removes any reported mistakes whose corresponding word is present in the provided
+/// in-memory dictionary (so user-defined or domain-specific words can be treated as correct).
+///
+/// The filtering is performed by extracting the substring of the input text using each
+/// mistake's offset and endOffset and checking membership against the dictionary returned
+/// by [getDictionary].
+///
+/// Note: the underlying service is throttled to avoid excessive requests; the throttling
+/// behavior is provided by the superclass.
+class InMemoryDictionaryLanguageCheckService
+    extends ThrottlingLanguageCheckService {
+  /// Callback that supplies the current set of words to be treated as correct.
+  ///
+  /// This function is invoked for each text check so the dictionary can be dynamic
+  /// (for example, reflecting user edits or settings). It must return a Set<String>
+  /// containing the words that should be ignored by the language checker.
+  final Set<String> Function() getDictionary;
+
+  /// Creates an InMemoryDictionaryLanguageCheckService that uses [getDictionary] to filter mistakes.
+  ///
+  /// The [getDictionary] callback is required and will be called for every check operation.
+  /// The service delegates checking to an internal LanguageToolService and then filters
+  /// the results based on the returned dictionary.
+  InMemoryDictionaryLanguageCheckService({required this.getDictionary})
+      : super(
+          LanguageToolService(LanguageToolClient()),
+          const Duration(milliseconds: 250),
+        );
+
+  @override
+  Future<Result<List<Mistake>>?> findMistakes(String text) async {
+    final result = await super.findMistakes(text);
+    final dictionary = getDictionary();
+
+    return result?.map(
+      (mistakes) => mistakes.where(
+        (mistake) {
+          final word = text.substring(mistake.offset, mistake.endOffset);
+
+          return !dictionary.contains(word);
+        },
+      ).toList(),
+    );
+  }
+}