OPT: 查词归一化统一为单一 normalizeWord 路径

- normalizeWord：trim + 弯撇号(’‘ʼ＇`´)归一为直撇号 + 剥首尾标点(右直撇号除外) + 小写
- 去掉全大写缩写特殊处理，统一小写化
- 归一化收敛到点击入口（word_dictionary_sheet），查一次词只归一化一次；
  controller/本地/AI/网页源均透传 request.word，不再各自归一
- 修复弯撇号导致的 I’d 查词不命中 / 粗体标题渲染异常
- AI 查词成功后标题用 result.headword（补测试锁定）
- 补充 normalizeWord / 各源 / controller / widget 测试

Author: echo-loop

lib/providers/dictionary/lookup_controller.dart

@@ -187,7 +187,9 @@ class DictionaryLookupController extends _$DictionaryLookupController {
   bool _isStale(String id, int seq) => _seq[id] != seq;
 
   DictionaryLookupRequest _buildRequest(DictionarySource source) {
-    // 不需联网的源无需鉴权/语言上下文，避免无谓读取
+    // word（= family key）已由调用方归一化一次（见 DictionaryLookupRequest.word
+    // 「已清洗」契约 + word_dictionary_sheet._normalizedWord）。此处及各源均不再归一，
+    // 保证「查一次词只归一化一次」，各端共用同一清洗结果。
     if (!source.requiresNetwork) {
       return DictionaryLookupRequest(word: word);
     }

lib/services/dictionary/ai_dictionary_source.dart

@@ -75,7 +75,10 @@ class AiDictionarySource implements DictionarySource {
       throw const DictionaryAuthRequiredException();
     }
     final language = request.targetLanguage ?? _defaultLanguage;
-    final key = hashText('${request.word}|$language');
+    // request.word 已由 controller 归一化（见 DictionaryLookupRequest.word 契约），
+    // 缓存键、发往后端的词、LLM 输入三者共用同一清洗结果
+    final word = request.word;
+    final key = hashText('$word|$language');
 
     // L1 内存
     final mem = _memCache[key];
@@ -87,7 +90,7 @@ class AiDictionarySource implements DictionarySource {
 
     final future = _fetch(
       key: key,
-      word: request.word,
+      word: word,
       accessToken: token,
       language: language,
     );

lib/services/dictionary/web_dictionary_source.dart

@@ -73,7 +73,8 @@ class WebDictionarySource implements DictionarySource {
     DictionaryLookupRequest request, {
     CancelToken? cancelToken,
   }) async {
-    final slug = Uri.encodeComponent(request.word.trim().toLowerCase());
+    // request.word 已由 controller 归一化（见 DictionaryLookupRequest.word 契约）
+    final slug = Uri.encodeComponent(request.word);
     return WebDictResult(
       sourceId: config.id,
       url: Uri.parse(config.buildUrl(slug)),

lib/services/dictionary_service.dart

@@ -9,6 +9,7 @@ import 'package:lemmatizerx/lemmatizerx.dart';
 import 'package:sqlite3/sqlite3.dart';
 
 import '../models/dict_entry.dart';
+import '../utils/text_normalize.dart';
 
 /// 词典服务单例
 class DictionaryService {
@@ -34,10 +35,6 @@ class DictionaryService {
   Database? _db;
   final Lemmatizer _lemmatizer = Lemmatizer();
 
-  static final RegExp _edgePunctuationPattern = RegExp(
-    r'^[^A-Za-z0-9]+|[^A-Za-z0-9]+$',
-  );
-
   /// 词典数据库是否已就绪
   bool get isAvailable => _db != null;
 
@@ -84,9 +81,7 @@ class DictionaryService {
     return null;
   }
 
-  String _normalizeLookupWord(String word) {
-    return word.trim().replaceAll(_edgePunctuationPattern, '').toLowerCase();
-  }
+  String _normalizeLookupWord(String word) => normalizeWord(word);
 
   /// 直接查询数据库
   DictEntry? _queryWord(String word) {

lib/utils/text_normalize.dart

@@ -23,3 +23,25 @@ String hashText(String text) {
   final normalized = normalizeForCache(text);
   return sha256.convert(utf8.encode(normalized)).toString();
 }
+
+/// 各种弯/花撇号（U+2019 ’ / U+2018 ‘ / U+02BC ʼ / U+FF07 ＇ / 反引号 ` / U+00B4 ´）
+/// 统一为直撇号 `'`：排版文本（如 "I'd"）多用弯撇号，而词典库（ECDICT / 网页源）
+/// 用直撇号存储，不归一会查不中且粗体标题渲染异常。
+final RegExp _smartApostrophes = RegExp('[’‘ʼ＇`´]');
+
+/// 剥离查词输入首尾的非字母数字字符（保留词内连字符/点，如 COVID-19）。
+///
+/// 右侧不剥离直撇号 `'`，保留所有格/缩写形式（dogs' / it's / library's）。
+final RegExp _edgeNonAlnum = RegExp(r"^[^A-Za-z0-9]+|[^A-Za-z0-9']+$");
+
+/// 归一化查词输入，供本地 / AI / 网页等所有词典源共用，保证大小写处理一致。
+///
+/// 处理步骤：去首尾空白 → 弯撇号归一为直撇号 → 剥离首尾标点（右侧直撇号除外）
+/// → 一律转小写。全大写缩写（NASA / FBI 等）不做特殊保留，统一小写化。
+String normalizeWord(String word) {
+  return word
+      .trim()
+      .replaceAll(_smartApostrophes, "'")
+      .replaceAll(_edgeNonAlnum, '')
+      .toLowerCase();
+}

lib/widgets/intensive_listen/word_dictionary_sheet.dart

@@ -18,6 +18,7 @@ import '../../providers/dictionary_provider.dart';
 import '../../providers/saved_word_provider.dart';
 import '../../services/dictionary/web_dictionary_source.dart';
 import '../../services/tts_service.dart';
+import '../../utils/text_normalize.dart';
 import '../../theme/app_theme.dart';
 import '../animated_bookmark_icon.dart';
 import '../common/text_context_menu.dart';
@@ -190,26 +191,24 @@ class _WordDictionarySheetState extends ConsumerState<WordDictionarySheet> {
     }
   }
 
-  /// 清洗后的词形（去首尾标点），用于查询与展示
-  String get _normalizedWord => widget.word.trim().replaceAll(
-    RegExp(r'^[^A-Za-z0-9]+|[^A-Za-z0-9]+$'),
-    '',
-  );
+  /// 归一化后的词形，用于查询（family key）与展示，
+  /// 与各词典源、后端共用同一 [normalizeWord]（trim + 剥首尾标点[右撇号除外] + 小写）
+  String get _normalizedWord => normalizeWord(widget.word);
 
-  /// 标题展示词：优先用当前结果的 headword（本地原形/AI 词头），否则用清洗词形
+  /// 标题展示词：优先用当前结果的 headword（本地原形/AI 词头），否则用归一化词形
   String _displayWord(DictionaryLookupState state) {
     final cur = state.current;
     if (cur is LookupLoaded) return cur.result.headword;
     return _normalizedWord;
   }
 
-  /// 收藏用 lemma：优先用本地词典返回的原形，否则用清洗词形
+  /// 收藏用 lemma：优先用本地词典返回的原形，否则用归一化词形
   String _lemmaWord(DictionaryLookupState state) {
     final local = state.bySource['local'];
     if (local case LookupLoaded(result: final LocalDictResult r)) {
       return r.entry.word.toLowerCase();
     }
-    return _normalizedWord.toLowerCase();
+    return _normalizedWord;
   }
 
   Future<void> _toggleSave(String lemma, bool currentlySaved) async {

test/providers/dictionary/lookup_controller_test.dart

@@ -20,6 +20,9 @@ class ControllableSource implements DictionarySource {
 
   final List<Completer<DictionaryLookupResult?>> calls = [];
 
+  /// 记录每次 lookup 收到的请求，供断言归一化结果
+  final List<DictionaryLookupRequest> requests = [];
+
   @override
   IconData get icon => Icons.abc;
   @override
@@ -30,6 +33,7 @@ class ControllableSource implements DictionarySource {
     DictionaryLookupRequest request, {
     CancelToken? cancelToken,
   }) {
+    requests.add(request);
     final c = Completer<DictionaryLookupResult?>();
     calls.add(c);
     return c.future;
@@ -225,6 +229,15 @@ void main() {
     // 跑到这里无未捕获异常即通过
   });
 
+  test('word（已由调用方归一化）原样透传给各源，controller 不再归一', () async {
+    final a = ControllableSource('a');
+    final c = makeContainer({'a': a});
+    // family key 已是归一化结果（由 widget 层 normalizeWord 产出）
+    start(c, "dogs'");
+    await pump();
+    expect(a.requests.single.word, "dogs'");
+  });
+
   test('不需联网的源不读取上下文也能查', () async {
     final a = ControllableSource('a', requiresNetwork: false);
     // 不 override context：若 controller 误读会抛错

test/services/dictionary/ai_dictionary_source_test.dart

@@ -80,6 +80,35 @@ void main() {
     verify(() => dao.upsert(any(), 'ai_dictionary', any())).called(1);
   });
 
+  test('request.word（已归一化）原样发往后端', () async {
+    // 归一化由 controller 统一完成；源拿到的已是清洗结果，原样透传
+    when(
+      () => dao.getByHash(any(), 'ai_dictionary'),
+    ).thenAnswer((_) async => null);
+    when(
+      () => api.lookupDictionary(
+        any(),
+        accessToken: any(named: 'accessToken'),
+        targetLanguage: any(named: 'targetLanguage'),
+        cancelToken: any(named: 'cancelToken'),
+      ),
+    ).thenAnswer((_) async => _entry('run'));
+    when(
+      () => dao.upsert(any(), 'ai_dictionary', any()),
+    ).thenAnswer((_) async {});
+
+    await source.lookup(tokenReq);
+
+    verify(
+      () => api.lookupDictionary(
+        'run',
+        accessToken: any(named: 'accessToken'),
+        targetLanguage: any(named: 'targetLanguage'),
+        cancelToken: any(named: 'cancelToken'),
+      ),
+    ).called(1);
+  });
+
   test('L1 内存命中 → 第二次不再调 API', () async {
     when(
       () => dao.getByHash(any(), 'ai_dictionary'),

test/services/dictionary/local_dictionary_source_test.dart

@@ -27,8 +27,9 @@ void main() {
 
   test('词典就绪且命中 → LocalDictResult', () async {
     when(() => service.isAvailable).thenReturn(true);
-    when(() => service.lookup('run'))
-        .thenReturn(const DictEntry(word: 'run', phonetic: 'rʌn'));
+    when(
+      () => service.lookup('run'),
+    ).thenReturn(const DictEntry(word: 'run', phonetic: 'rʌn'));
 
     final result = await source.lookup(req);
 

test/services/dictionary/web_dictionary_source_test.dart

@@ -50,13 +50,13 @@ void main() {
         expect(web.url.toString(), config.buildUrl('nice'));
       });
 
-      test('查询词被规整为小写并 URL 编码', () async {
+      test('对已归一化的查询词做 URL 编码（词内空格编码为 %20）', () async {
+        // 归一化由 controller 统一完成，源只对 request.word 做 URL 编码
         final result =
             await source.lookup(
-                  const DictionaryLookupRequest(word: '  A Posteriori '),
+                  const DictionaryLookupRequest(word: 'a posteriori'),
                 )
                 as WebDictResult;
-        // trim + toLowerCase + 空格编码为 %20
         expect(result.url.toString(), contains('a%20posteriori'));
         expect(result.url.toString(), isNot(contains(' ')));
       });