feat: import Chinese-localized Buzz source snapshot

Signed-off-by: cls_宁波本机 <908705107@qq.com>

mobile/test/shared/emoji/emoji_burst_test.dart

@@ -0,0 +1,227 @@
+import 'package:buzz/shared/emoji/emoji_burst.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+const _fire = '\u{1F525}';
+
+/// Run the controller forward until it says it is done, capped so a physics
+/// regression fails the test instead of hanging it.
+int _runToCompletion(EmojiBurstController controller, {int maxSteps = 600}) {
+  var steps = 0;
+  while (controller.hasParticles && steps < maxSteps) {
+    controller.step();
+    steps += 1;
+  }
+  return steps;
+}
+
+void main() {
+  group('EmojiBurstController', () {
+    test('a burst spawns particles and eventually clears itself', () {
+      final controller = EmojiBurstController();
+      addTearDown(controller.dispose);
+
+      expect(controller.hasParticles, isFalse);
+      controller.burst(_fire, const Offset(100, 200));
+      expect(controller.hasParticles, isTrue);
+
+      final steps = _runToCompletion(controller);
+      expect(controller.hasParticles, isFalse);
+      // Desktop's particles live 108 frames and fade over the last 24%.
+      expect(steps, lessThanOrEqualTo(108));
+      expect(steps, greaterThan(60));
+    });
+
+    test('ignores a blank emoji', () {
+      final controller = EmojiBurstController();
+      addTearDown(controller.dispose);
+
+      controller.burst('   ', Offset.zero);
+      expect(controller.hasParticles, isFalse);
+    });
+
+    test('notifies on spawn and on every step', () {
+      final controller = EmojiBurstController();
+      addTearDown(controller.dispose);
+
+      var notifications = 0;
+      controller.addListener(() => notifications += 1);
+
+      controller.burst(_fire, Offset.zero);
+      expect(notifications, 1);
+
+      controller.step();
+      expect(notifications, 2);
+    });
+
+    test('calls onSpawn so the overlay can start its ticker', () {
+      final controller = EmojiBurstController();
+      addTearDown(controller.dispose);
+
+      var spawns = 0;
+      controller.onSpawn = () => spawns += 1;
+
+      controller.burst(_fire, Offset.zero);
+      controller.burst(_fire, Offset.zero);
+      expect(spawns, 2);
+    });
+
+    test('caps the active particle count', () {
+      final controller = EmojiBurstController();
+      addTearDown(controller.dispose);
+
+      // Far more bursts than the cap allows, with no steps in between so
+      // nothing expires.
+      for (var i = 0; i < 200; i += 1) {
+        controller.burst(_fire, Offset.zero);
+      }
+
+      // Still bounded, and still animating rather than wedged.
+      expect(controller.hasParticles, isTrue);
+      _runToCompletion(controller);
+      expect(controller.hasParticles, isFalse);
+    });
+
+    test('clear drops everything immediately', () {
+      final controller = EmojiBurstController();
+      addTearDown(controller.dispose);
+
+      controller.burst(_fire, Offset.zero);
+      controller.clear();
+      expect(controller.hasParticles, isFalse);
+    });
+  });
+
+  group('PendingReactionBurstNotifier', () {
+    ProviderContainer container() {
+      final result = ProviderContainer();
+      addTearDown(result.dispose);
+      return result;
+    }
+
+    test('arms only positive emoji', () {
+      final ref = container();
+      final notifier = ref.read(pendingReactionBurstProvider.notifier);
+
+      notifier.arm('msg-1', '\u{1F44E}'); // 👎
+      expect(ref.read(pendingReactionBurstProvider), isNull);
+
+      notifier.arm('msg-1', _fire);
+      expect(
+        ref.read(pendingReactionBurstProvider),
+        const PendingReactionBurst(messageId: 'msg-1', emoji: _fire),
+      );
+    });
+
+    test('claim succeeds once, so one pill bursts when a message is on screen '
+        'twice', () {
+      final ref = container();
+      final notifier = ref.read(pendingReactionBurstProvider.notifier);
+      const target = PendingReactionBurst(messageId: 'msg-1', emoji: _fire);
+
+      notifier.arm('msg-1', _fire);
+      expect(notifier.claim(target), isTrue);
+      expect(notifier.claim(target), isFalse);
+      expect(ref.read(pendingReactionBurstProvider), isNull);
+    });
+
+    test('a claim for a different message or emoji does not consume it', () {
+      final ref = container();
+      final notifier = ref.read(pendingReactionBurstProvider.notifier);
+
+      notifier.arm('msg-1', _fire);
+      expect(
+        notifier.claim(
+          const PendingReactionBurst(messageId: 'msg-2', emoji: _fire),
+        ),
+        isFalse,
+      );
+      expect(
+        notifier.claim(
+          const PendingReactionBurst(messageId: 'msg-1', emoji: '\u{1F389}'),
+        ),
+        isFalse,
+      );
+      expect(ref.read(pendingReactionBurstProvider), isNotNull);
+    });
+
+    test('a newer arm replaces the pending one', () {
+      final ref = container();
+      final notifier = ref.read(pendingReactionBurstProvider.notifier);
+
+      notifier.arm('msg-1', _fire);
+      notifier.arm('msg-2', '\u{1F389}');
+      expect(
+        ref.read(pendingReactionBurstProvider),
+        const PendingReactionBurst(messageId: 'msg-2', emoji: '\u{1F389}'),
+      );
+    });
+  });
+
+  group('EmojiBurstOverlay', () {
+    testWidgets('paints its child and drains the burst', (tester) async {
+      late EmojiBurstController controller;
+
+      await tester.pumpWidget(
+        ProviderScope(
+          child: MaterialApp(
+            home: Consumer(
+              builder: (context, ref, _) {
+                controller = ref.watch(emojiBurstControllerProvider);
+                return const EmojiBurstOverlay(child: Text('body'));
+              },
+            ),
+          ),
+        ),
+      );
+
+      expect(find.text('body'), findsOneWidget);
+
+      controller.burst(_fire, const Offset(120, 240));
+      expect(controller.hasParticles, isTrue);
+
+      // Physics advances a bounded number of fixed steps per frame (no
+      // catch-up spiral), so drain it a frame at a time — 130 frames is past
+      // the 108-frame particle life.
+      await tester.pump();
+      for (var frame = 0; frame < 130; frame += 1) {
+        await tester.pump(const Duration(milliseconds: 16));
+      }
+      expect(controller.hasParticles, isFalse);
+    });
+
+    testWidgets('the overlay never takes a tap from the app below', (
+      tester,
+    ) async {
+      var taps = 0;
+      late EmojiBurstController controller;
+
+      await tester.pumpWidget(
+        ProviderScope(
+          child: MaterialApp(
+            home: Consumer(
+              builder: (context, ref, _) {
+                controller = ref.watch(emojiBurstControllerProvider);
+                return EmojiBurstOverlay(
+                  child: Center(
+                    child: GestureDetector(
+                      onTap: () => taps += 1,
+                      child: const Text('tap me'),
+                    ),
+                  ),
+                );
+              },
+            ),
+          ),
+        ),
+      );
+
+      controller.burst(_fire, const Offset(200, 400));
+      await tester.pump();
+
+      await tester.tap(find.text('tap me'));
+      expect(taps, 1);
+    });
+  });
+}

mobile/test/shared/emoji/emoji_data_test.dart

@@ -0,0 +1,81 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:buzz/shared/emoji/emoji_data.dart';
+import 'package:buzz/shared/emoji/emoji_data_provider.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+/// Reads the committed asset straight off disk rather than through
+/// `rootBundle`, so this test guards the generated file itself — if
+/// `just mobile-emoji-data` ever emits a different shape, this fails.
+EmojiDataset _loadFromDisk() {
+  final source = File(emojiDataAssetPath).readAsStringSync();
+  return EmojiDataset.fromJson(jsonDecode(source) as Map<String, dynamic>);
+}
+
+void main() {
+  late EmojiDataset dataset;
+
+  setUpAll(() {
+    dataset = _loadFromDisk();
+  });
+
+  test('parses every emoji-mart category in order', () {
+    expect(dataset.categories.map((category) => category.id), [
+      'people',
+      'nature',
+      'foods',
+      'activity',
+      'places',
+      'objects',
+      'symbols',
+      'flags',
+    ]);
+  });
+
+  test('carries the full standard set, not a hand-picked subset', () {
+    // The hardcoded list this replaced had ~140 glyphs; emoji-mart ships ~1.9k.
+    expect(dataset.all.length, greaterThan(1800));
+    expect(
+      dataset.all.length,
+      dataset.categories.fold<int>(
+        0,
+        (total, category) => total + category.emoji.length,
+      ),
+    );
+  });
+
+  test('every entry has an id, a glyph, and a category', () {
+    for (final entry in dataset.all) {
+      expect(entry.id, isNotEmpty);
+      expect(entry.native, isNotEmpty);
+      expect(entry.categoryId, isNotEmpty);
+    }
+  });
+
+  test('resolves glyphs back to desktop-identical shortcodes', () {
+    expect(dataset.nativeToShortcode['💯'], ':100:');
+    expect(dataset.nativeToShortcode['🔥'], ':fire:');
+    expect(dataset.nativeToShortcode['☝️'], ':point_up:');
+    expect(dataset.nativeToShortcode['👍🏽'], ':+1:');
+    expect(
+      dataset.all
+          .where((entry) => entry.id == '+1')
+          .map((entry) => entry.native),
+      containsAll(['👍', '👍🏻', '👍🏼', '👍🏽', '👍🏾', '👍🏿']),
+    );
+  });
+
+  test('displayName mirrors desktop emojiDisplayName', () {
+    expect(dataset.displayName('🎉'), ':tada:');
+    // Custom emoji already arrive as a shortcode and pass through untouched.
+    expect(dataset.displayName(':party_parrot:'), ':party_parrot:');
+    // Unknown glyphs fall back to themselves rather than a bogus name.
+    expect(dataset.displayName('\u{1FAF6}\u{200D}\u{2764}'), isNotEmpty);
+  });
+
+  test('empty dataset degrades safely', () {
+    expect(EmojiDataset.empty.isEmpty, isTrue);
+    expect(EmojiDataset.empty.displayName('🔥'), '🔥');
+  });
+}

mobile/test/shared/emoji/emoji_only_test.dart

@@ -0,0 +1,81 @@
+import 'package:buzz/shared/custom_emoji/custom_emoji.dart';
+import 'package:buzz/shared/emoji/emoji_only.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+const _customEmoji = [
+  CustomEmoji(shortcode: 'buzz', url: 'https://example.test/buzz.png'),
+];
+
+/// Keycaps carry no `Extended_Pictographic` code point of their own, so they
+/// only pass via the dataset's glyph set — the one case that needs it.
+const _keycapOne = '1\u{FE0F}\u{20E3}';
+
+bool emojiOnly(
+  String content, {
+  Set<String> nativeEmoji = const {},
+  List<CustomEmoji> customEmoji = const [],
+}) => isEmojiOnlyMessage(
+  content,
+  nativeEmoji: nativeEmoji,
+  customEmoji: customEmoji,
+);
+
+void main() {
+  group('isEmojiOnlyMessage', () {
+    test('accepts emoji, alone and in runs', () {
+      // Mirrors the cases in desktop's emojiOnly.test.mjs.
+      expect(emojiOnly('\u{1F600}'), isTrue);
+      expect(
+        emojiOnly('\u{1F600} \u{1F44D}\u{1F3FD}\n\u{2764}\u{FE0F}'),
+        isTrue,
+      );
+      expect(emojiOnly('\u{1F3F3}\u{FE0F}\u{200D}\u{1F308}'), isTrue);
+      expect(
+        emojiOnly(
+          '\u{1F468}\u{200D}\u{1F469}\u{200D}\u{1F467}\u{200D}\u{1F466}',
+        ),
+        isTrue,
+      );
+    });
+
+    test('rejects anything with text in it', () {
+      expect(emojiOnly('hi \u{1F600}'), isFalse);
+      expect(emojiOnly('\u{1F600}!'), isFalse);
+      expect(emojiOnly('nice'), isFalse);
+    });
+
+    test('rejects empty and whitespace-only bodies', () {
+      expect(emojiOnly(''), isFalse);
+      expect(emojiOnly('   \n '), isFalse);
+    });
+
+    test('counts a known custom shortcode as emoji', () {
+      expect(emojiOnly(':buzz:', customEmoji: _customEmoji), isTrue);
+      expect(emojiOnly(':buzz: \u{1F600}', customEmoji: _customEmoji), isTrue);
+      expect(emojiOnly('hi :buzz:', customEmoji: _customEmoji), isFalse);
+    });
+
+    test('an unknown shortcode is just text', () {
+      // Desktop behaves the same: without the palette it renders literally, so
+      // it must not be scaled up as if it were a glyph.
+      expect(emojiOnly(':buzz:'), isFalse);
+      expect(emojiOnly(':nope:', customEmoji: _customEmoji), isFalse);
+      expect(emojiOnly(':', customEmoji: _customEmoji), isFalse);
+      expect(emojiOnly('::', customEmoji: _customEmoji), isFalse);
+    });
+
+    test('keycaps need the dataset glyph set', () {
+      expect(emojiOnly(_keycapOne), isFalse);
+      expect(emojiOnly(_keycapOne, nativeEmoji: {_keycapOne}), isTrue);
+    });
+  });
+
+  group('emoji-only sizing', () {
+    test('matches desktop’s step up from body text', () {
+      // Desktop goes text-sm (14px) to text-4xl; mobile body is the same 14px.
+      expect(kEmojiOnlyFontSize, 36.0);
+      // Desktop sizes inline custom emoji at 1.45em of the surrounding text.
+      expect(kEmojiOnlyCustomEmojiSize, closeTo(36.0 * 1.45, 0.001));
+    });
+  });
+}

mobile/test/shared/emoji/emoji_search_test.dart

@@ -0,0 +1,121 @@
+import 'package:buzz/shared/emoji/emoji_data.dart';
+import 'package:buzz/shared/emoji/emoji_search.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+EmojiEntry _entry(
+  String id, {
+  String? name,
+  List<String> keywords = const [],
+  String native = '*',
+}) {
+  return EmojiEntry(
+    id: id,
+    name: name ?? id,
+    keywords: keywords,
+    native: native,
+    categoryId: 'people',
+  );
+}
+
+void main() {
+  group('collapseSeparators', () {
+    test('lowercases and drops shortcode punctuation', () {
+      expect(collapseSeparators(':Point_Up:'), 'pointup');
+      expect(collapseSeparators('white-check-mark'), 'whitecheckmark');
+      expect(collapseSeparators('  thumbs up '), 'thumbsup');
+    });
+  });
+
+  group('scoreShortcodeMatch', () {
+    test('ranks exact above prefix above substring above subsequence', () {
+      final exact = scoreShortcodeMatch('point_up', 'point_up')!;
+      final prefix = scoreShortcodeMatch('point', 'point_up')!;
+      final substring = scoreShortcodeMatch('up', 'point_up')!;
+      final subsequence = scoreShortcodeMatch('pntup', 'point_up')!;
+
+      expect(exact.tier, lessThan(prefix.tier));
+      expect(prefix.tier, lessThan(substring.tier));
+      expect(substring.tier, lessThan(subsequence.tier));
+    });
+
+    test('crosses the separator emoji-mart cannot', () {
+      expect(scoreShortcodeMatch('pointup', 'point_up'), isNotNull);
+      expect(scoreShortcodeMatch('pointup', 'point_up')!.tier, 0);
+    });
+
+    test('returns null for an empty query or no match', () {
+      expect(scoreShortcodeMatch('', 'point_up'), isNull);
+      expect(scoreShortcodeMatch('   ', 'point_up'), isNull);
+      expect(scoreShortcodeMatch('zzzz', 'point_up'), isNull);
+    });
+  });
+
+  group('searchEmoji', () {
+    final entries = [
+      _entry(
+        'point_up',
+        name: 'Index Pointing Up',
+        keywords: ['point', 'hand'],
+      ),
+      _entry('fire', name: 'Fire', keywords: ['flame', 'hot', 'lit']),
+      _entry(
+        'fire_engine',
+        name: 'Fire Engine',
+        keywords: ['fire', 'truck', 'emergency'],
+      ),
+      _entry('firecracker', name: 'Firecracker', keywords: ['dynamite']),
+      _entry('smile', name: 'Grinning Face With Smiling Eyes'),
+    ];
+
+    test('exact shortcode wins over longer prefixes', () {
+      final results = searchEmoji('fire', entries);
+      expect(results.first.id, 'fire');
+      expect(
+        results.map((entry) => entry.id),
+        containsAll(['fire', 'fire_engine', 'firecracker']),
+      );
+    });
+
+    test('shortcode prefix outranks a keyword-only hit', () {
+      final results = searchEmoji('flame', entries);
+      expect(results.single.id, 'fire');
+    });
+
+    test('separator-insensitive shortcode search still works', () {
+      expect(searchEmoji('pointup', entries).first.id, 'point_up');
+      expect(searchEmoji('fireengine', entries).first.id, 'fire_engine');
+    });
+
+    test('matches on name words when the shortcode does not contain them', () {
+      expect(searchEmoji('grinning', entries).single.id, 'smile');
+    });
+
+    test('honors the limit and returns empty for a blank query', () {
+      expect(searchEmoji('fire', entries, limit: 2), hasLength(2));
+      expect(searchEmoji('fire', entries, limit: 0), isEmpty);
+      expect(searchEmoji('', entries), isEmpty);
+    });
+  });
+
+  group('rankByShortcode', () {
+    test('ranks custom-emoji shortcodes with the desktop tiers', () {
+      final ranked = rankByShortcode('parrot', const [
+        'party_parrot',
+        'parrot',
+        'pirate_parrot',
+      ], (code) => code);
+
+      expect(ranked.first, 'parrot');
+      expect(ranked, hasLength(3));
+    });
+
+    test('prefers the shorter shortcode within a tier', () {
+      final ranked = rankByShortcode('par', const [
+        'parrotparrot',
+        'park',
+      ], (code) => code);
+
+      expect(ranked.first, 'park');
+    });
+  });
+}

mobile/test/shared/emoji/native_emoji_glyph_test.dart

@@ -0,0 +1,37 @@
+import 'package:buzz/shared/emoji/native_emoji_glyph.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  testWidgets('lifts the glyph one logical pixel on iOS', (tester) async {
+    debugDefaultTargetPlatformOverride = TargetPlatform.iOS;
+    try {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Center(child: NativeEmojiGlyph(emoji: '🔥', size: 24)),
+        ),
+      );
+
+      final transform = tester.widget<Transform>(find.byType(Transform));
+      expect(transform.transform.getTranslation().y, -1);
+    } finally {
+      debugDefaultTargetPlatformOverride = null;
+    }
+  });
+
+  testWidgets('keeps the glyph unshifted on Android', (tester) async {
+    debugDefaultTargetPlatformOverride = TargetPlatform.android;
+    try {
+      await tester.pumpWidget(
+        const MaterialApp(
+          home: Center(child: NativeEmojiGlyph(emoji: '🔥', size: 24)),
+        ),
+      );
+
+      expect(find.byType(Transform), findsNothing);
+    } finally {
+      debugDefaultTargetPlatformOverride = null;
+    }
+  });
+}

mobile/test/shared/emoji/positive_emoji_test.dart

@@ -0,0 +1,48 @@
+import 'package:buzz/shared/emoji/positive_emoji.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('isPositiveEmojiParticle', () {
+    test('accepts each group desktop celebrates', () {
+      expect(isPositiveEmojiParticle('\u{1F44D}'), isTrue); // 👍
+      expect(isPositiveEmojiParticle('\u{1F389}'), isTrue); // 🎉
+      expect(isPositiveEmojiParticle('\u{2764}\u{FE0F}'), isTrue); // ❤️
+      expect(isPositiveEmojiParticle('\u{1F602}'), isTrue); // 😂
+    });
+
+    test('rejects everything outside the set', () {
+      expect(isPositiveEmojiParticle('\u{1F44E}'), isFalse); // 👎
+      expect(isPositiveEmojiParticle('\u{1F622}'), isFalse); // 😢
+      expect(isPositiveEmojiParticle('\u{1F440}'), isFalse); // 👀
+      expect(isPositiveEmojiParticle(':partyparrot:'), isFalse);
+      expect(isPositiveEmojiParticle(''), isFalse);
+    });
+
+    test('ignores the presentation selector and surrounding space', () {
+      // The same emoji arrives with and without U+FE0F depending on the
+      // producer, and reactions come off the wire as well as from our picker.
+      expect(isPositiveEmojiParticle('\u{2764}'), isTrue);
+      expect(isPositiveEmojiParticle('\u{2B50}\u{FE0F}'), isTrue);
+      expect(isPositiveEmojiParticle(' \u{1F525} '), isTrue);
+    });
+
+    test('every entry in the exported list passes its own gate', () {
+      for (final emoji in positiveEmojiParticles) {
+        expect(
+          isPositiveEmojiParticle(emoji),
+          isTrue,
+          reason: 'expected $emoji to be a positive particle',
+        );
+      }
+    });
+
+    test('the three groups match desktop counts', () {
+      // Guards against a half-applied port: desktop has 23 hearts, 14 reaction
+      // emoji, and 15 faces.
+      expect(heartParticleEmojis, hasLength(23));
+      expect(positiveReactionParticleEmojis, hasLength(14));
+      expect(positiveFaceParticleEmojis, hasLength(15));
+      expect(positiveEmojiParticles, hasLength(52));
+    });
+  });
+}