feat: import Chinese-localized Buzz source snapshot

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

mobile/lib/features/channels/thread_replies_provider.dart

@@ -0,0 +1,154 @@
+import 'dart:async';
+
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+
+import '../../shared/relay/relay.dart';
+import 'pending_local_messages_provider.dart';
+
+class ThreadRepliesArgs {
+  final String channelId;
+  final String rootId;
+
+  const ThreadRepliesArgs({required this.channelId, required this.rootId});
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is ThreadRepliesArgs &&
+          channelId == other.channelId &&
+          rootId == other.rootId;
+
+  @override
+  int get hashCode => Object.hash(channelId, rootId);
+}
+
+class _ThreadCursor {
+  final int createdAt;
+  final String eventId;
+
+  const _ThreadCursor({required this.createdAt, required this.eventId});
+}
+
+final threadRepliesProvider =
+    FutureProvider.family<List<NostrEvent>, ThreadRepliesArgs>((
+      ref,
+      args,
+    ) async {
+      final session = ref.watch(relaySessionProvider.notifier);
+      final replies = <NostrEvent>[];
+      _ThreadCursor? cursor;
+      for (var page = 0; page < 500; page++) {
+        final events = await session.queryRelay([
+          _threadRepliesFilter(args, cursor),
+        ]);
+        replies.addAll(events);
+        if (events.length < 200) return replies;
+        final last = events.last;
+        cursor = _ThreadCursor(createdAt: last.createdAt, eventId: last.id);
+      }
+      throw Exception('Thread ${args.rootId} exceeded the page safety limit.');
+    });
+
+NostrFilter _threadRepliesFilter(
+  ThreadRepliesArgs args,
+  _ThreadCursor? cursor,
+) {
+  return NostrFilter(
+    kinds: EventKind.channelTimelineContentKinds,
+    tags: {
+      '#e': [args.rootId],
+      '#h': [args.channelId],
+    },
+    limit: 200,
+    extensions: {
+      'depth_limit': 64,
+      if (cursor != null) 'thread_cursor': cursor.createdAt,
+      if (cursor != null) 'thread_cursor_id': cursor.eventId,
+    },
+  );
+}
+
+class ThreadLocalRepliesNotifier extends Notifier<List<NostrEvent>> {
+  final ThreadRepliesArgs args;
+
+  ThreadLocalRepliesNotifier(this.args);
+
+  @override
+  List<NostrEvent> build() => const [];
+
+  void add(NostrEvent event) {
+    state = _mergeReplies(state, [event]);
+  }
+
+  void remove(String eventId) {
+    state = state.where((event) => event.id != eventId).toList();
+  }
+
+  void confirm(Set<String> eventIds) {
+    if (!state.any((event) => eventIds.contains(event.id))) return;
+    state = state.where((event) => !eventIds.contains(event.id)).toList();
+  }
+}
+
+final threadLocalRepliesProvider =
+    NotifierProvider.family<
+      ThreadLocalRepliesNotifier,
+      List<NostrEvent>,
+      ThreadRepliesArgs
+    >(ThreadLocalRepliesNotifier.new);
+
+/// Relay-backed replies merged with signed local replies that are still
+/// waiting for acknowledgement.
+final threadRepliesWithLocalProvider =
+    Provider.family<AsyncValue<List<NostrEvent>>, ThreadRepliesArgs>((
+      ref,
+      args,
+    ) {
+      final relayReplies = ref.watch(threadRepliesProvider(args));
+      final localReplies = ref.watch(threadLocalRepliesProvider(args));
+      final authoritative = relayReplies.value;
+      if (authoritative != null && localReplies.isNotEmpty) {
+        final authoritativeIds = authoritative.map((event) => event.id).toSet();
+        if (localReplies.any((event) => authoritativeIds.contains(event.id))) {
+          Future.microtask(() {
+            ref
+                .read(threadLocalRepliesProvider(args).notifier)
+                .confirm(authoritativeIds);
+            ref
+                .read(pendingLocalMessagesProvider(args.channelId).notifier)
+                .confirm(authoritativeIds);
+          });
+        }
+      }
+      if (localReplies.isEmpty) return relayReplies;
+      return relayReplies.when(
+        data: (events) => AsyncData(_mergeReplies(events, localReplies)),
+        loading: () => AsyncData(localReplies),
+        error: (error, stackTrace) => AsyncData(localReplies),
+      );
+    });
+
+/// Union two event lists by id, newest-wins, in timeline order.
+///
+/// The thread view needs this to fold the channel's live socket events into its
+/// own one-shot query result: the query asks for content kinds only, so
+/// reactions, edits, and deletions that land while a thread is open never reach
+/// it on their own.
+List<NostrEvent> mergeThreadEvents(
+  Iterable<NostrEvent> first,
+  Iterable<NostrEvent> second,
+) => _mergeReplies(first, second);
+
+List<NostrEvent> _mergeReplies(
+  Iterable<NostrEvent> first,
+  Iterable<NostrEvent> second,
+) {
+  final byId = <String, NostrEvent>{};
+  for (final event in [...first, ...second]) {
+    byId[event.id] = event;
+  }
+  return byId.values.toList()..sort((a, b) {
+    final createdAt = a.createdAt.compareTo(b.createdAt);
+    return createdAt != 0 ? createdAt : a.id.compareTo(b.id);
+  });
+}