comparing a5f9524ae73aff9474c85c0318115b1877b1e6f6 and main on bretton.dev/coves-mobile

+1 -3

lib/services/comment_service.dart

···

       119
       119
        
             final cid = data['cid'] as String?;

     

       120
       120
        
       

     

       121
       121
        
             if (uri == null || uri.isEmpty || cid == null || cid.isEmpty) {

     

       122
       122
       -
               throw ApiException(

     

       123
       123
       -
                 'Invalid response from server - missing uri or cid',

     

       124
       124
       -
               );

     

       122
       122
       +
               throw ApiException('Invalid response from server - missing uri or cid');

     

       125
       123
        
             }

     

       126
       124
        
       

     

       127
       125
        
             if (kDebugMode) {

+96 -87

test/services/comment_service_test.dart

···

       178
       178
        
               );

     

       179
       179
        
             });

     

       180
       180
        
       

     

       181
       181
       -
             test('should throw ApiException on invalid response (null data)', () async {

     

       182
       182
       -
               when(

     

       183
       183
       -
                 mockDio.post<Map<String, dynamic>>(

     

       184
       184
       -
                   '/xrpc/social.coves.community.comment.create',

     

       185
       185
       -
                   data: anyNamed('data'),

     

       186
       186
       -
                 ),

     

       187
       187
       -
               ).thenAnswer(

     

       188
       188
       -
                 (_) async => Response(

     

       189
       189
       -
                   requestOptions: RequestOptions(path: ''),

     

       190
       190
       -
                   statusCode: 200,

     

       191
       191
       -
                   data: null,

     

       192
       192
       -
                 ),

     

       193
       193
       -
               );

     

       181
       181
       +
             test(

     

       182
       182
       +
               'should throw ApiException on invalid response (null data)',

     

       183
       183
       +
               () async {

     

       184
       184
       +
                 when(

     

       185
       185
       +
                   mockDio.post<Map<String, dynamic>>(

     

       186
       186
       +
                     '/xrpc/social.coves.community.comment.create',

     

       187
       187
       +
                     data: anyNamed('data'),

     

       188
       188
       +
                   ),

     

       189
       189
       +
                 ).thenAnswer(

     

       190
       190
       +
                   (_) async => Response(

     

       191
       191
       +
                     requestOptions: RequestOptions(path: ''),

     

       192
       192
       +
                     statusCode: 200,

     

       193
       193
       +
                     data: null,

     

       194
       194
       +
                   ),

     

       195
       195
       +
                 );

     

       194
       196
        
       

     

       195
       195
       -
               expect(

     

       196
       196
       -
                 () => commentService.createComment(

     

       197
       197
       -
                   rootUri: 'at://did:plc:author/post/123',

     

       198
       198
       -
                   rootCid: 'rootCid',

     

       199
       199
       -
                   parentUri: 'at://did:plc:author/post/123',

     

       200
       200
       -
                   parentCid: 'parentCid',

     

       201
       201
       -
                   content: 'Test comment',

     

       202
       202
       -
                 ),

     

       203
       203
       -
                 throwsA(

     

       204
       204
       -
                   isA<ApiException>().having(

     

       205
       205
       -
                     (e) => e.message,

     

       206
       206
       -
                     'message',

     

       207
       207
       -
                     contains('no data'),

     

       197
       197
       +
                 expect(

     

       198
       198
       +
                   () => commentService.createComment(

     

       199
       199
       +
                     rootUri: 'at://did:plc:author/post/123',

     

       200
       200
       +
                     rootCid: 'rootCid',

     

       201
       201
       +
                     parentUri: 'at://did:plc:author/post/123',

     

       202
       202
       +
                     parentCid: 'parentCid',

     

       203
       203
       +
                     content: 'Test comment',

     

       208
       204
        
                   ),

     

       209
       209
       -
                 ),

     

       210
       210
       -
               );

     

       211
       211
       -
             });

     

       205
       205
       +
                   throwsA(

     

       206
       206
       +
                     isA<ApiException>().having(

     

       207
       207
       +
                       (e) => e.message,

     

       208
       208
       +
                       'message',

     

       209
       209
       +
                       contains('no data'),

     

       210
       210
       +
                     ),

     

       211
       211
       +
                   ),

     

       212
       212
       +
                 );

     

       213
       213
       +
               },

     

       214
       214
       +
             );

     

       212
       215
        
       

     

       213
       213
       -
             test('should throw ApiException on invalid response (missing uri)', () async {

     

       214
       214
       -
               when(

     

       215
       215
       -
                 mockDio.post<Map<String, dynamic>>(

     

       216
       216
       -
                   '/xrpc/social.coves.community.comment.create',

     

       217
       217
       -
                   data: anyNamed('data'),

     

       218
       218
       -
                 ),

     

       219
       219
       -
               ).thenAnswer(

     

       220
       220
       -
                 (_) async => Response(

     

       221
       221
       -
                   requestOptions: RequestOptions(path: ''),

     

       222
       222
       -
                   statusCode: 200,

     

       223
       223
       -
                   data: {'cid': 'bafy123'},

     

       224
       224
       -
                 ),

     

       225
       225
       -
               );

     

       216
       216
       +
             test(

     

       217
       217
       +
               'should throw ApiException on invalid response (missing uri)',

     

       218
       218
       +
               () async {

     

       219
       219
       +
                 when(

     

       220
       220
       +
                   mockDio.post<Map<String, dynamic>>(

     

       221
       221
       +
                     '/xrpc/social.coves.community.comment.create',

     

       222
       222
       +
                     data: anyNamed('data'),

     

       223
       223
       +
                   ),

     

       224
       224
       +
                 ).thenAnswer(

     

       225
       225
       +
                   (_) async => Response(

     

       226
       226
       +
                     requestOptions: RequestOptions(path: ''),

     

       227
       227
       +
                     statusCode: 200,

     

       228
       228
       +
                     data: {'cid': 'bafy123'},

     

       229
       229
       +
                   ),

     

       230
       230
       +
                 );

     

       226
       231
        
       

     

       227
       227
       -
               expect(

     

       228
       228
       -
                 () => commentService.createComment(

     

       229
       229
       -
                   rootUri: 'at://did:plc:author/post/123',

     

       230
       230
       -
                   rootCid: 'rootCid',

     

       231
       231
       -
                   parentUri: 'at://did:plc:author/post/123',

     

       232
       232
       -
                   parentCid: 'parentCid',

     

       233
       233
       -
                   content: 'Test comment',

     

       234
       234
       -
                 ),

     

       235
       235
       -
                 throwsA(

     

       236
       236
       -
                   isA<ApiException>().having(

     

       237
       237
       -
                     (e) => e.message,

     

       238
       238
       -
                     'message',

     

       239
       239
       -
                     contains('missing uri'),

     

       232
       232
       +
                 expect(

     

       233
       233
       +
                   () => commentService.createComment(

     

       234
       234
       +
                     rootUri: 'at://did:plc:author/post/123',

     

       235
       235
       +
                     rootCid: 'rootCid',

     

       236
       236
       +
                     parentUri: 'at://did:plc:author/post/123',

     

       237
       237
       +
                     parentCid: 'parentCid',

     

       238
       238
       +
                     content: 'Test comment',

     

       240
       239
        
                   ),

     

       241
       241
       -
                 ),

     

       242
       242
       -
               );

     

       243
       243
       -
             });

     

       240
       240
       +
                   throwsA(

     

       241
       241
       +
                     isA<ApiException>().having(

     

       242
       242
       +
                       (e) => e.message,

     

       243
       243
       +
                       'message',

     

       244
       244
       +
                       contains('missing uri'),

     

       245
       245
       +
                     ),

     

       246
       246
       +
                   ),

     

       247
       247
       +
                 );

     

       248
       248
       +
               },

     

       249
       249
       +
             );

     

       244
       250
        
       

     

       245
       245
       -
             test('should throw ApiException on invalid response (empty uri)', () async {

     

       246
       246
       -
               when(

     

       247
       247
       -
                 mockDio.post<Map<String, dynamic>>(

     

       248
       248
       -
                   '/xrpc/social.coves.community.comment.create',

     

       249
       249
       -
                   data: anyNamed('data'),

     

       250
       250
       -
                 ),

     

       251
       251
       -
               ).thenAnswer(

     

       252
       252
       -
                 (_) async => Response(

     

       253
       253
       -
                   requestOptions: RequestOptions(path: ''),

     

       254
       254
       -
                   statusCode: 200,

     

       255
       255
       -
                   data: {'uri': '', 'cid': 'bafy123'},

     

       256
       256
       -
                 ),

     

       257
       257
       -
               );

     

       251
       251
       +
             test(

     

       252
       252
       +
               'should throw ApiException on invalid response (empty uri)',

     

       253
       253
       +
               () async {

     

       254
       254
       +
                 when(

     

       255
       255
       +
                   mockDio.post<Map<String, dynamic>>(

     

       256
       256
       +
                     '/xrpc/social.coves.community.comment.create',

     

       257
       257
       +
                     data: anyNamed('data'),

     

       258
       258
       +
                   ),

     

       259
       259
       +
                 ).thenAnswer(

     

       260
       260
       +
                   (_) async => Response(

     

       261
       261
       +
                     requestOptions: RequestOptions(path: ''),

     

       262
       262
       +
                     statusCode: 200,

     

       263
       263
       +
                     data: {'uri': '', 'cid': 'bafy123'},

     

       264
       264
       +
                   ),

     

       265
       265
       +
                 );

     

       258
       266
        
       

     

       259
       259
       -
               expect(

     

       260
       260
       -
                 () => commentService.createComment(

     

       261
       261
       -
                   rootUri: 'at://did:plc:author/post/123',

     

       262
       262
       -
                   rootCid: 'rootCid',

     

       263
       263
       -
                   parentUri: 'at://did:plc:author/post/123',

     

       264
       264
       -
                   parentCid: 'parentCid',

     

       265
       265
       -
                   content: 'Test comment',

     

       266
       266
       -
                 ),

     

       267
       267
       -
                 throwsA(

     

       268
       268
       -
                   isA<ApiException>().having(

     

       269
       269
       -
                     (e) => e.message,

     

       270
       270
       -
                     'message',

     

       271
       271
       -
                     contains('missing uri'),

     

       267
       267
       +
                 expect(

     

       268
       268
       +
                   () => commentService.createComment(

     

       269
       269
       +
                     rootUri: 'at://did:plc:author/post/123',

     

       270
       270
       +
                     rootCid: 'rootCid',

     

       271
       271
       +
                     parentUri: 'at://did:plc:author/post/123',

     

       272
       272
       +
                     parentCid: 'parentCid',

     

       273
       273
       +
                     content: 'Test comment',

     

       272
       274
        
                   ),

     

       273
       273
       -
                 ),

     

       274
       274
       -
               );

     

       275
       275
       -
             });

     

       275
       275
       +
                   throwsA(

     

       276
       276
       +
                     isA<ApiException>().having(

     

       277
       277
       +
                       (e) => e.message,

     

       278
       278
       +
                       'message',

     

       279
       279
       +
                       contains('missing uri'),

     

       280
       280
       +
                     ),

     

       281
       281
       +
                   ),

     

       282
       282
       +
                 );

     

       283
       283
       +
               },

     

       284
       284
       +
             );

     

       276
       285
        
       

     

       277
       286
        
             test('should throw ApiException on server error', () async {

     

       278
       287
        
               when(

+14

lib/config/environment_config.dart

···

       54
       54
        
         static const String _flavor = String.fromEnvironment('FLUTTER_FLAVOR');

     

       55
       55
        
       

     

       56
       56
        
         /// Explicit environment override via --dart-define=ENVIRONMENT=local

     

       57
       57
       +
         /// Also supports --dart-define=ENV=dev for convenience

     

       57
       58
        
         static const String _envOverride = String.fromEnvironment('ENVIRONMENT');

     

       59
       59
       +
         static const String _envShorthand = String.fromEnvironment('ENV');

     

       58
       60
        
       

     

       59
       61
        
         /// Get current environment based on build configuration

     

       60
       62
        
         ///

     
···

       73
       75
        
             }

     

       74
       76
        
           }

     

       75
       77
        
       

     

       78
       78
       +
           // Priority 1b: Shorthand ENV override (dev -> local, prod -> production)

     

       79
       79
       +
           if (_envShorthand.isNotEmpty) {

     

       80
       80
       +
             switch (_envShorthand) {

     

       81
       81
       +
               case 'dev':

     

       82
       82
       +
               case 'local':

     

       83
       83
       +
                 return local;

     

       84
       84
       +
               case 'prod':

     

       85
       85
       +
               case 'production':

     

       86
       86
       +
                 return production;

     

       87
       87
       +
             }

     

       88
       88
       +
           }

     

       89
       89
       +
       

     

       76
       90
        
           // Priority 2: Flavor-based environment

     

       77
       91
        
           switch (_flavor) {

     

       78
       92
        
             case 'dev':

-1

macos/Flutter/Flutter-Debug.xcconfig

···

       1
       1
       -
       #include "ephemeral/Flutter-Generated.xcconfig"

-1

macos/Flutter/Flutter-Release.xcconfig

···

       1
       1
       -
       #include "ephemeral/Flutter-Generated.xcconfig"

+14

lib/constants/threading_colors.dart

···

       1
       1
       +
       import 'package:flutter/material.dart';

     

       2
       2
       +
       

     

       3
       3
       +
       /// Color palette for comment threading depth indicators

     

       4
       4
       +
       ///

     

       5
       5
       +
       /// These colors cycle through as threads get deeper, providing visual

     

       6
       6
       +
       /// distinction between nesting levels. Used by CommentCard and CommentThread.

     

       7
       7
       +
       const List<Color> kThreadingColors = [

     

       8
       8
       +
         Color(0xFFFF6B6B), // Red

     

       9
       9
       +
         Color(0xFF4ECDC4), // Teal

     

       10
       10
       +
         Color(0xFFFFE66D), // Yellow

     

       11
       11
       +
         Color(0xFF95E1D3), // Mint

     

       12
       12
       +
         Color(0xFFC7CEEA), // Purple

     

       13
       13
       +
         Color(0xFFFFAA5C), // Orange

     

       14
       14
       +
       ];

+42

lib/widgets/status_bar_overlay.dart

···

       1
       1
       +
       import 'package:flutter/material.dart';

     

       2
       2
       +
       

     

       3
       3
       +
       import '../constants/app_colors.dart';

     

       4
       4
       +
       

     

       5
       5
       +
       /// A solid color overlay for the status bar area

     

       6
       6
       +
       ///

     

       7
       7
       +
       /// Prevents content from showing through the transparent status bar when

     

       8
       8
       +
       /// scrolling. Use with a Stack widget, positioned at the top.

     

       9
       9
       +
       ///

     

       10
       10
       +
       /// Example:

     

       11
       11
       +
       /// ```dart

     

       12
       12
       +
       /// Stack(

     

       13
       13
       +
       ///   children: [

     

       14
       14
       +
       ///     // Your scrollable content

     

       15
       15
       +
       ///     CustomScrollView(...),

     

       16
       16
       +
       ///     // Status bar overlay

     

       17
       17
       +
       ///     const StatusBarOverlay(),

     

       18
       18
       +
       ///   ],

     

       19
       19
       +
       /// )

     

       20
       20
       +
       /// ```

     

       21
       21
       +
       class StatusBarOverlay extends StatelessWidget {

     

       22
       22
       +
         const StatusBarOverlay({

     

       23
       23
       +
           this.color = AppColors.background,

     

       24
       24
       +
           super.key,

     

       25
       25
       +
         });

     

       26
       26
       +
       

     

       27
       27
       +
         /// The color to fill the status bar area with

     

       28
       28
       +
         final Color color;

     

       29
       29
       +
       

     

       30
       30
       +
         @override

     

       31
       31
       +
         Widget build(BuildContext context) {

     

       32
       32
       +
           final statusBarHeight = MediaQuery.of(context).padding.top;

     

       33
       33
       +
       

     

       34
       34
       +
           return Positioned(

     

       35
       35
       +
             top: 0,

     

       36
       36
       +
             left: 0,

     

       37
       37
       +
             right: 0,

     

       38
       38
       +
             height: statusBarHeight,

     

       39
       39
       +
             child: Container(color: color),

     

       40
       40
       +
           );

     

       41
       41
       +
         }

     

       42
       42
       +
       }

+267

test/widgets/comment_thread_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/models/comment.dart';

     

       2
       2
       +
       import 'package:coves_flutter/models/post.dart';

     

       3
       3
       +
       import 'package:coves_flutter/widgets/comment_thread.dart';

     

       4
       4
       +
       import 'package:flutter/material.dart';

     

       5
       5
       +
       import 'package:flutter_test/flutter_test.dart';

     

       6
       6
       +
       import 'package:provider/provider.dart';

     

       7
       7
       +
       

     

       8
       8
       +
       import '../test_helpers/mock_providers.dart';

     

       9
       9
       +
       

     

       10
       10
       +
       void main() {

     

       11
       11
       +
         late MockAuthProvider mockAuthProvider;

     

       12
       12
       +
         late MockVoteProvider mockVoteProvider;

     

       13
       13
       +
       

     

       14
       14
       +
         setUp(() {

     

       15
       15
       +
           mockAuthProvider = MockAuthProvider();

     

       16
       16
       +
           mockVoteProvider = MockVoteProvider();

     

       17
       17
       +
         });

     

       18
       18
       +
       

     

       19
       19
       +
         /// Helper to create a test comment

     

       20
       20
       +
         CommentView createComment({

     

       21
       21
       +
           required String uri,

     

       22
       22
       +
           String content = 'Test comment',

     

       23
       23
       +
           String handle = 'test.user',

     

       24
       24
       +
         }) {

     

       25
       25
       +
           return CommentView(

     

       26
       26
       +
             uri: uri,

     

       27
       27
       +
             cid: 'cid-$uri',

     

       28
       28
       +
             content: content,

     

       29
       29
       +
             createdAt: DateTime(2025),

     

       30
       30
       +
             indexedAt: DateTime(2025),

     

       31
       31
       +
             author: AuthorView(did: 'did:plc:author', handle: handle),

     

       32
       32
       +
             post: CommentRef(uri: 'at://did:plc:test/post/123', cid: 'post-cid'),

     

       33
       33
       +
             stats: CommentStats(upvotes: 5, downvotes: 1, score: 4),

     

       34
       34
       +
           );

     

       35
       35
       +
         }

     

       36
       36
       +
       

     

       37
       37
       +
         /// Helper to create a thread with nested replies

     

       38
       38
       +
         ThreadViewComment createThread({

     

       39
       39
       +
           required String uri,

     

       40
       40
       +
           String content = 'Test comment',

     

       41
       41
       +
           List<ThreadViewComment>? replies,

     

       42
       42
       +
         }) {

     

       43
       43
       +
           return ThreadViewComment(

     

       44
       44
       +
             comment: createComment(uri: uri, content: content),

     

       45
       45
       +
             replies: replies,

     

       46
       46
       +
           );

     

       47
       47
       +
         }

     

       48
       48
       +
       

     

       49
       49
       +
         Widget createTestWidget(

     

       50
       50
       +
           ThreadViewComment thread, {

     

       51
       51
       +
           int depth = 0,

     

       52
       52
       +
           int maxDepth = 5,

     

       53
       53
       +
           void Function(ThreadViewComment)? onCommentTap,

     

       54
       54
       +
           void Function(String uri)? onCollapseToggle,

     

       55
       55
       +
           void Function(ThreadViewComment, List<ThreadViewComment>)? onContinueThread,

     

       56
       56
       +
           Set<String> collapsedComments = const {},

     

       57
       57
       +
           List<ThreadViewComment> ancestors = const [],

     

       58
       58
       +
         }) {

     

       59
       59
       +
           return MultiProvider(

     

       60
       60
       +
             providers: [

     

       61
       61
       +
               ChangeNotifierProvider<MockAuthProvider>.value(value: mockAuthProvider),

     

       62
       62
       +
               ChangeNotifierProvider<MockVoteProvider>.value(value: mockVoteProvider),

     

       63
       63
       +
             ],

     

       64
       64
       +
             child: MaterialApp(

     

       65
       65
       +
               home: Scaffold(

     

       66
       66
       +
                 body: SingleChildScrollView(

     

       67
       67
       +
                   child: CommentThread(

     

       68
       68
       +
                     thread: thread,

     

       69
       69
       +
                     depth: depth,

     

       70
       70
       +
                     maxDepth: maxDepth,

     

       71
       71
       +
                     onCommentTap: onCommentTap,

     

       72
       72
       +
                     onCollapseToggle: onCollapseToggle,

     

       73
       73
       +
                     onContinueThread: onContinueThread,

     

       74
       74
       +
                     collapsedComments: collapsedComments,

     

       75
       75
       +
                     ancestors: ancestors,

     

       76
       76
       +
                   ),

     

       77
       77
       +
                 ),

     

       78
       78
       +
               ),

     

       79
       79
       +
             ),

     

       80
       80
       +
           );

     

       81
       81
       +
         }

     

       82
       82
       +
       

     

       83
       83
       +
         group('CommentThread', () {

     

       84
       84
       +
           group('countDescendants', () {

     

       85
       85
       +
             test('returns 0 for thread with no replies', () {

     

       86
       86
       +
               final thread = createThread(uri: 'comment/1');

     

       87
       87
       +
       

     

       88
       88
       +
               expect(CommentThread.countDescendants(thread), 0);

     

       89
       89
       +
             });

     

       90
       90
       +
       

     

       91
       91
       +
             test('returns 0 for thread with empty replies', () {

     

       92
       92
       +
               final thread = createThread(uri: 'comment/1', replies: []);

     

       93
       93
       +
       

     

       94
       94
       +
               expect(CommentThread.countDescendants(thread), 0);

     

       95
       95
       +
             });

     

       96
       96
       +
       

     

       97
       97
       +
             test('counts direct replies', () {

     

       98
       98
       +
               final thread = createThread(

     

       99
       99
       +
                 uri: 'comment/1',

     

       100
       100
       +
                 replies: [

     

       101
       101
       +
                   createThread(uri: 'comment/2'),

     

       102
       102
       +
                   createThread(uri: 'comment/3'),

     

       103
       103
       +
                 ],

     

       104
       104
       +
               );

     

       105
       105
       +
       

     

       106
       106
       +
               expect(CommentThread.countDescendants(thread), 2);

     

       107
       107
       +
             });

     

       108
       108
       +
       

     

       109
       109
       +
             test('counts nested replies recursively', () {

     

       110
       110
       +
               final thread = createThread(

     

       111
       111
       +
                 uri: 'comment/1',

     

       112
       112
       +
                 replies: [

     

       113
       113
       +
                   createThread(

     

       114
       114
       +
                     uri: 'comment/2',

     

       115
       115
       +
                     replies: [

     

       116
       116
       +
                       createThread(uri: 'comment/3'),

     

       117
       117
       +
                       createThread(

     

       118
       118
       +
                         uri: 'comment/4',

     

       119
       119
       +
                         replies: [

     

       120
       120
       +
                           createThread(uri: 'comment/5'),

     

       121
       121
       +
                         ],

     

       122
       122
       +
                       ),

     

       123
       123
       +
                     ],

     

       124
       124
       +
                   ),

     

       125
       125
       +
                 ],

     

       126
       126
       +
               );

     

       127
       127
       +
       

     

       128
       128
       +
               // 1 direct reply + 2 nested + 1 deeply nested = 4

     

       129
       129
       +
               expect(CommentThread.countDescendants(thread), 4);

     

       130
       130
       +
             });

     

       131
       131
       +
           });

     

       132
       132
       +
       

     

       133
       133
       +
           group(

     

       134
       134
       +
             'rendering',

     

       135
       135
       +
             skip: 'Provider type compatibility issues - needs mock refactoring',

     

       136
       136
       +
             () {

     

       137
       137
       +
               testWidgets('renders comment content', (tester) async {

     

       138
       138
       +
                 final thread = createThread(

     

       139
       139
       +
                   uri: 'comment/1',

     

       140
       140
       +
                   content: 'Hello, world!',

     

       141
       141
       +
                 );

     

       142
       142
       +
       

     

       143
       143
       +
                 await tester.pumpWidget(createTestWidget(thread));

     

       144
       144
       +
       

     

       145
       145
       +
                 expect(find.text('Hello, world!'), findsOneWidget);

     

       146
       146
       +
               });

     

       147
       147
       +
       

     

       148
       148
       +
               testWidgets('renders nested replies when depth < maxDepth',

     

       149
       149
       +
                   (tester) async {

     

       150
       150
       +
                 final thread = createThread(

     

       151
       151
       +
                   uri: 'comment/1',

     

       152
       152
       +
                   content: 'Parent',

     

       153
       153
       +
                   replies: [

     

       154
       154
       +
                     createThread(uri: 'comment/2', content: 'Child 1'),

     

       155
       155
       +
                     createThread(uri: 'comment/3', content: 'Child 2'),

     

       156
       156
       +
                   ],

     

       157
       157
       +
                 );

     

       158
       158
       +
       

     

       159
       159
       +
                 await tester.pumpWidget(createTestWidget(thread));

     

       160
       160
       +
       

     

       161
       161
       +
                 expect(find.text('Parent'), findsOneWidget);

     

       162
       162
       +
                 expect(find.text('Child 1'), findsOneWidget);

     

       163
       163
       +
                 expect(find.text('Child 2'), findsOneWidget);

     

       164
       164
       +
               });

     

       165
       165
       +
       

     

       166
       166
       +
               testWidgets('shows "Read X more replies" at maxDepth', (tester) async {

     

       167
       167
       +
                 final thread = createThread(

     

       168
       168
       +
                   uri: 'comment/1',

     

       169
       169
       +
                   content: 'At max depth',

     

       170
       170
       +
                   replies: [

     

       171
       171
       +
                     createThread(uri: 'comment/2', content: 'Hidden reply'),

     

       172
       172
       +
                   ],

     

       173
       173
       +
                 );

     

       174
       174
       +
       

     

       175
       175
       +
                 await tester.pumpWidget(createTestWidget(thread, depth: 5));

     

       176
       176
       +
       

     

       177
       177
       +
                 expect(find.text('At max depth'), findsOneWidget);

     

       178
       178
       +
                 expect(find.textContaining('Read'), findsOneWidget);

     

       179
       179
       +
                 expect(find.textContaining('more'), findsOneWidget);

     

       180
       180
       +
                 // The hidden reply should NOT be rendered

     

       181
       181
       +
                 expect(find.text('Hidden reply'), findsNothing);

     

       182
       182
       +
               });

     

       183
       183
       +
       

     

       184
       184
       +
               testWidgets('does not show "Read more" when depth < maxDepth',

     

       185
       185
       +
                   (tester) async {

     

       186
       186
       +
                 final thread = createThread(

     

       187
       187
       +
                   uri: 'comment/1',

     

       188
       188
       +
                   replies: [

     

       189
       189
       +
                     createThread(uri: 'comment/2'),

     

       190
       190
       +
                   ],

     

       191
       191
       +
                 );

     

       192
       192
       +
       

     

       193
       193
       +
                 await tester.pumpWidget(createTestWidget(thread, depth: 3));

     

       194
       194
       +
       

     

       195
       195
       +
                 expect(find.textContaining('Read'), findsNothing);

     

       196
       196
       +
               });

     

       197
       197
       +
       

     

       198
       198
       +
               testWidgets('calls onContinueThread with correct ancestors',

     

       199
       199
       +
                   (tester) async {

     

       200
       200
       +
                 ThreadViewComment? tappedThread;

     

       201
       201
       +
                 List<ThreadViewComment>? receivedAncestors;

     

       202
       202
       +
       

     

       203
       203
       +
                 final thread = createThread(

     

       204
       204
       +
                   uri: 'comment/1',

     

       205
       205
       +
                   replies: [

     

       206
       206
       +
                     createThread(uri: 'comment/2'),

     

       207
       207
       +
                   ],

     

       208
       208
       +
                 );

     

       209
       209
       +
       

     

       210
       210
       +
                 await tester.pumpWidget(createTestWidget(

     

       211
       211
       +
                   thread,

     

       212
       212
       +
                   depth: 5,

     

       213
       213
       +
                   onContinueThread: (t, a) {

     

       214
       214
       +
                     tappedThread = t;

     

       215
       215
       +
                     receivedAncestors = a;

     

       216
       216
       +
                   },

     

       217
       217
       +
                 ));

     

       218
       218
       +
       

     

       219
       219
       +
                 // Find and tap the "Read more" link

     

       220
       220
       +
                 final readMoreFinder = find.textContaining('Read');

     

       221
       221
       +
                 expect(readMoreFinder, findsOneWidget);

     

       222
       222
       +
       

     

       223
       223
       +
                 await tester.tap(readMoreFinder);

     

       224
       224
       +
                 await tester.pump();

     

       225
       225
       +
       

     

       226
       226
       +
                 expect(tappedThread, isNotNull);

     

       227
       227
       +
                 expect(tappedThread!.comment.uri, 'comment/1');

     

       228
       228
       +
                 expect(receivedAncestors, isNotNull);

     

       229
       229
       +
                 // ancestors should NOT include the thread itself

     

       230
       230
       +
                 expect(receivedAncestors, isEmpty);

     

       231
       231
       +
               });

     

       232
       232
       +
       

     

       233
       233
       +
               testWidgets('handles correct reply count pluralization',

     

       234
       234
       +
                   (tester) async {

     

       235
       235
       +
                 // Single reply

     

       236
       236
       +
                 final singleReplyThread = createThread(

     

       237
       237
       +
                   uri: 'comment/1',

     

       238
       238
       +
                   replies: [

     

       239
       239
       +
                     createThread(uri: 'comment/2'),

     

       240
       240
       +
                   ],

     

       241
       241
       +
                 );

     

       242
       242
       +
       

     

       243
       243
       +
                 await tester.pumpWidget(

     

       244
       244
       +
                   createTestWidget(singleReplyThread, depth: 5),

     

       245
       245
       +
                 );

     

       246
       246
       +
       

     

       247
       247
       +
                 expect(find.text('Read 1 more reply'), findsOneWidget);

     

       248
       248
       +
               });

     

       249
       249
       +
       

     

       250
       250
       +
               testWidgets('handles multiple replies pluralization', (tester) async {

     

       251
       251
       +
                 final multiReplyThread = createThread(

     

       252
       252
       +
                   uri: 'comment/1',

     

       253
       253
       +
                   replies: [

     

       254
       254
       +
                     createThread(uri: 'comment/2'),

     

       255
       255
       +
                     createThread(uri: 'comment/3'),

     

       256
       256
       +
                     createThread(uri: 'comment/4'),

     

       257
       257
       +
                   ],

     

       258
       258
       +
                 );

     

       259
       259
       +
       

     

       260
       260
       +
                 await tester.pumpWidget(createTestWidget(multiReplyThread, depth: 5));

     

       261
       261
       +
       

     

       262
       262
       +
                 expect(find.text('Read 3 more replies'), findsOneWidget);

     

       263
       263
       +
               });

     

       264
       264
       +
             },

     

       265
       265
       +
           );

     

       266
       266
       +
         });

     

       267
       267
       +
       }

+217

lib/services/comments_provider_cache.dart

···

       1
       1
       +
       import 'dart:collection';

     

       2
       2
       +
       

     

       3
       3
       +
       import 'package:flutter/foundation.dart';

     

       4
       4
       +
       import '../providers/auth_provider.dart';

     

       5
       5
       +
       import '../providers/comments_provider.dart';

     

       6
       6
       +
       import '../providers/vote_provider.dart';

     

       7
       7
       +
       import 'comment_service.dart';

     

       8
       8
       +
       

     

       9
       9
       +
       /// Comments Provider Cache

     

       10
       10
       +
       ///

     

       11
       11
       +
       /// Manages cached CommentsProvider instances per post URI using LRU eviction.

     

       12
       12
       +
       /// Inspired by Thunder app's architecture for instant back navigation.

     

       13
       13
       +
       ///

     

       14
       14
       +
       /// Key features:

     

       15
       15
       +
       /// - One CommentsProvider per post URI

     

       16
       16
       +
       /// - LRU eviction (default: 15 most recent posts)

     

       17
       17
       +
       /// - Sign-out cleanup via AuthProvider listener

     

       18
       18
       +
       ///

     

       19
       19
       +
       /// Usage:

     

       20
       20
       +
       /// ```dart

     

       21
       21
       +
       /// final cache = context.read<CommentsProviderCache>();

     

       22
       22
       +
       /// final provider = cache.getProvider(

     

       23
       23
       +
       ///   postUri: post.uri,

     

       24
       24
       +
       ///   postCid: post.cid,

     

       25
       25
       +
       /// );

     

       26
       26
       +
       /// ```

     

       27
       27
       +
       class CommentsProviderCache {

     

       28
       28
       +
         CommentsProviderCache({

     

       29
       29
       +
           required AuthProvider authProvider,

     

       30
       30
       +
           required VoteProvider voteProvider,

     

       31
       31
       +
           required CommentService commentService,

     

       32
       32
       +
           this.maxSize = 15,

     

       33
       33
       +
         }) : _authProvider = authProvider,

     

       34
       34
       +
              _voteProvider = voteProvider,

     

       35
       35
       +
              _commentService = commentService {

     

       36
       36
       +
           _wasAuthenticated = _authProvider.isAuthenticated;

     

       37
       37
       +
           _authProvider.addListener(_onAuthChanged);

     

       38
       38
       +
         }

     

       39
       39
       +
       

     

       40
       40
       +
         final AuthProvider _authProvider;

     

       41
       41
       +
         final VoteProvider _voteProvider;

     

       42
       42
       +
         final CommentService _commentService;

     

       43
       43
       +
       

     

       44
       44
       +
         /// Maximum number of providers to cache

     

       45
       45
       +
         final int maxSize;

     

       46
       46
       +
       

     

       47
       47
       +
         /// LRU cache - LinkedHashMap maintains insertion order

     

       48
       48
       +
         /// Most recently accessed items are at the end

     

       49
       49
       +
         final LinkedHashMap<String, CommentsProvider> _cache = LinkedHashMap();

     

       50
       50
       +
       

     

       51
       51
       +
         /// Reference counts for "in-use" providers.

     

       52
       52
       +
         ///

     

       53
       53
       +
         /// Screens that hold onto a provider instance should call [acquireProvider]

     

       54
       54
       +
         /// and later [releaseProvider] to prevent LRU eviction from disposing a

     

       55
       55
       +
         /// provider that is still mounted in the navigation stack.

     

       56
       56
       +
         final Map<String, int> _refCounts = {};

     

       57
       57
       +
       

     

       58
       58
       +
         /// Track auth state for sign-out detection

     

       59
       59
       +
         bool _wasAuthenticated = false;

     

       60
       60
       +
       

     

       61
       61
       +
         /// Acquire (get or create) a CommentsProvider for a post.

     

       62
       62
       +
         ///

     

       63
       63
       +
         /// This "pins" the provider to avoid LRU eviction while in use.

     

       64
       64
       +
         /// Call [releaseProvider] when the consumer unmounts.

     

       65
       65
       +
         ///

     

       66
       66
       +
         /// If provider exists in cache, moves it to end (LRU touch).

     

       67
       67
       +
         /// If cache is full, evicts the oldest *unreferenced* provider before

     

       68
       68
       +
         /// creating a new one. If all providers are currently referenced, the cache

     

       69
       69
       +
         /// may temporarily exceed [maxSize] to avoid disposing active providers.

     

       70
       70
       +
         CommentsProvider acquireProvider({

     

       71
       71
       +
           required String postUri,

     

       72
       72
       +
           required String postCid,

     

       73
       73
       +
         }) {

     

       74
       74
       +
           final provider = _getOrCreateProvider(postUri: postUri, postCid: postCid);

     

       75
       75
       +
           _refCounts[postUri] = (_refCounts[postUri] ?? 0) + 1;

     

       76
       76
       +
           return provider;

     

       77
       77
       +
         }

     

       78
       78
       +
       

     

       79
       79
       +
         /// Release a previously acquired provider for a post.

     

       80
       80
       +
         ///

     

       81
       81
       +
         /// Once released, the provider becomes eligible for LRU eviction.

     

       82
       82
       +
         void releaseProvider(String postUri) {

     

       83
       83
       +
           final current = _refCounts[postUri];

     

       84
       84
       +
           if (current == null) {

     

       85
       85
       +
             return;

     

       86
       86
       +
           }

     

       87
       87
       +
       

     

       88
       88
       +
           if (current <= 1) {

     

       89
       89
       +
             _refCounts.remove(postUri);

     

       90
       90
       +
           } else {

     

       91
       91
       +
             _refCounts[postUri] = current - 1;

     

       92
       92
       +
           }

     

       93
       93
       +
       

     

       94
       94
       +
           _evictIfNeeded();

     

       95
       95
       +
         }

     

       96
       96
       +
       

     

       97
       97
       +
         /// Legacy name kept for compatibility: prefer [acquireProvider].

     

       98
       98
       +
         CommentsProvider getProvider({

     

       99
       99
       +
           required String postUri,

     

       100
       100
       +
           required String postCid,

     

       101
       101
       +
         }) => acquireProvider(postUri: postUri, postCid: postCid);

     

       102
       102
       +
       

     

       103
       103
       +
         CommentsProvider _getOrCreateProvider({

     

       104
       104
       +
           required String postUri,

     

       105
       105
       +
           required String postCid,

     

       106
       106
       +
         }) {

     

       107
       107
       +
           // Check if already cached

     

       108
       108
       +
           if (_cache.containsKey(postUri)) {

     

       109
       109
       +
             // Move to end (most recently used)

     

       110
       110
       +
             final provider = _cache.remove(postUri)!;

     

       111
       111
       +
             _cache[postUri] = provider;

     

       112
       112
       +
       

     

       113
       113
       +
             if (kDebugMode) {

     

       114
       114
       +
               debugPrint('📦 Cache hit: $postUri (${_cache.length}/$maxSize)');

     

       115
       115
       +
             }

     

       116
       116
       +
       

     

       117
       117
       +
             return provider;

     

       118
       118
       +
           }

     

       119
       119
       +
       

     

       120
       120
       +
           // Evict unreferenced providers if at capacity.

     

       121
       121
       +
           if (_cache.length >= maxSize) {

     

       122
       122
       +
             _evictIfNeeded(includingOne: true);

     

       123
       123
       +
           }

     

       124
       124
       +
       

     

       125
       125
       +
           // Create new provider

     

       126
       126
       +
           final provider = CommentsProvider(

     

       127
       127
       +
             _authProvider,

     

       128
       128
       +
             voteProvider: _voteProvider,

     

       129
       129
       +
             commentService: _commentService,

     

       130
       130
       +
             postUri: postUri,

     

       131
       131
       +
             postCid: postCid,

     

       132
       132
       +
           );

     

       133
       133
       +
       

     

       134
       134
       +
           _cache[postUri] = provider;

     

       135
       135
       +
       

     

       136
       136
       +
           if (kDebugMode) {

     

       137
       137
       +
             debugPrint('📦 Cache miss: $postUri (${_cache.length}/$maxSize)');

     

       138
       138
       +
             if (_cache.length > maxSize) {

     

       139
       139
       +
               debugPrint(

     

       140
       140
       +
                 '📌 Cache exceeded maxSize because active providers are pinned',

     

       141
       141
       +
               );

     

       142
       142
       +
             }

     

       143
       143
       +
           }

     

       144
       144
       +
       

     

       145
       145
       +
           return provider;

     

       146
       146
       +
         }

     

       147
       147
       +
       

     

       148
       148
       +
         void _evictIfNeeded({bool includingOne = false}) {

     

       149
       149
       +
           final targetSize = includingOne ? maxSize - 1 : maxSize;

     

       150
       150
       +
           while (_cache.length > targetSize) {

     

       151
       151
       +
             String? oldestUnreferencedKey;

     

       152
       152
       +
             for (final key in _cache.keys) {

     

       153
       153
       +
               if ((_refCounts[key] ?? 0) == 0) {

     

       154
       154
       +
                 oldestUnreferencedKey = key;

     

       155
       155
       +
                 break;

     

       156
       156
       +
               }

     

       157
       157
       +
             }

     

       158
       158
       +
       

     

       159
       159
       +
             if (oldestUnreferencedKey == null) {

     

       160
       160
       +
               break;

     

       161
       161
       +
             }

     

       162
       162
       +
       

     

       163
       163
       +
             final evicted = _cache.remove(oldestUnreferencedKey);

     

       164
       164
       +
             evicted?.dispose();

     

       165
       165
       +
       

     

       166
       166
       +
             if (kDebugMode) {

     

       167
       167
       +
               debugPrint('🗑️ Cache evict: $oldestUnreferencedKey');

     

       168
       168
       +
             }

     

       169
       169
       +
           }

     

       170
       170
       +
         }

     

       171
       171
       +
       

     

       172
       172
       +
         /// Check if provider exists without creating

     

       173
       173
       +
         bool hasProvider(String postUri) => _cache.containsKey(postUri);

     

       174
       174
       +
       

     

       175
       175
       +
         /// Get existing provider without creating (for checking state)

     

       176
       176
       +
         CommentsProvider? peekProvider(String postUri) => _cache[postUri];

     

       177
       177
       +
       

     

       178
       178
       +
         /// Remove specific provider (e.g., after post deletion)

     

       179
       179
       +
         void removeProvider(String postUri) {

     

       180
       180
       +
           final provider = _cache.remove(postUri);

     

       181
       181
       +
           _refCounts.remove(postUri);

     

       182
       182
       +
           provider?.dispose();

     

       183
       183
       +
         }

     

       184
       184
       +
       

     

       185
       185
       +
         /// Handle auth state changes - clear all on sign-out

     

       186
       186
       +
         void _onAuthChanged() {

     

       187
       187
       +
           final isAuthenticated = _authProvider.isAuthenticated;

     

       188
       188
       +
       

     

       189
       189
       +
           // Clear all cached providers on sign-out

     

       190
       190
       +
           if (_wasAuthenticated && !isAuthenticated) {

     

       191
       191
       +
             if (kDebugMode) {

     

       192
       192
       +
               debugPrint('🔒 User signed out - clearing ${_cache.length} cached comment providers');

     

       193
       193
       +
             }

     

       194
       194
       +
             clearAll();

     

       195
       195
       +
           }

     

       196
       196
       +
       

     

       197
       197
       +
           _wasAuthenticated = isAuthenticated;

     

       198
       198
       +
         }

     

       199
       199
       +
       

     

       200
       200
       +
         /// Clear all cached providers

     

       201
       201
       +
         void clearAll() {

     

       202
       202
       +
           for (final provider in _cache.values) {

     

       203
       203
       +
             provider.dispose();

     

       204
       204
       +
           }

     

       205
       205
       +
           _cache.clear();

     

       206
       206
       +
           _refCounts.clear();

     

       207
       207
       +
         }

     

       208
       208
       +
       

     

       209
       209
       +
         /// Current cache size

     

       210
       210
       +
         int get size => _cache.length;

     

       211
       211
       +
       

     

       212
       212
       +
         /// Dispose and cleanup

     

       213
       213
       +
         void dispose() {

     

       214
       214
       +
           _authProvider.removeListener(_onAuthChanged);

     

       215
       215
       +
           clearAll();

     

       216
       216
       +
         }

     

       217
       217
       +
       }

+19

test/test_helpers/mock_providers.dart

···

       2
       2
        
       import 'package:coves_flutter/providers/vote_provider.dart';

     

       3
       3
        
       import 'package:flutter/foundation.dart';

     

       4
       4
        
       

     

       5
       5
       +
       /// Mock CommentsProvider for testing

     

       6
       6
       +
       class MockCommentsProvider extends ChangeNotifier {

     

       7
       7
       +
         final String postUri;

     

       8
       8
       +
         final String postCid;

     

       9
       9
       +
       

     

       10
       10
       +
         MockCommentsProvider({

     

       11
       11
       +
           required this.postUri,

     

       12
       12
       +
           required this.postCid,

     

       13
       13
       +
         });

     

       14
       14
       +
       

     

       15
       15
       +
         final ValueNotifier<DateTime?> currentTimeNotifier = ValueNotifier(null);

     

       16
       16
       +
       

     

       17
       17
       +
         @override

     

       18
       18
       +
         void dispose() {

     

       19
       19
       +
           currentTimeNotifier.dispose();

     

       20
       20
       +
           super.dispose();

     

       21
       21
       +
         }

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

       5
       24
        
       /// Mock AuthProvider for testing

     

       6
       25
        
       class MockAuthProvider extends ChangeNotifier {

     

       7
       26
        
         bool _isAuthenticated = false;

+264

lib/models/community.dart

···

       1
       1
       +
       // Community data models for Coves

     

       2
       2
       +
       //

     

       3
       3
       +
       // These models match the backend API structure from:

     

       4
       4
       +
       // GET /xrpc/social.coves.community.list

     

       5
       5
       +
       // POST /xrpc/social.coves.community.post.create

     

       6
       6
       +
       

     

       7
       7
       +
       /// Response from GET /xrpc/social.coves.community.list

     

       8
       8
       +
       class CommunitiesResponse {

     

       9
       9
       +
         CommunitiesResponse({required this.communities, this.cursor});

     

       10
       10
       +
       

     

       11
       11
       +
         factory CommunitiesResponse.fromJson(Map<String, dynamic> json) {

     

       12
       12
       +
           // Handle null communities array from backend

     

       13
       13
       +
           final communitiesData = json['communities'];

     

       14
       14
       +
           final List<CommunityView> communitiesList;

     

       15
       15
       +
       

     

       16
       16
       +
           if (communitiesData == null) {

     

       17
       17
       +
             // Backend returned null, use empty list

     

       18
       18
       +
             communitiesList = [];

     

       19
       19
       +
           } else {

     

       20
       20
       +
             // Parse community items

     

       21
       21
       +
             communitiesList = (communitiesData as List<dynamic>)

     

       22
       22
       +
                 .map(

     

       23
       23
       +
                   (item) => CommunityView.fromJson(item as Map<String, dynamic>),

     

       24
       24
       +
                 )

     

       25
       25
       +
                 .toList();

     

       26
       26
       +
           }

     

       27
       27
       +
       

     

       28
       28
       +
           return CommunitiesResponse(

     

       29
       29
       +
             communities: communitiesList,

     

       30
       30
       +
             cursor: json['cursor'] as String?,

     

       31
       31
       +
           );

     

       32
       32
       +
         }

     

       33
       33
       +
       

     

       34
       34
       +
         final List<CommunityView> communities;

     

       35
       35
       +
         final String? cursor;

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       /// Full community view data

     

       39
       39
       +
       class CommunityView {

     

       40
       40
       +
         CommunityView({

     

       41
       41
       +
           required this.did,

     

       42
       42
       +
           required this.name,

     

       43
       43
       +
           this.handle,

     

       44
       44
       +
           this.displayName,

     

       45
       45
       +
           this.description,

     

       46
       46
       +
           this.avatar,

     

       47
       47
       +
           this.visibility,

     

       48
       48
       +
           this.subscriberCount,

     

       49
       49
       +
           this.memberCount,

     

       50
       50
       +
           this.postCount,

     

       51
       51
       +
           this.viewer,

     

       52
       52
       +
         });

     

       53
       53
       +
       

     

       54
       54
       +
         factory CommunityView.fromJson(Map<String, dynamic> json) {

     

       55
       55
       +
           return CommunityView(

     

       56
       56
       +
             did: json['did'] as String,

     

       57
       57
       +
             name: json['name'] as String,

     

       58
       58
       +
             handle: json['handle'] as String?,

     

       59
       59
       +
             displayName: json['displayName'] as String?,

     

       60
       60
       +
             description: json['description'] as String?,

     

       61
       61
       +
             avatar: json['avatar'] as String?,

     

       62
       62
       +
             visibility: json['visibility'] as String?,

     

       63
       63
       +
             subscriberCount: json['subscriberCount'] as int?,

     

       64
       64
       +
             memberCount: json['memberCount'] as int?,

     

       65
       65
       +
             postCount: json['postCount'] as int?,

     

       66
       66
       +
             viewer: json['viewer'] != null

     

       67
       67
       +
                 ? CommunityViewerState.fromJson(

     

       68
       68
       +
                     json['viewer'] as Map<String, dynamic>,

     

       69
       69
       +
                   )

     

       70
       70
       +
                 : null,

     

       71
       71
       +
           );

     

       72
       72
       +
         }

     

       73
       73
       +
       

     

       74
       74
       +
         /// Community DID (decentralized identifier)

     

       75
       75
       +
         final String did;

     

       76
       76
       +
       

     

       77
       77
       +
         /// Community name (unique identifier)

     

       78
       78
       +
         final String name;

     

       79
       79
       +
       

     

       80
       80
       +
         /// Community handle

     

       81
       81
       +
         final String? handle;

     

       82
       82
       +
       

     

       83
       83
       +
         /// Display name for UI

     

       84
       84
       +
         final String? displayName;

     

       85
       85
       +
       

     

       86
       86
       +
         /// Community description

     

       87
       87
       +
         final String? description;

     

       88
       88
       +
       

     

       89
       89
       +
         /// Avatar URL

     

       90
       90
       +
         final String? avatar;

     

       91
       91
       +
       

     

       92
       92
       +
         /// Visibility setting (e.g., "public", "private")

     

       93
       93
       +
         final String? visibility;

     

       94
       94
       +
       

     

       95
       95
       +
         /// Number of subscribers

     

       96
       96
       +
         final int? subscriberCount;

     

       97
       97
       +
       

     

       98
       98
       +
         /// Number of members

     

       99
       99
       +
         final int? memberCount;

     

       100
       100
       +
       

     

       101
       101
       +
         /// Number of posts

     

       102
       102
       +
         final int? postCount;

     

       103
       103
       +
       

     

       104
       104
       +
         /// Current user's relationship with this community

     

       105
       105
       +
         final CommunityViewerState? viewer;

     

       106
       106
       +
       }

     

       107
       107
       +
       

     

       108
       108
       +
       /// Current user's relationship with a community

     

       109
       109
       +
       class CommunityViewerState {

     

       110
       110
       +
         CommunityViewerState({this.subscribed, this.member});

     

       111
       111
       +
       

     

       112
       112
       +
         factory CommunityViewerState.fromJson(Map<String, dynamic> json) {

     

       113
       113
       +
           return CommunityViewerState(

     

       114
       114
       +
             subscribed: json['subscribed'] as bool?,

     

       115
       115
       +
             member: json['member'] as bool?,

     

       116
       116
       +
           );

     

       117
       117
       +
         }

     

       118
       118
       +
       

     

       119
       119
       +
         /// Whether the user is subscribed to this community

     

       120
       120
       +
         final bool? subscribed;

     

       121
       121
       +
       

     

       122
       122
       +
         /// Whether the user is a member of this community

     

       123
       123
       +
         final bool? member;

     

       124
       124
       +
       }

     

       125
       125
       +
       

     

       126
       126
       +
       /// Request body for POST /xrpc/social.coves.community.post.create

     

       127
       127
       +
       class CreatePostRequest {

     

       128
       128
       +
         CreatePostRequest({

     

       129
       129
       +
           required this.community,

     

       130
       130
       +
           this.title,

     

       131
       131
       +
           this.content,

     

       132
       132
       +
           this.embed,

     

       133
       133
       +
           this.langs,

     

       134
       134
       +
           this.labels,

     

       135
       135
       +
         });

     

       136
       136
       +
       

     

       137
       137
       +
         Map<String, dynamic> toJson() {

     

       138
       138
       +
           final json = <String, dynamic>{

     

       139
       139
       +
             'community': community,

     

       140
       140
       +
           };

     

       141
       141
       +
       

     

       142
       142
       +
           if (title != null) {

     

       143
       143
       +
             json['title'] = title;

     

       144
       144
       +
           }

     

       145
       145
       +
           if (content != null) {

     

       146
       146
       +
             json['content'] = content;

     

       147
       147
       +
           }

     

       148
       148
       +
           if (embed != null) {

     

       149
       149
       +
             json['embed'] = embed!.toJson();

     

       150
       150
       +
           }

     

       151
       151
       +
           if (langs != null && langs!.isNotEmpty) {

     

       152
       152
       +
             json['langs'] = langs;

     

       153
       153
       +
           }

     

       154
       154
       +
           if (labels != null) {

     

       155
       155
       +
             json['labels'] = labels!.toJson();

     

       156
       156
       +
           }

     

       157
       157
       +
       

     

       158
       158
       +
           return json;

     

       159
       159
       +
         }

     

       160
       160
       +
       

     

       161
       161
       +
         /// Community DID or handle

     

       162
       162
       +
         final String community;

     

       163
       163
       +
       

     

       164
       164
       +
         /// Post title

     

       165
       165
       +
         final String? title;

     

       166
       166
       +
       

     

       167
       167
       +
         /// Post content/text

     

       168
       168
       +
         final String? content;

     

       169
       169
       +
       

     

       170
       170
       +
         /// External link embed

     

       171
       171
       +
         final ExternalEmbedInput? embed;

     

       172
       172
       +
       

     

       173
       173
       +
         /// Language codes (e.g., ["en", "es"])

     

       174
       174
       +
         final List<String>? langs;

     

       175
       175
       +
       

     

       176
       176
       +
         /// Self-applied content labels

     

       177
       177
       +
         final SelfLabels? labels;

     

       178
       178
       +
       }

     

       179
       179
       +
       

     

       180
       180
       +
       /// Response from POST /xrpc/social.coves.community.post.create

     

       181
       181
       +
       class CreatePostResponse {

     

       182
       182
       +
         const CreatePostResponse({required this.uri, required this.cid});

     

       183
       183
       +
       

     

       184
       184
       +
         factory CreatePostResponse.fromJson(Map<String, dynamic> json) {

     

       185
       185
       +
           return CreatePostResponse(

     

       186
       186
       +
             uri: json['uri'] as String,

     

       187
       187
       +
             cid: json['cid'] as String,

     

       188
       188
       +
           );

     

       189
       189
       +
         }

     

       190
       190
       +
       

     

       191
       191
       +
         /// AT-URI of the created post

     

       192
       192
       +
         final String uri;

     

       193
       193
       +
       

     

       194
       194
       +
         /// Content identifier (CID) of the created post

     

       195
       195
       +
         final String cid;

     

       196
       196
       +
       }

     

       197
       197
       +
       

     

       198
       198
       +
       /// External link embed input for creating posts

     

       199
       199
       +
       class ExternalEmbedInput {

     

       200
       200
       +
         const ExternalEmbedInput({

     

       201
       201
       +
           required this.uri,

     

       202
       202
       +
           this.title,

     

       203
       203
       +
           this.description,

     

       204
       204
       +
           this.thumb,

     

       205
       205
       +
         });

     

       206
       206
       +
       

     

       207
       207
       +
         Map<String, dynamic> toJson() {

     

       208
       208
       +
           final json = <String, dynamic>{

     

       209
       209
       +
             'uri': uri,

     

       210
       210
       +
           };

     

       211
       211
       +
       

     

       212
       212
       +
           if (title != null) {

     

       213
       213
       +
             json['title'] = title;

     

       214
       214
       +
           }

     

       215
       215
       +
           if (description != null) {

     

       216
       216
       +
             json['description'] = description;

     

       217
       217
       +
           }

     

       218
       218
       +
           if (thumb != null) {

     

       219
       219
       +
             json['thumb'] = thumb;

     

       220
       220
       +
           }

     

       221
       221
       +
       

     

       222
       222
       +
           return json;

     

       223
       223
       +
         }

     

       224
       224
       +
       

     

       225
       225
       +
         /// URL of the external link

     

       226
       226
       +
         final String uri;

     

       227
       227
       +
       

     

       228
       228
       +
         /// Title of the linked content

     

       229
       229
       +
         final String? title;

     

       230
       230
       +
       

     

       231
       231
       +
         /// Description of the linked content

     

       232
       232
       +
         final String? description;

     

       233
       233
       +
       

     

       234
       234
       +
         /// Thumbnail URL

     

       235
       235
       +
         final String? thumb;

     

       236
       236
       +
       }

     

       237
       237
       +
       

     

       238
       238
       +
       /// Self-applied content labels

     

       239
       239
       +
       class SelfLabels {

     

       240
       240
       +
         const SelfLabels({required this.values});

     

       241
       241
       +
       

     

       242
       242
       +
         Map<String, dynamic> toJson() {

     

       243
       243
       +
           return {

     

       244
       244
       +
             'values': values.map((label) => label.toJson()).toList(),

     

       245
       245
       +
           };

     

       246
       246
       +
         }

     

       247
       247
       +
       

     

       248
       248
       +
         /// List of self-applied labels

     

       249
       249
       +
         final List<SelfLabel> values;

     

       250
       250
       +
       }

     

       251
       251
       +
       

     

       252
       252
       +
       /// Individual self-applied label

     

       253
       253
       +
       class SelfLabel {

     

       254
       254
       +
         const SelfLabel({required this.val});

     

       255
       255
       +
       

     

       256
       256
       +
         Map<String, dynamic> toJson() {

     

       257
       257
       +
           return {

     

       258
       258
       +
             'val': val,

     

       259
       259
       +
           };

     

       260
       260
       +
         }

     

       261
       261
       +
       

     

       262
       262
       +
         /// Label value (e.g., "nsfw", "spoiler")

     

       263
       263
       +
         final String val;

     

       264
       264
       +
       }

+126

lib/services/coves_api_service.dart

···

       3
       3
        
       

     

       4
       4
        
       import '../config/environment_config.dart';

     

       5
       5
        
       import '../models/comment.dart';

     

       6
       6
       +
       import '../models/community.dart';

     

       6
       7
        
       import '../models/post.dart';

     

       7
       8
        
       import 'api_exceptions.dart';

     

       8
       9
        
       

     
···

       358
       359
        
           }

     

       359
       360
        
         }

     

       360
       361
        
       

     

       362
       362
       +
         /// List communities with optional filtering

     

       363
       363
       +
         ///

     

       364
       364
       +
         /// Fetches a list of communities with pagination support.

     

       365
       365
       +
         /// Requires authentication.

     

       366
       366
       +
         ///

     

       367
       367
       +
         /// Parameters:

     

       368
       368
       +
         /// - [limit]: Number of communities per page (default: 50, max: 100)

     

       369
       369
       +
         /// - [cursor]: Pagination cursor from previous response

     

       370
       370
       +
         /// - [sort]: Sort order - 'popular', 'new', or 'alphabetical' (default: 'popular')

     

       371
       371
       +
         Future<CommunitiesResponse> listCommunities({

     

       372
       372
       +
           int limit = 50,

     

       373
       373
       +
           String? cursor,

     

       374
       374
       +
           String sort = 'popular',

     

       375
       375
       +
         }) async {

     

       376
       376
       +
           try {

     

       377
       377
       +
             if (kDebugMode) {

     

       378
       378
       +
               debugPrint('📡 Fetching communities: sort=$sort, limit=$limit');

     

       379
       379
       +
             }

     

       380
       380
       +
       

     

       381
       381
       +
             final queryParams = <String, dynamic>{

     

       382
       382
       +
               'limit': limit,

     

       383
       383
       +
               'sort': sort,

     

       384
       384
       +
             };

     

       385
       385
       +
       

     

       386
       386
       +
             if (cursor != null) {

     

       387
       387
       +
               queryParams['cursor'] = cursor;

     

       388
       388
       +
             }

     

       389
       389
       +
       

     

       390
       390
       +
             final response = await _dio.get(

     

       391
       391
       +
               '/xrpc/social.coves.community.list',

     

       392
       392
       +
               queryParameters: queryParams,

     

       393
       393
       +
             );

     

       394
       394
       +
       

     

       395
       395
       +
             if (kDebugMode) {

     

       396
       396
       +
               debugPrint(

     

       397
       397
       +
                 '✅ Communities fetched: '

     

       398
       398
       +
                 '${response.data['communities']?.length ?? 0} communities',

     

       399
       399
       +
               );

     

       400
       400
       +
             }

     

       401
       401
       +
       

     

       402
       402
       +
             return CommunitiesResponse.fromJson(

     

       403
       403
       +
               response.data as Map<String, dynamic>,

     

       404
       404
       +
             );

     

       405
       405
       +
           } on DioException catch (e) {

     

       406
       406
       +
             _handleDioException(e, 'communities');

     

       407
       407
       +
           } catch (e) {

     

       408
       408
       +
             if (kDebugMode) {

     

       409
       409
       +
               debugPrint('❌ Error parsing communities response: $e');

     

       410
       410
       +
             }

     

       411
       411
       +
             throw ApiException('Failed to parse server response', originalError: e);

     

       412
       412
       +
           }

     

       413
       413
       +
         }

     

       414
       414
       +
       

     

       415
       415
       +
         /// Create a new post in a community

     

       416
       416
       +
         ///

     

       417
       417
       +
         /// Creates a new post with optional title, content, and embed.

     

       418
       418
       +
         /// Requires authentication.

     

       419
       419
       +
         ///

     

       420
       420
       +
         /// Parameters:

     

       421
       421
       +
         /// - [community]: Community identifier (required)

     

       422
       422
       +
         /// - [title]: Post title (optional)

     

       423
       423
       +
         /// - [content]: Post content (optional)

     

       424
       424
       +
         /// - [embed]: External embed (link, image, etc.) (optional)

     

       425
       425
       +
         /// - [langs]: Language codes for the post (optional)

     

       426
       426
       +
         /// - [labels]: Self-applied content labels (optional)

     

       427
       427
       +
         Future<CreatePostResponse> createPost({

     

       428
       428
       +
           required String community,

     

       429
       429
       +
           String? title,

     

       430
       430
       +
           String? content,

     

       431
       431
       +
           ExternalEmbedInput? embed,

     

       432
       432
       +
           List<String>? langs,

     

       433
       433
       +
           SelfLabels? labels,

     

       434
       434
       +
         }) async {

     

       435
       435
       +
           try {

     

       436
       436
       +
             if (kDebugMode) {

     

       437
       437
       +
               debugPrint('📡 Creating post in community: $community');

     

       438
       438
       +
             }

     

       439
       439
       +
       

     

       440
       440
       +
             // Build request body with only non-null fields

     

       441
       441
       +
             final requestBody = <String, dynamic>{

     

       442
       442
       +
               'community': community,

     

       443
       443
       +
             };

     

       444
       444
       +
       

     

       445
       445
       +
             if (title != null) {

     

       446
       446
       +
               requestBody['title'] = title;

     

       447
       447
       +
             }

     

       448
       448
       +
       

     

       449
       449
       +
             if (content != null) {

     

       450
       450
       +
               requestBody['content'] = content;

     

       451
       451
       +
             }

     

       452
       452
       +
       

     

       453
       453
       +
             if (embed != null) {

     

       454
       454
       +
               requestBody['embed'] = embed.toJson();

     

       455
       455
       +
             }

     

       456
       456
       +
       

     

       457
       457
       +
             if (langs != null && langs.isNotEmpty) {

     

       458
       458
       +
               requestBody['langs'] = langs;

     

       459
       459
       +
             }

     

       460
       460
       +
       

     

       461
       461
       +
             if (labels != null) {

     

       462
       462
       +
               requestBody['labels'] = labels.toJson();

     

       463
       463
       +
             }

     

       464
       464
       +
       

     

       465
       465
       +
             final response = await _dio.post(

     

       466
       466
       +
               '/xrpc/social.coves.community.post.create',

     

       467
       467
       +
               data: requestBody,

     

       468
       468
       +
             );

     

       469
       469
       +
       

     

       470
       470
       +
             if (kDebugMode) {

     

       471
       471
       +
               debugPrint('✅ Post created successfully');

     

       472
       472
       +
             }

     

       473
       473
       +
       

     

       474
       474
       +
             return CreatePostResponse.fromJson(

     

       475
       475
       +
               response.data as Map<String, dynamic>,

     

       476
       476
       +
             );

     

       477
       477
       +
           } on DioException catch (e) {

     

       478
       478
       +
             _handleDioException(e, 'create post');

     

       479
       479
       +
           } catch (e) {

     

       480
       480
       +
             if (kDebugMode) {

     

       481
       481
       +
               debugPrint('❌ Error creating post: $e');

     

       482
       482
       +
             }

     

       483
       483
       +
             throw ApiException('Failed to create post', originalError: e);

     

       484
       484
       +
           }

     

       485
       485
       +
         }

     

       486
       486
       +
       

     

       361
       487
        
         /// Handle Dio exceptions with specific error types

     

       362
       488
        
         ///

     

       363
       489
        
         /// Converts generic DioException into specific typed exceptions

+518

lib/screens/compose/community_picker_screen.dart

···

       1
       1
       +
       import 'dart:async';

     

       2
       2
       +
       

     

       3
       3
       +
       import 'package:cached_network_image/cached_network_image.dart';

     

       4
       4
       +
       import 'package:flutter/material.dart';

     

       5
       5
       +
       import 'package:provider/provider.dart';

     

       6
       6
       +
       

     

       7
       7
       +
       import '../../constants/app_colors.dart';

     

       8
       8
       +
       import '../../models/community.dart';

     

       9
       9
       +
       import '../../providers/auth_provider.dart';

     

       10
       10
       +
       import '../../services/api_exceptions.dart';

     

       11
       11
       +
       import '../../services/coves_api_service.dart';

     

       12
       12
       +
       

     

       13
       13
       +
       /// Community Picker Screen

     

       14
       14
       +
       ///

     

       15
       15
       +
       /// Full-screen interface for selecting a community when creating a post.

     

       16
       16
       +
       ///

     

       17
       17
       +
       /// Features:

     

       18
       18
       +
       /// - Search bar with 300ms debounce for client-side filtering

     

       19
       19
       +
       /// - Scroll pagination - loads more communities when near bottom

     

       20
       20
       +
       /// - Loading, error, and empty states

     

       21
       21
       +
       /// - Returns selected community on tap via Navigator.pop

     

       22
       22
       +
       ///

     

       23
       23
       +
       /// Design:

     

       24
       24
       +
       /// - Header: "Post to" with X close button

     

       25
       25
       +
       /// - Search bar: "Search for a community" with search icon

     

       26
       26
       +
       /// - List of communities showing:

     

       27
       27
       +
       ///   - Avatar (CircleAvatar with first letter fallback)

     

       28
       28
       +
       ///   - Community name (bold)

     

       29
       29
       +
       ///   - Member count + optional description

     

       30
       30
       +
       class CommunityPickerScreen extends StatefulWidget {

     

       31
       31
       +
         const CommunityPickerScreen({super.key});

     

       32
       32
       +
       

     

       33
       33
       +
         @override

     

       34
       34
       +
         State<CommunityPickerScreen> createState() => _CommunityPickerScreenState();

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       class _CommunityPickerScreenState extends State<CommunityPickerScreen> {

     

       38
       38
       +
         final TextEditingController _searchController = TextEditingController();

     

       39
       39
       +
         final ScrollController _scrollController = ScrollController();

     

       40
       40
       +
       

     

       41
       41
       +
         List<CommunityView> _communities = [];

     

       42
       42
       +
         List<CommunityView> _filteredCommunities = [];

     

       43
       43
       +
         bool _isLoading = false;

     

       44
       44
       +
         bool _isLoadingMore = false;

     

       45
       45
       +
         String? _error;

     

       46
       46
       +
         String? _cursor;

     

       47
       47
       +
         bool _hasMore = true;

     

       48
       48
       +
         Timer? _searchDebounce;

     

       49
       49
       +
         CovesApiService? _apiService;

     

       50
       50
       +
       

     

       51
       51
       +
         @override

     

       52
       52
       +
         void initState() {

     

       53
       53
       +
           super.initState();

     

       54
       54
       +
           _searchController.addListener(_onSearchChanged);

     

       55
       55
       +
           _scrollController.addListener(_onScroll);

     

       56
       56
       +
           // Defer API initialization to first frame to access context

     

       57
       57
       +
           WidgetsBinding.instance.addPostFrameCallback((_) {

     

       58
       58
       +
             _initApiService();

     

       59
       59
       +
             _loadCommunities();

     

       60
       60
       +
           });

     

       61
       61
       +
         }

     

       62
       62
       +
       

     

       63
       63
       +
         void _initApiService() {

     

       64
       64
       +
           final authProvider = context.read<AuthProvider>();

     

       65
       65
       +
           _apiService = CovesApiService(

     

       66
       66
       +
             tokenGetter: authProvider.getAccessToken,

     

       67
       67
       +
             tokenRefresher: authProvider.refreshToken,

     

       68
       68
       +
             signOutHandler: authProvider.signOut,

     

       69
       69
       +
           );

     

       70
       70
       +
         }

     

       71
       71
       +
       

     

       72
       72
       +
         @override

     

       73
       73
       +
         void dispose() {

     

       74
       74
       +
           _searchController.dispose();

     

       75
       75
       +
           _scrollController.dispose();

     

       76
       76
       +
           _searchDebounce?.cancel();

     

       77
       77
       +
           _apiService?.dispose();

     

       78
       78
       +
           super.dispose();

     

       79
       79
       +
         }

     

       80
       80
       +
       

     

       81
       81
       +
         void _onSearchChanged() {

     

       82
       82
       +
           // Cancel previous debounce timer

     

       83
       83
       +
           _searchDebounce?.cancel();

     

       84
       84
       +
       

     

       85
       85
       +
           // Start new debounce timer (300ms)

     

       86
       86
       +
           _searchDebounce = Timer(const Duration(milliseconds: 300), _filterCommunities);

     

       87
       87
       +
         }

     

       88
       88
       +
       

     

       89
       89
       +
         void _filterCommunities() {

     

       90
       90
       +
           final query = _searchController.text.trim().toLowerCase();

     

       91
       91
       +
       

     

       92
       92
       +
           if (query.isEmpty) {

     

       93
       93
       +
             setState(() {

     

       94
       94
       +
               _filteredCommunities = _communities;

     

       95
       95
       +
             });

     

       96
       96
       +
             return;

     

       97
       97
       +
           }

     

       98
       98
       +
       

     

       99
       99
       +
           setState(() {

     

       100
       100
       +
             _filteredCommunities = _communities.where((community) {

     

       101
       101
       +
               final name = community.name.toLowerCase();

     

       102
       102
       +
               final displayName = community.displayName?.toLowerCase() ?? '';

     

       103
       103
       +
               final description = community.description?.toLowerCase() ?? '';

     

       104
       104
       +
       

     

       105
       105
       +
               return name.contains(query) ||

     

       106
       106
       +
                   displayName.contains(query) ||

     

       107
       107
       +
                   description.contains(query);

     

       108
       108
       +
             }).toList();

     

       109
       109
       +
           });

     

       110
       110
       +
         }

     

       111
       111
       +
       

     

       112
       112
       +
         void _onScroll() {

     

       113
       113
       +
           // Load more when near bottom (80% scrolled)

     

       114
       114
       +
           if (_scrollController.position.pixels >=

     

       115
       115
       +
               _scrollController.position.maxScrollExtent * 0.8) {

     

       116
       116
       +
             if (!_isLoadingMore && _hasMore && !_isLoading) {

     

       117
       117
       +
               _loadMoreCommunities();

     

       118
       118
       +
             }

     

       119
       119
       +
           }

     

       120
       120
       +
         }

     

       121
       121
       +
       

     

       122
       122
       +
         Future<void> _loadCommunities() async {

     

       123
       123
       +
           if (_isLoading || _apiService == null) {

     

       124
       124
       +
             return;

     

       125
       125
       +
           }

     

       126
       126
       +
       

     

       127
       127
       +
           setState(() {

     

       128
       128
       +
             _isLoading = true;

     

       129
       129
       +
             _error = null;

     

       130
       130
       +
           });

     

       131
       131
       +
       

     

       132
       132
       +
           try {

     

       133
       133
       +
             final response = await _apiService!.listCommunities(

     

       134
       134
       +
               limit: 50,

     

       135
       135
       +
             );

     

       136
       136
       +
       

     

       137
       137
       +
             if (mounted) {

     

       138
       138
       +
               setState(() {

     

       139
       139
       +
                 _communities = response.communities;

     

       140
       140
       +
                 _filteredCommunities = response.communities;

     

       141
       141
       +
                 _cursor = response.cursor;

     

       142
       142
       +
                 _hasMore = response.cursor != null && response.cursor!.isNotEmpty;

     

       143
       143
       +
                 _isLoading = false;

     

       144
       144
       +
               });

     

       145
       145
       +
             }

     

       146
       146
       +
           } on ApiException catch (e) {

     

       147
       147
       +
             if (mounted) {

     

       148
       148
       +
               setState(() {

     

       149
       149
       +
                 _error = e.message;

     

       150
       150
       +
                 _isLoading = false;

     

       151
       151
       +
               });

     

       152
       152
       +
             }

     

       153
       153
       +
           } on Exception catch (e) {

     

       154
       154
       +
             if (mounted) {

     

       155
       155
       +
               setState(() {

     

       156
       156
       +
                 _error = 'Failed to load communities: ${e.toString()}';

     

       157
       157
       +
                 _isLoading = false;

     

       158
       158
       +
               });

     

       159
       159
       +
             }

     

       160
       160
       +
           }

     

       161
       161
       +
         }

     

       162
       162
       +
       

     

       163
       163
       +
         Future<void> _loadMoreCommunities() async {

     

       164
       164
       +
           if (_isLoadingMore || !_hasMore || _cursor == null || _apiService == null) {

     

       165
       165
       +
             return;

     

       166
       166
       +
           }

     

       167
       167
       +
       

     

       168
       168
       +
           setState(() {

     

       169
       169
       +
             _isLoadingMore = true;

     

       170
       170
       +
           });

     

       171
       171
       +
       

     

       172
       172
       +
           try {

     

       173
       173
       +
             final response = await _apiService!.listCommunities(

     

       174
       174
       +
               limit: 50,

     

       175
       175
       +
               cursor: _cursor,

     

       176
       176
       +
             );

     

       177
       177
       +
       

     

       178
       178
       +
             if (mounted) {

     

       179
       179
       +
               setState(() {

     

       180
       180
       +
                 _communities.addAll(response.communities);

     

       181
       181
       +
                 _cursor = response.cursor;

     

       182
       182
       +
                 _hasMore = response.cursor != null && response.cursor!.isNotEmpty;

     

       183
       183
       +
                 _isLoadingMore = false;

     

       184
       184
       +
       

     

       185
       185
       +
                 // Re-apply search filter if active

     

       186
       186
       +
                 _filterCommunities();

     

       187
       187
       +
               });

     

       188
       188
       +
             }

     

       189
       189
       +
           } on ApiException catch (e) {

     

       190
       190
       +
             if (mounted) {

     

       191
       191
       +
               setState(() {

     

       192
       192
       +
                 _error = e.message;

     

       193
       193
       +
                 _isLoadingMore = false;

     

       194
       194
       +
               });

     

       195
       195
       +
             }

     

       196
       196
       +
           } on Exception {

     

       197
       197
       +
             if (mounted) {

     

       198
       198
       +
               setState(() {

     

       199
       199
       +
                 _isLoadingMore = false;

     

       200
       200
       +
               });

     

       201
       201
       +
             }

     

       202
       202
       +
           }

     

       203
       203
       +
         }

     

       204
       204
       +
       

     

       205
       205
       +
         void _onCommunityTap(CommunityView community) {

     

       206
       206
       +
           Navigator.pop(context, community);

     

       207
       207
       +
         }

     

       208
       208
       +
       

     

       209
       209
       +
         @override

     

       210
       210
       +
         Widget build(BuildContext context) {

     

       211
       211
       +
           return Scaffold(

     

       212
       212
       +
             backgroundColor: AppColors.background,

     

       213
       213
       +
             appBar: AppBar(

     

       214
       214
       +
               backgroundColor: AppColors.background,

     

       215
       215
       +
               foregroundColor: Colors.white,

     

       216
       216
       +
               title: const Text('Post to'),

     

       217
       217
       +
               elevation: 0,

     

       218
       218
       +
               leading: IconButton(

     

       219
       219
       +
                 icon: const Icon(Icons.close),

     

       220
       220
       +
                 onPressed: () => Navigator.pop(context),

     

       221
       221
       +
               ),

     

       222
       222
       +
             ),

     

       223
       223
       +
             body: SafeArea(

     

       224
       224
       +
               child: Column(

     

       225
       225
       +
                 children: [

     

       226
       226
       +
                   // Search bar

     

       227
       227
       +
                   Padding(

     

       228
       228
       +
                     padding: const EdgeInsets.all(16),

     

       229
       229
       +
                     child: TextField(

     

       230
       230
       +
                       controller: _searchController,

     

       231
       231
       +
                       style: const TextStyle(color: Colors.white),

     

       232
       232
       +
                       decoration: InputDecoration(

     

       233
       233
       +
                         hintText: 'Search for a community',

     

       234
       234
       +
                         hintStyle: const TextStyle(color: Color(0xFF5A6B7F)),

     

       235
       235
       +
                         filled: true,

     

       236
       236
       +
                         fillColor: const Color(0xFF1A2028),

     

       237
       237
       +
                         border: OutlineInputBorder(

     

       238
       238
       +
                           borderRadius: BorderRadius.circular(12),

     

       239
       239
       +
                           borderSide: BorderSide.none,

     

       240
       240
       +
                         ),

     

       241
       241
       +
                         enabledBorder: OutlineInputBorder(

     

       242
       242
       +
                           borderRadius: BorderRadius.circular(12),

     

       243
       243
       +
                           borderSide: BorderSide.none,

     

       244
       244
       +
                         ),

     

       245
       245
       +
                         focusedBorder: OutlineInputBorder(

     

       246
       246
       +
                           borderRadius: BorderRadius.circular(12),

     

       247
       247
       +
                           borderSide: const BorderSide(

     

       248
       248
       +
                             color: AppColors.primary,

     

       249
       249
       +
                             width: 2,

     

       250
       250
       +
                           ),

     

       251
       251
       +
                         ),

     

       252
       252
       +
                         prefixIcon: const Icon(

     

       253
       253
       +
                           Icons.search,

     

       254
       254
       +
                           color: Color(0xFF5A6B7F),

     

       255
       255
       +
                         ),

     

       256
       256
       +
                         contentPadding: const EdgeInsets.symmetric(

     

       257
       257
       +
                           horizontal: 16,

     

       258
       258
       +
                           vertical: 12,

     

       259
       259
       +
                         ),

     

       260
       260
       +
                       ),

     

       261
       261
       +
                     ),

     

       262
       262
       +
                   ),

     

       263
       263
       +
       

     

       264
       264
       +
                   // Community list

     

       265
       265
       +
                   Expanded(

     

       266
       266
       +
                     child: _buildBody(),

     

       267
       267
       +
                   ),

     

       268
       268
       +
                 ],

     

       269
       269
       +
               ),

     

       270
       270
       +
             ),

     

       271
       271
       +
           );

     

       272
       272
       +
         }

     

       273
       273
       +
       

     

       274
       274
       +
         Widget _buildBody() {

     

       275
       275
       +
           // Loading state (initial load)

     

       276
       276
       +
           if (_isLoading) {

     

       277
       277
       +
             return const Center(

     

       278
       278
       +
               child: CircularProgressIndicator(

     

       279
       279
       +
                 color: AppColors.primary,

     

       280
       280
       +
               ),

     

       281
       281
       +
             );

     

       282
       282
       +
           }

     

       283
       283
       +
       

     

       284
       284
       +
           // Error state

     

       285
       285
       +
           if (_error != null) {

     

       286
       286
       +
             return Center(

     

       287
       287
       +
               child: Padding(

     

       288
       288
       +
                 padding: const EdgeInsets.all(24),

     

       289
       289
       +
                 child: Column(

     

       290
       290
       +
                   mainAxisAlignment: MainAxisAlignment.center,

     

       291
       291
       +
                   children: [

     

       292
       292
       +
                     const Icon(

     

       293
       293
       +
                       Icons.error_outline,

     

       294
       294
       +
                       size: 48,

     

       295
       295
       +
                       color: Color(0xFF5A6B7F),

     

       296
       296
       +
                     ),

     

       297
       297
       +
                     const SizedBox(height: 16),

     

       298
       298
       +
                     Text(

     

       299
       299
       +
                       _error!,

     

       300
       300
       +
                       style: const TextStyle(

     

       301
       301
       +
                         color: Color(0xFFB6C2D2),

     

       302
       302
       +
                         fontSize: 16,

     

       303
       303
       +
                       ),

     

       304
       304
       +
                       textAlign: TextAlign.center,

     

       305
       305
       +
                     ),

     

       306
       306
       +
                     const SizedBox(height: 24),

     

       307
       307
       +
                     ElevatedButton(

     

       308
       308
       +
                       onPressed: _loadCommunities,

     

       309
       309
       +
                       style: ElevatedButton.styleFrom(

     

       310
       310
       +
                         backgroundColor: AppColors.primary,

     

       311
       311
       +
                         foregroundColor: Colors.white,

     

       312
       312
       +
                         padding: const EdgeInsets.symmetric(

     

       313
       313
       +
                           horizontal: 24,

     

       314
       314
       +
                           vertical: 12,

     

       315
       315
       +
                         ),

     

       316
       316
       +
                         shape: RoundedRectangleBorder(

     

       317
       317
       +
                           borderRadius: BorderRadius.circular(8),

     

       318
       318
       +
                         ),

     

       319
       319
       +
                       ),

     

       320
       320
       +
                       child: const Text('Retry'),

     

       321
       321
       +
                     ),

     

       322
       322
       +
                   ],

     

       323
       323
       +
                 ),

     

       324
       324
       +
               ),

     

       325
       325
       +
             );

     

       326
       326
       +
           }

     

       327
       327
       +
       

     

       328
       328
       +
           // Empty state

     

       329
       329
       +
           if (_filteredCommunities.isEmpty) {

     

       330
       330
       +
             return Center(

     

       331
       331
       +
               child: Padding(

     

       332
       332
       +
                 padding: const EdgeInsets.all(24),

     

       333
       333
       +
                 child: Column(

     

       334
       334
       +
                   mainAxisAlignment: MainAxisAlignment.center,

     

       335
       335
       +
                   children: [

     

       336
       336
       +
                     const Icon(

     

       337
       337
       +
                       Icons.search_off,

     

       338
       338
       +
                       size: 48,

     

       339
       339
       +
                       color: Color(0xFF5A6B7F),

     

       340
       340
       +
                     ),

     

       341
       341
       +
                     const SizedBox(height: 16),

     

       342
       342
       +
                     Text(

     

       343
       343
       +
                       _searchController.text.trim().isEmpty

     

       344
       344
       +
                           ? 'No communities found'

     

       345
       345
       +
                           : 'No communities match your search',

     

       346
       346
       +
                       style: const TextStyle(

     

       347
       347
       +
                         color: Color(0xFFB6C2D2),

     

       348
       348
       +
                         fontSize: 16,

     

       349
       349
       +
                       ),

     

       350
       350
       +
                       textAlign: TextAlign.center,

     

       351
       351
       +
                     ),

     

       352
       352
       +
                   ],

     

       353
       353
       +
                 ),

     

       354
       354
       +
               ),

     

       355
       355
       +
             );

     

       356
       356
       +
           }

     

       357
       357
       +
       

     

       358
       358
       +
           // Community list

     

       359
       359
       +
           return ListView.builder(

     

       360
       360
       +
             controller: _scrollController,

     

       361
       361
       +
             itemCount: _filteredCommunities.length + (_isLoadingMore ? 1 : 0),

     

       362
       362
       +
             itemBuilder: (context, index) {

     

       363
       363
       +
               // Loading indicator at bottom

     

       364
       364
       +
               if (index == _filteredCommunities.length) {

     

       365
       365
       +
                 return const Padding(

     

       366
       366
       +
                   padding: EdgeInsets.all(16),

     

       367
       367
       +
                   child: Center(

     

       368
       368
       +
                     child: CircularProgressIndicator(

     

       369
       369
       +
                       color: AppColors.primary,

     

       370
       370
       +
                     ),

     

       371
       371
       +
                   ),

     

       372
       372
       +
                 );

     

       373
       373
       +
               }

     

       374
       374
       +
       

     

       375
       375
       +
               final community = _filteredCommunities[index];

     

       376
       376
       +
               return _buildCommunityTile(community);

     

       377
       377
       +
             },

     

       378
       378
       +
           );

     

       379
       379
       +
         }

     

       380
       380
       +
       

     

       381
       381
       +
         Widget _buildCommunityAvatar(CommunityView community) {

     

       382
       382
       +
           final fallbackChild = CircleAvatar(

     

       383
       383
       +
             radius: 20,

     

       384
       384
       +
             backgroundColor: AppColors.backgroundSecondary,

     

       385
       385
       +
             foregroundColor: Colors.white,

     

       386
       386
       +
             child: Text(

     

       387
       387
       +
               community.name.isNotEmpty ? community.name[0].toUpperCase() : '?',

     

       388
       388
       +
               style: const TextStyle(

     

       389
       389
       +
                 fontSize: 16,

     

       390
       390
       +
                 fontWeight: FontWeight.bold,

     

       391
       391
       +
               ),

     

       392
       392
       +
             ),

     

       393
       393
       +
           );

     

       394
       394
       +
       

     

       395
       395
       +
           if (community.avatar == null) {

     

       396
       396
       +
             return fallbackChild;

     

       397
       397
       +
           }

     

       398
       398
       +
       

     

       399
       399
       +
           return CachedNetworkImage(

     

       400
       400
       +
             imageUrl: community.avatar!,

     

       401
       401
       +
             imageBuilder: (context, imageProvider) => CircleAvatar(

     

       402
       402
       +
               radius: 20,

     

       403
       403
       +
               backgroundColor: AppColors.backgroundSecondary,

     

       404
       404
       +
               backgroundImage: imageProvider,

     

       405
       405
       +
             ),

     

       406
       406
       +
             placeholder: (context, url) => CircleAvatar(

     

       407
       407
       +
               radius: 20,

     

       408
       408
       +
               backgroundColor: AppColors.backgroundSecondary,

     

       409
       409
       +
               child: const SizedBox(

     

       410
       410
       +
                 width: 16,

     

       411
       411
       +
                 height: 16,

     

       412
       412
       +
                 child: CircularProgressIndicator(

     

       413
       413
       +
                   strokeWidth: 2,

     

       414
       414
       +
                   color: AppColors.primary,

     

       415
       415
       +
                 ),

     

       416
       416
       +
               ),

     

       417
       417
       +
             ),

     

       418
       418
       +
             errorWidget: (context, url, error) => fallbackChild,

     

       419
       419
       +
           );

     

       420
       420
       +
         }

     

       421
       421
       +
       

     

       422
       422
       +
         Widget _buildCommunityTile(CommunityView community) {

     

       423
       423
       +
           // Format member count

     

       424
       424
       +
           String formatCount(int? count) {

     

       425
       425
       +
             if (count == null) {

     

       426
       426
       +
               return '0';

     

       427
       427
       +
             }

     

       428
       428
       +
             if (count >= 1000000) {

     

       429
       429
       +
               return '${(count / 1000000).toStringAsFixed(1)}M';

     

       430
       430
       +
             } else if (count >= 1000) {

     

       431
       431
       +
               return '${(count / 1000).toStringAsFixed(1)}K';

     

       432
       432
       +
             }

     

       433
       433
       +
             return count.toString();

     

       434
       434
       +
           }

     

       435
       435
       +
       

     

       436
       436
       +
           final memberCount = formatCount(community.memberCount);

     

       437
       437
       +
           final subscriberCount = formatCount(community.subscriberCount);

     

       438
       438
       +
       

     

       439
       439
       +
           // Build description line

     

       440
       440
       +
           var descriptionLine = '';

     

       441
       441
       +
           if (community.memberCount != null && community.memberCount! > 0) {

     

       442
       442
       +
             descriptionLine = '$memberCount members';

     

       443
       443
       +
             if (community.subscriberCount != null &&

     

       444
       444
       +
                 community.subscriberCount! > 0) {

     

       445
       445
       +
               descriptionLine += ' · $subscriberCount subscribers';

     

       446
       446
       +
             }

     

       447
       447
       +
           } else if (community.subscriberCount != null &&

     

       448
       448
       +
               community.subscriberCount! > 0) {

     

       449
       449
       +
             descriptionLine = '$subscriberCount subscribers';

     

       450
       450
       +
           }

     

       451
       451
       +
       

     

       452
       452
       +
           if (community.description != null && community.description!.isNotEmpty) {

     

       453
       453
       +
             if (descriptionLine.isNotEmpty) {

     

       454
       454
       +
               descriptionLine += ' · ';

     

       455
       455
       +
             }

     

       456
       456
       +
             descriptionLine += community.description!;

     

       457
       457
       +
           }

     

       458
       458
       +
       

     

       459
       459
       +
           return Material(

     

       460
       460
       +
             color: Colors.transparent,

     

       461
       461
       +
             child: InkWell(

     

       462
       462
       +
               onTap: () => _onCommunityTap(community),

     

       463
       463
       +
               child: Container(

     

       464
       464
       +
                 padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),

     

       465
       465
       +
                 decoration: const BoxDecoration(

     

       466
       466
       +
                   border: Border(

     

       467
       467
       +
                     bottom: BorderSide(

     

       468
       468
       +
                       color: Color(0xFF2A3441),

     

       469
       469
       +
                       width: 1,

     

       470
       470
       +
                     ),

     

       471
       471
       +
                   ),

     

       472
       472
       +
                 ),

     

       473
       473
       +
                 child: Row(

     

       474
       474
       +
                   children: [

     

       475
       475
       +
                     // Avatar

     

       476
       476
       +
                     _buildCommunityAvatar(community),

     

       477
       477
       +
                     const SizedBox(width: 12),

     

       478
       478
       +
       

     

       479
       479
       +
                     // Community info

     

       480
       480
       +
                     Expanded(

     

       481
       481
       +
                       child: Column(

     

       482
       482
       +
                         crossAxisAlignment: CrossAxisAlignment.start,

     

       483
       483
       +
                         children: [

     

       484
       484
       +
                           // Community name

     

       485
       485
       +
                           Text(

     

       486
       486
       +
                             community.displayName ?? community.name,

     

       487
       487
       +
                             style: const TextStyle(

     

       488
       488
       +
                               color: Colors.white,

     

       489
       489
       +
                               fontSize: 16,

     

       490
       490
       +
                               fontWeight: FontWeight.bold,

     

       491
       491
       +
                             ),

     

       492
       492
       +
                             maxLines: 1,

     

       493
       493
       +
                             overflow: TextOverflow.ellipsis,

     

       494
       494
       +
                           ),

     

       495
       495
       +
       

     

       496
       496
       +
                           // Description line

     

       497
       497
       +
                           if (descriptionLine.isNotEmpty) ...[

     

       498
       498
       +
                             const SizedBox(height: 4),

     

       499
       499
       +
                             Text(

     

       500
       500
       +
                               descriptionLine,

     

       501
       501
       +
                               style: const TextStyle(

     

       502
       502
       +
                                 color: Color(0xFFB6C2D2),

     

       503
       503
       +
                                 fontSize: 14,

     

       504
       504
       +
                               ),

     

       505
       505
       +
                               maxLines: 2,

     

       506
       506
       +
                               overflow: TextOverflow.ellipsis,

     

       507
       507
       +
                             ),

     

       508
       508
       +
                           ],

     

       509
       509
       +
                         ],

     

       510
       510
       +
                       ),

     

       511
       511
       +
                     ),

     

       512
       512
       +
                   ],

     

       513
       513
       +
                 ),

     

       514
       514
       +
               ),

     

       515
       515
       +
             ),

     

       516
       516
       +
           );

     

       517
       517
       +
         }

     

       518
       518
       +
       }

+686 -28

lib/screens/home/create_post_screen.dart

···

       1
       1
        
       import 'package:flutter/material.dart';

     

       2
       2
       +
       import 'package:provider/provider.dart';

     

       2
       3
        
       

     

       3
       4
        
       import '../../constants/app_colors.dart';

     

       5
       5
       +
       import '../../models/community.dart';

     

       6
       6
       +
       import '../../models/post.dart';

     

       7
       7
       +
       import '../../providers/auth_provider.dart';

     

       8
       8
       +
       import '../../services/api_exceptions.dart';

     

       9
       9
       +
       import '../../services/coves_api_service.dart';

     

       10
       10
       +
       import '../compose/community_picker_screen.dart';

     

       11
       11
       +
       import 'post_detail_screen.dart';

     

       4
       12
        
       

     

       5
       5
       -
       class CreatePostScreen extends StatelessWidget {

     

       6
       6
       -
         const CreatePostScreen({super.key});

     

       13
       13
       +
       /// Language options for posts

     

       14
       14
       +
       const Map<String, String> languages = {

     

       15
       15
       +
         'en': 'English',

     

       16
       16
       +
         'es': 'Spanish',

     

       17
       17
       +
         'pt': 'Portuguese',

     

       18
       18
       +
         'de': 'German',

     

       19
       19
       +
         'fr': 'French',

     

       20
       20
       +
         'ja': 'Japanese',

     

       21
       21
       +
         'ko': 'Korean',

     

       22
       22
       +
         'zh': 'Chinese',

     

       23
       23
       +
       };

     

       24
       24
       +
       

     

       25
       25
       +
       /// Content limits from backend lexicon (social.coves.community.post)

     

       26
       26
       +
       /// Using grapheme limits as they are the user-facing character counts

     

       27
       27
       +
       const int kTitleMaxLength = 300;

     

       28
       28
       +
       const int kContentMaxLength = 10000;

     

       29
       29
       +
       

     

       30
       30
       +
       /// Create Post Screen

     

       31
       31
       +
       ///

     

       32
       32
       +
       /// Full-screen interface for creating a new post in a community.

     

       33
       33
       +
       ///

     

       34
       34
       +
       /// Features:

     

       35
       35
       +
       /// - Community selector (required)

     

       36
       36
       +
       /// - Optional title, URL, thumbnail, and body fields

     

       37
       37
       +
       /// - Language dropdown and NSFW toggle

     

       38
       38
       +
       /// - Form validation (at least one of title/body/URL required)

     

       39
       39
       +
       /// - Loading states and error handling

     

       40
       40
       +
       /// - Keyboard handling with scroll support

     

       41
       41
       +
       class CreatePostScreen extends StatefulWidget {

     

       42
       42
       +
         const CreatePostScreen({this.onNavigateToFeed, super.key});

     

       43
       43
       +
       

     

       44
       44
       +
         /// Callback to navigate to feed tab (used when in tab navigation)

     

       45
       45
       +
         final VoidCallback? onNavigateToFeed;

     

       46
       46
       +
       

     

       47
       47
       +
         @override

     

       48
       48
       +
         State<CreatePostScreen> createState() => _CreatePostScreenState();

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       class _CreatePostScreenState extends State<CreatePostScreen>

     

       52
       52
       +
           with WidgetsBindingObserver {

     

       53
       53
       +
         // Text controllers

     

       54
       54
       +
         final TextEditingController _titleController = TextEditingController();

     

       55
       55
       +
         final TextEditingController _urlController = TextEditingController();

     

       56
       56
       +
         final TextEditingController _thumbnailController = TextEditingController();

     

       57
       57
       +
         final TextEditingController _bodyController = TextEditingController();

     

       58
       58
       +
       

     

       59
       59
       +
         // Scroll and focus

     

       60
       60
       +
         final ScrollController _scrollController = ScrollController();

     

       61
       61
       +
         final FocusNode _titleFocusNode = FocusNode();

     

       62
       62
       +
         final FocusNode _urlFocusNode = FocusNode();

     

       63
       63
       +
         final FocusNode _thumbnailFocusNode = FocusNode();

     

       64
       64
       +
         final FocusNode _bodyFocusNode = FocusNode();

     

       65
       65
       +
         double _lastKeyboardHeight = 0;

     

       66
       66
       +
       

     

       67
       67
       +
         // Form state

     

       68
       68
       +
         CommunityView? _selectedCommunity;

     

       69
       69
       +
         String _language = 'en';

     

       70
       70
       +
         bool _isNsfw = false;

     

       71
       71
       +
         bool _isSubmitting = false;

     

       72
       72
       +
       

     

       73
       73
       +
         // Computed state

     

       74
       74
       +
         bool get _isFormValid {

     

       75
       75
       +
           return _selectedCommunity != null &&

     

       76
       76
       +
               (_titleController.text.trim().isNotEmpty ||

     

       77
       77
       +
                   _bodyController.text.trim().isNotEmpty ||

     

       78
       78
       +
                   _urlController.text.trim().isNotEmpty);

     

       79
       79
       +
         }

     

       80
       80
       +
       

     

       81
       81
       +
         @override

     

       82
       82
       +
         void initState() {

     

       83
       83
       +
           super.initState();

     

       84
       84
       +
           WidgetsBinding.instance.addObserver(this);

     

       85
       85
       +
           // Listen to text changes to update button state

     

       86
       86
       +
           _titleController.addListener(_onTextChanged);

     

       87
       87
       +
           _urlController.addListener(_onTextChanged);

     

       88
       88
       +
           _bodyController.addListener(_onTextChanged);

     

       89
       89
       +
         }

     

       90
       90
       +
       

     

       91
       91
       +
         @override

     

       92
       92
       +
         void dispose() {

     

       93
       93
       +
           WidgetsBinding.instance.removeObserver(this);

     

       94
       94
       +
           _titleController.dispose();

     

       95
       95
       +
           _urlController.dispose();

     

       96
       96
       +
           _thumbnailController.dispose();

     

       97
       97
       +
           _bodyController.dispose();

     

       98
       98
       +
           _scrollController.dispose();

     

       99
       99
       +
           _titleFocusNode.dispose();

     

       100
       100
       +
           _urlFocusNode.dispose();

     

       101
       101
       +
           _thumbnailFocusNode.dispose();

     

       102
       102
       +
           _bodyFocusNode.dispose();

     

       103
       103
       +
           super.dispose();

     

       104
       104
       +
         }

     

       105
       105
       +
       

     

       106
       106
       +
         @override

     

       107
       107
       +
         void didChangeMetrics() {

     

       108
       108
       +
           super.didChangeMetrics();

     

       109
       109
       +
           if (!mounted) {

     

       110
       110
       +
             return;

     

       111
       111
       +
           }

     

       112
       112
       +
       

     

       113
       113
       +
           final keyboardHeight = View.of(context).viewInsets.bottom;

     

       114
       114
       +
       

     

       115
       115
       +
           // Detect keyboard closing and unfocus all text fields

     

       116
       116
       +
           if (_lastKeyboardHeight > 0 && keyboardHeight == 0) {

     

       117
       117
       +
             FocusManager.instance.primaryFocus?.unfocus();

     

       118
       118
       +
           }

     

       119
       119
       +
       

     

       120
       120
       +
           _lastKeyboardHeight = keyboardHeight;

     

       121
       121
       +
         }

     

       122
       122
       +
       

     

       123
       123
       +
         void _onTextChanged() {

     

       124
       124
       +
           // Force rebuild to update Post button state

     

       125
       125
       +
           setState(() {});

     

       126
       126
       +
         }

     

       127
       127
       +
       

     

       128
       128
       +
         Future<void> _selectCommunity() async {

     

       129
       129
       +
           final result = await Navigator.push<CommunityView>(

     

       130
       130
       +
             context,

     

       131
       131
       +
             MaterialPageRoute(

     

       132
       132
       +
               builder: (context) => const CommunityPickerScreen(),

     

       133
       133
       +
             ),

     

       134
       134
       +
           );

     

       135
       135
       +
       

     

       136
       136
       +
           if (result != null && mounted) {

     

       137
       137
       +
             setState(() {

     

       138
       138
       +
               _selectedCommunity = result;

     

       139
       139
       +
             });

     

       140
       140
       +
           }

     

       141
       141
       +
         }

     

       142
       142
       +
       

     

       143
       143
       +
         Future<void> _handleSubmit() async {

     

       144
       144
       +
           if (!_isFormValid || _isSubmitting) {

     

       145
       145
       +
             return;

     

       146
       146
       +
           }

     

       147
       147
       +
       

     

       148
       148
       +
           setState(() {

     

       149
       149
       +
             _isSubmitting = true;

     

       150
       150
       +
           });

     

       151
       151
       +
       

     

       152
       152
       +
           try {

     

       153
       153
       +
             final authProvider = context.read<AuthProvider>();

     

       154
       154
       +
       

     

       155
       155
       +
             // Create API service with auth

     

       156
       156
       +
             final apiService = CovesApiService(

     

       157
       157
       +
               tokenGetter: authProvider.getAccessToken,

     

       158
       158
       +
               tokenRefresher: authProvider.refreshToken,

     

       159
       159
       +
               signOutHandler: authProvider.signOut,

     

       160
       160
       +
             );

     

       161
       161
       +
       

     

       162
       162
       +
             // Build embed if URL is provided

     

       163
       163
       +
             ExternalEmbedInput? embed;

     

       164
       164
       +
             final url = _urlController.text.trim();

     

       165
       165
       +
             if (url.isNotEmpty) {

     

       166
       166
       +
               // Validate URL

     

       167
       167
       +
               final uri = Uri.tryParse(url);

     

       168
       168
       +
               if (uri == null ||

     

       169
       169
       +
                   !uri.hasScheme ||

     

       170
       170
       +
                   (!uri.scheme.startsWith('http'))) {

     

       171
       171
       +
                 if (mounted) {

     

       172
       172
       +
                   ScaffoldMessenger.of(context).showSnackBar(

     

       173
       173
       +
                     SnackBar(

     

       174
       174
       +
                       content: const Text('Please enter a valid URL (http or https)'),

     

       175
       175
       +
                       backgroundColor: Colors.red[700],

     

       176
       176
       +
                       behavior: SnackBarBehavior.floating,

     

       177
       177
       +
                     ),

     

       178
       178
       +
                   );

     

       179
       179
       +
                 }

     

       180
       180
       +
                 setState(() {

     

       181
       181
       +
                   _isSubmitting = false;

     

       182
       182
       +
                 });

     

       183
       183
       +
                 return;

     

       184
       184
       +
               }

     

       185
       185
       +
       

     

       186
       186
       +
               embed = ExternalEmbedInput(

     

       187
       187
       +
                 uri: url,

     

       188
       188
       +
                 title: _titleController.text.trim().isNotEmpty

     

       189
       189
       +
                     ? _titleController.text.trim()

     

       190
       190
       +
                     : null,

     

       191
       191
       +
                 thumb: _thumbnailController.text.trim().isNotEmpty

     

       192
       192
       +
                     ? _thumbnailController.text.trim()

     

       193
       193
       +
                     : null,

     

       194
       194
       +
               );

     

       195
       195
       +
             }

     

       196
       196
       +
       

     

       197
       197
       +
             // Build labels if NSFW is enabled

     

       198
       198
       +
             SelfLabels? labels;

     

       199
       199
       +
             if (_isNsfw) {

     

       200
       200
       +
               labels = const SelfLabels(values: [SelfLabel(val: 'nsfw')]);

     

       201
       201
       +
             }

     

       202
       202
       +
       

     

       203
       203
       +
             // Create post

     

       204
       204
       +
             final response = await apiService.createPost(

     

       205
       205
       +
               community: _selectedCommunity!.did,

     

       206
       206
       +
               title: _titleController.text.trim().isNotEmpty

     

       207
       207
       +
                   ? _titleController.text.trim()

     

       208
       208
       +
                   : null,

     

       209
       209
       +
               content: _bodyController.text.trim().isNotEmpty

     

       210
       210
       +
                   ? _bodyController.text.trim()

     

       211
       211
       +
                   : null,

     

       212
       212
       +
               embed: embed,

     

       213
       213
       +
               langs: [_language],

     

       214
       214
       +
               labels: labels,

     

       215
       215
       +
             );

     

       216
       216
       +
       

     

       217
       217
       +
             if (mounted) {

     

       218
       218
       +
               // Build optimistic post for immediate display

     

       219
       219
       +
               final optimisticPost = _buildOptimisticPost(

     

       220
       220
       +
                 response: response,

     

       221
       221
       +
                 authProvider: authProvider,

     

       222
       222
       +
               );

     

       223
       223
       +
       

     

       224
       224
       +
               // Reset form first

     

       225
       225
       +
               _resetForm();

     

       226
       226
       +
       

     

       227
       227
       +
               // Navigate to post detail with optimistic data

     

       228
       228
       +
               await Navigator.push(

     

       229
       229
       +
                 context,

     

       230
       230
       +
                 MaterialPageRoute(

     

       231
       231
       +
                   builder: (context) => PostDetailScreen(

     

       232
       232
       +
                     post: optimisticPost,

     

       233
       233
       +
                     isOptimistic: true,

     

       234
       234
       +
                   ),

     

       235
       235
       +
                 ),

     

       236
       236
       +
               );

     

       237
       237
       +
             }

     

       238
       238
       +
           } on ApiException catch (e) {

     

       239
       239
       +
             if (mounted) {

     

       240
       240
       +
               ScaffoldMessenger.of(context).showSnackBar(

     

       241
       241
       +
                 SnackBar(

     

       242
       242
       +
                   content: Text('Failed to create post: ${e.message}'),

     

       243
       243
       +
                   backgroundColor: Colors.red[700],

     

       244
       244
       +
                   behavior: SnackBarBehavior.floating,

     

       245
       245
       +
                 ),

     

       246
       246
       +
               );

     

       247
       247
       +
             }

     

       248
       248
       +
           } on Exception catch (e) {

     

       249
       249
       +
             if (mounted) {

     

       250
       250
       +
               ScaffoldMessenger.of(context).showSnackBar(

     

       251
       251
       +
                 SnackBar(

     

       252
       252
       +
                   content: Text('Failed to create post: ${e.toString()}'),

     

       253
       253
       +
                   backgroundColor: Colors.red[700],

     

       254
       254
       +
                   behavior: SnackBarBehavior.floating,

     

       255
       255
       +
                 ),

     

       256
       256
       +
               );

     

       257
       257
       +
             }

     

       258
       258
       +
           } finally {

     

       259
       259
       +
             if (mounted) {

     

       260
       260
       +
               setState(() {

     

       261
       261
       +
                 _isSubmitting = false;

     

       262
       262
       +
               });

     

       263
       263
       +
             }

     

       264
       264
       +
           }

     

       265
       265
       +
         }

     

       266
       266
       +
       

     

       267
       267
       +
         void _resetForm() {

     

       268
       268
       +
           setState(() {

     

       269
       269
       +
             _titleController.clear();

     

       270
       270
       +
             _urlController.clear();

     

       271
       271
       +
             _thumbnailController.clear();

     

       272
       272
       +
             _bodyController.clear();

     

       273
       273
       +
             _selectedCommunity = null;

     

       274
       274
       +
             _language = 'en';

     

       275
       275
       +
             _isNsfw = false;

     

       276
       276
       +
           });

     

       277
       277
       +
         }

     

       278
       278
       +
       

     

       279
       279
       +
         /// Build optimistic post for immediate display after creation

     

       280
       280
       +
         FeedViewPost _buildOptimisticPost({

     

       281
       281
       +
           required CreatePostResponse response,

     

       282
       282
       +
           required AuthProvider authProvider,

     

       283
       283
       +
         }) {

     

       284
       284
       +
           // Extract rkey from AT-URI (at://did/collection/rkey)

     

       285
       285
       +
           final uriParts = response.uri.split('/');

     

       286
       286
       +
           final rkey = uriParts.isNotEmpty ? uriParts.last : '';

     

       287
       287
       +
       

     

       288
       288
       +
           // Build embed if URL was provided

     

       289
       289
       +
           PostEmbed? embed;

     

       290
       290
       +
           final url = _urlController.text.trim();

     

       291
       291
       +
           if (url.isNotEmpty) {

     

       292
       292
       +
             embed = PostEmbed(

     

       293
       293
       +
               type: 'social.coves.embed.external',

     

       294
       294
       +
               external: ExternalEmbed(

     

       295
       295
       +
                 uri: url,

     

       296
       296
       +
                 title: _titleController.text.trim().isNotEmpty

     

       297
       297
       +
                     ? _titleController.text.trim()

     

       298
       298
       +
                     : null,

     

       299
       299
       +
                 thumb: _thumbnailController.text.trim().isNotEmpty

     

       300
       300
       +
                     ? _thumbnailController.text.trim()

     

       301
       301
       +
                     : null,

     

       302
       302
       +
               ),

     

       303
       303
       +
               data: {

     

       304
       304
       +
                 r'$type': 'social.coves.embed.external',

     

       305
       305
       +
                 'external': {

     

       306
       306
       +
                   'uri': url,

     

       307
       307
       +
                   if (_titleController.text.trim().isNotEmpty)

     

       308
       308
       +
                     'title': _titleController.text.trim(),

     

       309
       309
       +
                   if (_thumbnailController.text.trim().isNotEmpty)

     

       310
       310
       +
                     'thumb': _thumbnailController.text.trim(),

     

       311
       311
       +
                 },

     

       312
       312
       +
               },

     

       313
       313
       +
             );

     

       314
       314
       +
           }

     

       315
       315
       +
       

     

       316
       316
       +
           final now = DateTime.now();

     

       317
       317
       +
       

     

       318
       318
       +
           return FeedViewPost(

     

       319
       319
       +
             post: PostView(

     

       320
       320
       +
               uri: response.uri,

     

       321
       321
       +
               cid: response.cid,

     

       322
       322
       +
               rkey: rkey,

     

       323
       323
       +
               author: AuthorView(

     

       324
       324
       +
                 did: authProvider.did ?? '',

     

       325
       325
       +
                 handle: authProvider.handle ?? 'unknown',

     

       326
       326
       +
                 displayName: null,

     

       327
       327
       +
                 avatar: null,

     

       328
       328
       +
               ),

     

       329
       329
       +
               community: CommunityRef(

     

       330
       330
       +
                 did: _selectedCommunity!.did,

     

       331
       331
       +
                 name: _selectedCommunity!.name,

     

       332
       332
       +
                 handle: _selectedCommunity!.handle,

     

       333
       333
       +
                 avatar: _selectedCommunity!.avatar,

     

       334
       334
       +
               ),

     

       335
       335
       +
               createdAt: now,

     

       336
       336
       +
               indexedAt: now,

     

       337
       337
       +
               text: _bodyController.text.trim(),

     

       338
       338
       +
               title: _titleController.text.trim().isNotEmpty

     

       339
       339
       +
                   ? _titleController.text.trim()

     

       340
       340
       +
                   : null,

     

       341
       341
       +
               stats: PostStats(

     

       342
       342
       +
                 upvotes: 0,

     

       343
       343
       +
                 downvotes: 0,

     

       344
       344
       +
                 score: 0,

     

       345
       345
       +
                 commentCount: 0,

     

       346
       346
       +
               ),

     

       347
       347
       +
               embed: embed,

     

       348
       348
       +
               viewer: ViewerState(),

     

       349
       349
       +
             ),

     

       350
       350
       +
           );

     

       351
       351
       +
         }

     

       7
       352
        
       

     

       8
       353
        
         @override

     

       9
       354
        
         Widget build(BuildContext context) {

     

       10
       10
       -
           return Scaffold(

     

       11
       11
       -
             backgroundColor: const Color(0xFF0B0F14),

     

       12
       12
       -
             appBar: AppBar(

     

       13
       13
       -
               backgroundColor: const Color(0xFF0B0F14),

     

       14
       14
       -
               foregroundColor: Colors.white,

     

       355
       355
       +
           final authProvider = context.watch<AuthProvider>();

     

       356
       356
       +
           final userHandle = authProvider.handle ?? 'Unknown';

     

       357
       357
       +
       

     

       358
       358
       +
           return PopScope(

     

       359
       359
       +
             canPop: widget.onNavigateToFeed == null,

     

       360
       360
       +
             onPopInvokedWithResult: (didPop, result) {

     

       361
       361
       +
               if (!didPop && widget.onNavigateToFeed != null) {

     

       362
       362
       +
                 widget.onNavigateToFeed!();

     

       363
       363
       +
               }

     

       364
       364
       +
             },

     

       365
       365
       +
             child: Scaffold(

     

       366
       366
       +
               backgroundColor: AppColors.background,

     

       367
       367
       +
               appBar: AppBar(

     

       368
       368
       +
               backgroundColor: AppColors.background,

     

       369
       369
       +
               surfaceTintColor: Colors.transparent,

     

       370
       370
       +
               foregroundColor: AppColors.textPrimary,

     

       15
       371
        
               title: const Text('Create Post'),

     

       372
       372
       +
               elevation: 0,

     

       16
       373
        
               automaticallyImplyLeading: false,

     

       374
       374
       +
               leading: IconButton(

     

       375
       375
       +
                 icon: const Icon(Icons.close),

     

       376
       376
       +
                 onPressed: () {

     

       377
       377
       +
                   // Use callback if available (tab navigation), otherwise pop

     

       378
       378
       +
                   if (widget.onNavigateToFeed != null) {

     

       379
       379
       +
                     widget.onNavigateToFeed!();

     

       380
       380
       +
                   } else {

     

       381
       381
       +
                     Navigator.pop(context);

     

       382
       382
       +
                   }

     

       383
       383
       +
                 },

     

       384
       384
       +
               ),

     

       385
       385
       +
               actions: [

     

       386
       386
       +
                 Padding(

     

       387
       387
       +
                   padding: const EdgeInsets.only(right: 8),

     

       388
       388
       +
                   child: TextButton(

     

       389
       389
       +
                     onPressed: _isFormValid && !_isSubmitting ? _handleSubmit : null,

     

       390
       390
       +
                     style: TextButton.styleFrom(

     

       391
       391
       +
                       backgroundColor: _isFormValid && !_isSubmitting

     

       392
       392
       +
                           ? AppColors.primary

     

       393
       393
       +
                           : AppColors.textSecondary.withValues(alpha: 0.3),

     

       394
       394
       +
                       foregroundColor: AppColors.textPrimary,

     

       395
       395
       +
                       padding: const EdgeInsets.symmetric(

     

       396
       396
       +
                         horizontal: 16,

     

       397
       397
       +
                         vertical: 8,

     

       398
       398
       +
                       ),

     

       399
       399
       +
                       shape: RoundedRectangleBorder(

     

       400
       400
       +
                         borderRadius: BorderRadius.circular(20),

     

       401
       401
       +
                       ),

     

       402
       402
       +
                     ),

     

       403
       403
       +
                     child:

     

       404
       404
       +
                         _isSubmitting

     

       405
       405
       +
                             ? const SizedBox(

     

       406
       406
       +
                               width: 16,

     

       407
       407
       +
                               height: 16,

     

       408
       408
       +
                               child: CircularProgressIndicator(

     

       409
       409
       +
                                 strokeWidth: 2,

     

       410
       410
       +
                                 valueColor: AlwaysStoppedAnimation<Color>(

     

       411
       411
       +
                                   AppColors.textPrimary,

     

       412
       412
       +
                                 ),

     

       413
       413
       +
                               ),

     

       414
       414
       +
                             )

     

       415
       415
       +
                             : const Text('Post'),

     

       416
       416
       +
                   ),

     

       417
       417
       +
                 ),

     

       418
       418
       +
               ],

     

       17
       419
        
             ),

     

       18
       18
       -
             body: const Center(

     

       19
       19
       -
               child: Padding(

     

       20
       20
       -
                 padding: EdgeInsets.all(24),

     

       420
       420
       +
             body: SafeArea(

     

       421
       421
       +
               child: SingleChildScrollView(

     

       422
       422
       +
                 controller: _scrollController,

     

       423
       423
       +
                 padding: const EdgeInsets.all(16),

     

       21
       424
        
                 child: Column(

     

       22
       22
       -
                   mainAxisAlignment: MainAxisAlignment.center,

     

       425
       425
       +
                   crossAxisAlignment: CrossAxisAlignment.stretch,

     

       426
       426
       +
                   children: [

     

       427
       427
       +
                     // Community selector

     

       428
       428
       +
                     _buildCommunitySelector(),

     

       429
       429
       +
       

     

       430
       430
       +
                     const SizedBox(height: 16),

     

       431
       431
       +
       

     

       432
       432
       +
                     // User info row

     

       433
       433
       +
                     _buildUserInfo(userHandle),

     

       434
       434
       +
       

     

       435
       435
       +
                     const SizedBox(height: 24),

     

       436
       436
       +
       

     

       437
       437
       +
                     // Title field

     

       438
       438
       +
                     _buildTextField(

     

       439
       439
       +
                       controller: _titleController,

     

       440
       440
       +
                       focusNode: _titleFocusNode,

     

       441
       441
       +
                       hintText: 'Title',

     

       442
       442
       +
                       maxLines: 1,

     

       443
       443
       +
                       maxLength: kTitleMaxLength,

     

       444
       444
       +
                     ),

     

       445
       445
       +
       

     

       446
       446
       +
                     const SizedBox(height: 16),

     

       447
       447
       +
       

     

       448
       448
       +
                     // URL field

     

       449
       449
       +
                     _buildTextField(

     

       450
       450
       +
                       controller: _urlController,

     

       451
       451
       +
                       focusNode: _urlFocusNode,

     

       452
       452
       +
                       hintText: 'URL',

     

       453
       453
       +
                       maxLines: 1,

     

       454
       454
       +
                       keyboardType: TextInputType.url,

     

       455
       455
       +
                     ),

     

       456
       456
       +
       

     

       457
       457
       +
                     // Thumbnail field (only visible when URL is filled)

     

       458
       458
       +
                     if (_urlController.text.trim().isNotEmpty) ...[

     

       459
       459
       +
                       const SizedBox(height: 16),

     

       460
       460
       +
                       _buildTextField(

     

       461
       461
       +
                         controller: _thumbnailController,

     

       462
       462
       +
                         focusNode: _thumbnailFocusNode,

     

       463
       463
       +
                         hintText: 'Thumbnail URL',

     

       464
       464
       +
                         maxLines: 1,

     

       465
       465
       +
                         keyboardType: TextInputType.url,

     

       466
       466
       +
                       ),

     

       467
       467
       +
                     ],

     

       468
       468
       +
       

     

       469
       469
       +
                     const SizedBox(height: 16),

     

       470
       470
       +
       

     

       471
       471
       +
                     // Body field (multiline)

     

       472
       472
       +
                     _buildTextField(

     

       473
       473
       +
                       controller: _bodyController,

     

       474
       474
       +
                       focusNode: _bodyFocusNode,

     

       475
       475
       +
                       hintText: 'What are your thoughts?',

     

       476
       476
       +
                       minLines: 8,

     

       477
       477
       +
                       maxLines: null,

     

       478
       478
       +
                       maxLength: kContentMaxLength,

     

       479
       479
       +
                     ),

     

       480
       480
       +
       

     

       481
       481
       +
                     const SizedBox(height: 24),

     

       482
       482
       +
       

     

       483
       483
       +
                     // Language dropdown and NSFW toggle

     

       484
       484
       +
                     Row(

     

       485
       485
       +
                       children: [

     

       486
       486
       +
                         // Language dropdown

     

       487
       487
       +
                         Expanded(

     

       488
       488
       +
                           child: _buildLanguageDropdown(),

     

       489
       489
       +
                         ),

     

       490
       490
       +
       

     

       491
       491
       +
                         const SizedBox(width: 16),

     

       492
       492
       +
       

     

       493
       493
       +
                         // NSFW toggle

     

       494
       494
       +
                         Expanded(

     

       495
       495
       +
                           child: _buildNsfwToggle(),

     

       496
       496
       +
                         ),

     

       497
       497
       +
                       ],

     

       498
       498
       +
                     ),

     

       499
       499
       +
       

     

       500
       500
       +
                     const SizedBox(height: 24),

     

       501
       501
       +
                   ],

     

       502
       502
       +
                 ),

     

       503
       503
       +
               ),

     

       504
       504
       +
             ),

     

       505
       505
       +
             ),

     

       506
       506
       +
           );

     

       507
       507
       +
         }

     

       508
       508
       +
       

     

       509
       509
       +
         Widget _buildCommunitySelector() {

     

       510
       510
       +
           return Material(

     

       511
       511
       +
             color: Colors.transparent,

     

       512
       512
       +
             child: InkWell(

     

       513
       513
       +
               onTap: _selectCommunity,

     

       514
       514
       +
               borderRadius: BorderRadius.circular(12),

     

       515
       515
       +
               child: Container(

     

       516
       516
       +
                 padding: const EdgeInsets.all(16),

     

       517
       517
       +
                 decoration: BoxDecoration(

     

       518
       518
       +
                   color: AppColors.backgroundSecondary,

     

       519
       519
       +
                   border: Border.all(color: AppColors.border),

     

       520
       520
       +
                   borderRadius: BorderRadius.circular(12),

     

       521
       521
       +
                 ),

     

       522
       522
       +
                 child: Row(

     

       23
       523
        
                   children: [

     

       24
       24
       -
                     Icon(

     

       25
       25
       -
                       Icons.add_circle_outline,

     

       26
       26
       -
                       size: 64,

     

       27
       27
       -
                       color: AppColors.primary,

     

       28
       28
       -
                     ),

     

       29
       29
       -
                     SizedBox(height: 24),

     

       30
       30
       -
                     Text(

     

       31
       31
       -
                       'Create Post',

     

       32
       32
       -
                       style: TextStyle(

     

       33
       33
       -
                         fontSize: 28,

     

       34
       34
       -
                         color: Colors.white,

     

       35
       35
       -
                         fontWeight: FontWeight.bold,

     

       524
       524
       +
                     const Icon(

     

       525
       525
       +
                       Icons.workspaces_outlined,

     

       526
       526
       +
                       color: AppColors.textSecondary,

     

       527
       527
       +
                       size: 20,

     

       528
       528
       +
                     ),

     

       529
       529
       +
                     const SizedBox(width: 12),

     

       530
       530
       +
                     Expanded(

     

       531
       531
       +
                       child: Text(

     

       532
       532
       +
                         _selectedCommunity?.displayName ??

     

       533
       533
       +
                             _selectedCommunity?.name ??

     

       534
       534
       +
                             'Select a community',

     

       535
       535
       +
                         style:

     

       536
       536
       +
                             TextStyle(

     

       537
       537
       +
                               color:

     

       538
       538
       +
                                   _selectedCommunity != null

     

       539
       539
       +
                                       ? AppColors.textPrimary

     

       540
       540
       +
                                       : AppColors.textSecondary,

     

       541
       541
       +
                               fontSize: 16,

     

       542
       542
       +
                             ),

     

       543
       543
       +
                         maxLines: 1,

     

       544
       544
       +
                         overflow: TextOverflow.ellipsis,

     

       36
       545
        
                       ),

     

       37
       546
        
                     ),

     

       38
       38
       -
                     SizedBox(height: 16),

     

       39
       39
       -
                     Text(

     

       40
       40
       -
                       'Share your thoughts with the community',

     

       41
       41
       -
                       style: TextStyle(fontSize: 16, color: Color(0xFFB6C2D2)),

     

       42
       42
       -
                       textAlign: TextAlign.center,

     

       547
       547
       +
                     const Icon(

     

       548
       548
       +
                       Icons.chevron_right,

     

       549
       549
       +
                       color: AppColors.textSecondary,

     

       550
       550
       +
                       size: 20,

     

       43
       551
        
                     ),

     

       44
       552
        
                   ],

     

       45
       553
        
                 ),

     
···

       47
       555
        
             ),

     

       48
       556
        
           );

     

       49
       557
        
         }

     

       558
       558
       +
       

     

       559
       559
       +
         Widget _buildUserInfo(String handle) {

     

       560
       560
       +
           return Row(

     

       561
       561
       +
             children: [

     

       562
       562
       +
               const Icon(

     

       563
       563
       +
                 Icons.person,

     

       564
       564
       +
                 color: AppColors.textSecondary,

     

       565
       565
       +
                 size: 16,

     

       566
       566
       +
               ),

     

       567
       567
       +
               const SizedBox(width: 8),

     

       568
       568
       +
               Text(

     

       569
       569
       +
                 '@$handle',

     

       570
       570
       +
                 style: const TextStyle(

     

       571
       571
       +
                   color: AppColors.textSecondary,

     

       572
       572
       +
                   fontSize: 14,

     

       573
       573
       +
                 ),

     

       574
       574
       +
               ),

     

       575
       575
       +
             ],

     

       576
       576
       +
           );

     

       577
       577
       +
         }

     

       578
       578
       +
       

     

       579
       579
       +
         Widget _buildTextField({

     

       580
       580
       +
           required TextEditingController controller,

     

       581
       581
       +
           required String hintText,

     

       582
       582
       +
           FocusNode? focusNode,

     

       583
       583
       +
           int? maxLines,

     

       584
       584
       +
           int? minLines,

     

       585
       585
       +
           int? maxLength,

     

       586
       586
       +
           TextInputType? keyboardType,

     

       587
       587
       +
           TextInputAction? textInputAction,

     

       588
       588
       +
         }) {

     

       589
       589
       +
           // For multiline fields, use newline action and multiline keyboard

     

       590
       590
       +
           final isMultiline = minLines != null && minLines > 1;

     

       591
       591
       +
           final effectiveKeyboardType =

     

       592
       592
       +
               keyboardType ?? (isMultiline ? TextInputType.multiline : TextInputType.text);

     

       593
       593
       +
           final effectiveTextInputAction =

     

       594
       594
       +
               textInputAction ?? (isMultiline ? TextInputAction.newline : TextInputAction.next);

     

       595
       595
       +
       

     

       596
       596
       +
           return TextField(

     

       597
       597
       +
             controller: controller,

     

       598
       598
       +
             focusNode: focusNode,

     

       599
       599
       +
             maxLines: maxLines,

     

       600
       600
       +
             minLines: minLines,

     

       601
       601
       +
             maxLength: maxLength,

     

       602
       602
       +
             keyboardType: effectiveKeyboardType,

     

       603
       603
       +
             textInputAction: effectiveTextInputAction,

     

       604
       604
       +
             textCapitalization: TextCapitalization.sentences,

     

       605
       605
       +
             style: const TextStyle(

     

       606
       606
       +
               color: AppColors.textPrimary,

     

       607
       607
       +
               fontSize: 16,

     

       608
       608
       +
             ),

     

       609
       609
       +
             decoration: InputDecoration(

     

       610
       610
       +
               hintText: hintText,

     

       611
       611
       +
               hintStyle: const TextStyle(color: Color(0xFF5A6B7F)),

     

       612
       612
       +
               filled: true,

     

       613
       613
       +
               fillColor: const Color(0xFF1A2028),

     

       614
       614
       +
               counterStyle: const TextStyle(color: AppColors.textSecondary),

     

       615
       615
       +
               border: OutlineInputBorder(

     

       616
       616
       +
                 borderRadius: BorderRadius.circular(12),

     

       617
       617
       +
                 borderSide: const BorderSide(color: Color(0xFF2A3441)),

     

       618
       618
       +
               ),

     

       619
       619
       +
               enabledBorder: OutlineInputBorder(

     

       620
       620
       +
                 borderRadius: BorderRadius.circular(12),

     

       621
       621
       +
                 borderSide: const BorderSide(color: Color(0xFF2A3441)),

     

       622
       622
       +
               ),

     

       623
       623
       +
               focusedBorder: OutlineInputBorder(

     

       624
       624
       +
                 borderRadius: BorderRadius.circular(12),

     

       625
       625
       +
                 borderSide: const BorderSide(

     

       626
       626
       +
                   color: AppColors.primary,

     

       627
       627
       +
                   width: 2,

     

       628
       628
       +
                 ),

     

       629
       629
       +
               ),

     

       630
       630
       +
               contentPadding: const EdgeInsets.all(16),

     

       631
       631
       +
             ),

     

       632
       632
       +
           );

     

       633
       633
       +
         }

     

       634
       634
       +
       

     

       635
       635
       +
         Widget _buildLanguageDropdown() {

     

       636
       636
       +
           return Container(

     

       637
       637
       +
             padding: const EdgeInsets.symmetric(horizontal: 12),

     

       638
       638
       +
             decoration: BoxDecoration(

     

       639
       639
       +
               color: AppColors.backgroundSecondary,

     

       640
       640
       +
               border: Border.all(color: AppColors.border),

     

       641
       641
       +
               borderRadius: BorderRadius.circular(12),

     

       642
       642
       +
             ),

     

       643
       643
       +
             child: DropdownButtonHideUnderline(

     

       644
       644
       +
               child: DropdownButton<String>(

     

       645
       645
       +
                 value: _language,

     

       646
       646
       +
                 dropdownColor: AppColors.backgroundSecondary,

     

       647
       647
       +
                 style: const TextStyle(

     

       648
       648
       +
                   color: AppColors.textPrimary,

     

       649
       649
       +
                   fontSize: 16,

     

       650
       650
       +
                 ),

     

       651
       651
       +
                 icon: const Icon(

     

       652
       652
       +
                   Icons.arrow_drop_down,

     

       653
       653
       +
                   color: AppColors.textSecondary,

     

       654
       654
       +
                 ),

     

       655
       655
       +
                 items:

     

       656
       656
       +
                     languages.entries.map((entry) {

     

       657
       657
       +
                       return DropdownMenuItem<String>(

     

       658
       658
       +
                         value: entry.key,

     

       659
       659
       +
                         child: Text(entry.value),

     

       660
       660
       +
                       );

     

       661
       661
       +
                     }).toList(),

     

       662
       662
       +
                 onChanged: (value) {

     

       663
       663
       +
                   if (value != null) {

     

       664
       664
       +
                     setState(() {

     

       665
       665
       +
                       _language = value;

     

       666
       666
       +
                     });

     

       667
       667
       +
                   }

     

       668
       668
       +
                 },

     

       669
       669
       +
               ),

     

       670
       670
       +
             ),

     

       671
       671
       +
           );

     

       672
       672
       +
         }

     

       673
       673
       +
       

     

       674
       674
       +
         Widget _buildNsfwToggle() {

     

       675
       675
       +
           return Container(

     

       676
       676
       +
             padding: const EdgeInsets.symmetric(horizontal: 12),

     

       677
       677
       +
             decoration: BoxDecoration(

     

       678
       678
       +
               color: AppColors.backgroundSecondary,

     

       679
       679
       +
               border: Border.all(color: AppColors.border),

     

       680
       680
       +
               borderRadius: BorderRadius.circular(12),

     

       681
       681
       +
             ),

     

       682
       682
       +
             child: Row(

     

       683
       683
       +
               mainAxisAlignment: MainAxisAlignment.spaceBetween,

     

       684
       684
       +
               children: [

     

       685
       685
       +
                 const Text(

     

       686
       686
       +
                   'NSFW',

     

       687
       687
       +
                   style: TextStyle(

     

       688
       688
       +
                     color: AppColors.textPrimary,

     

       689
       689
       +
                     fontSize: 16,

     

       690
       690
       +
                   ),

     

       691
       691
       +
                 ),

     

       692
       692
       +
                 Transform.scale(

     

       693
       693
       +
                   scale: 0.8,

     

       694
       694
       +
                   child: Switch.adaptive(

     

       695
       695
       +
                     value: _isNsfw,

     

       696
       696
       +
                     activeTrackColor: AppColors.primary,

     

       697
       697
       +
                     onChanged: (value) {

     

       698
       698
       +
                       setState(() {

     

       699
       699
       +
                         _isNsfw = value;

     

       700
       700
       +
                       });

     

       701
       701
       +
                     },

     

       702
       702
       +
                   ),

     

       703
       703
       +
                 ),

     

       704
       704
       +
               ],

     

       705
       705
       +
             ),

     

       706
       706
       +
           );

     

       707
       707
       +
         }

     

       50
       708
        
       }

+7 -1

lib/screens/home/main_shell_screen.dart

···

       30
       30
        
           });

     

       31
       31
        
         }

     

       32
       32
        
       

     

       33
       33
       +
         void _onNavigateToFeed() {

     

       34
       34
       +
           setState(() {

     

       35
       35
       +
             _selectedIndex = 0; // Switch to feed tab

     

       36
       36
       +
           });

     

       37
       37
       +
         }

     

       38
       38
       +
       

     

       33
       39
        
         @override

     

       34
       40
        
         Widget build(BuildContext context) {

     

       35
       41
        
           return Scaffold(

     
···

       38
       44
        
               children: [

     

       39
       45
        
                 FeedScreen(onSearchTap: _onCommunitiesTap),

     

       40
       46
        
                 const CommunitiesScreen(),

     

       41
       41
       -
                 const CreatePostScreen(),

     

       47
       47
       +
                 CreatePostScreen(onNavigateToFeed: _onNavigateToFeed),

     

       42
       48
        
                 const NotificationsScreen(),

     

       43
       49
        
                 const ProfileScreen(),

     

       44
       50
        
               ],

+368

test/models/community_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/models/community.dart';

     

       2
       2
       +
       import 'package:flutter_test/flutter_test.dart';

     

       3
       3
       +
       

     

       4
       4
       +
       void main() {

     

       5
       5
       +
         group('CommunitiesResponse', () {

     

       6
       6
       +
           test('should parse valid JSON with communities', () {

     

       7
       7
       +
             final json = {

     

       8
       8
       +
               'communities': [

     

       9
       9
       +
                 {

     

       10
       10
       +
                   'did': 'did:plc:community1',

     

       11
       11
       +
                   'name': 'test-community',

     

       12
       12
       +
                   'handle': 'test.coves.social',

     

       13
       13
       +
                   'displayName': 'Test Community',

     

       14
       14
       +
                   'description': 'A test community',

     

       15
       15
       +
                   'avatar': 'https://example.com/avatar.jpg',

     

       16
       16
       +
                   'visibility': 'public',

     

       17
       17
       +
                   'subscriberCount': 100,

     

       18
       18
       +
                   'memberCount': 50,

     

       19
       19
       +
                   'postCount': 200,

     

       20
       20
       +
                 },

     

       21
       21
       +
               ],

     

       22
       22
       +
               'cursor': 'next-cursor',

     

       23
       23
       +
             };

     

       24
       24
       +
       

     

       25
       25
       +
             final response = CommunitiesResponse.fromJson(json);

     

       26
       26
       +
       

     

       27
       27
       +
             expect(response.communities.length, 1);

     

       28
       28
       +
             expect(response.cursor, 'next-cursor');

     

       29
       29
       +
             expect(response.communities[0].did, 'did:plc:community1');

     

       30
       30
       +
             expect(response.communities[0].name, 'test-community');

     

       31
       31
       +
             expect(response.communities[0].displayName, 'Test Community');

     

       32
       32
       +
           });

     

       33
       33
       +
       

     

       34
       34
       +
           test('should handle null communities array', () {

     

       35
       35
       +
             final json = {

     

       36
       36
       +
               'communities': null,

     

       37
       37
       +
               'cursor': null,

     

       38
       38
       +
             };

     

       39
       39
       +
       

     

       40
       40
       +
             final response = CommunitiesResponse.fromJson(json);

     

       41
       41
       +
       

     

       42
       42
       +
             expect(response.communities, isEmpty);

     

       43
       43
       +
             expect(response.cursor, null);

     

       44
       44
       +
           });

     

       45
       45
       +
       

     

       46
       46
       +
           test('should handle empty communities array', () {

     

       47
       47
       +
             final json = {

     

       48
       48
       +
               'communities': [],

     

       49
       49
       +
               'cursor': null,

     

       50
       50
       +
             };

     

       51
       51
       +
       

     

       52
       52
       +
             final response = CommunitiesResponse.fromJson(json);

     

       53
       53
       +
       

     

       54
       54
       +
             expect(response.communities, isEmpty);

     

       55
       55
       +
             expect(response.cursor, null);

     

       56
       56
       +
           });

     

       57
       57
       +
       

     

       58
       58
       +
           test('should parse without cursor', () {

     

       59
       59
       +
             final json = {

     

       60
       60
       +
               'communities': [

     

       61
       61
       +
                 {

     

       62
       62
       +
                   'did': 'did:plc:community1',

     

       63
       63
       +
                   'name': 'test-community',

     

       64
       64
       +
                 },

     

       65
       65
       +
               ],

     

       66
       66
       +
             };

     

       67
       67
       +
       

     

       68
       68
       +
             final response = CommunitiesResponse.fromJson(json);

     

       69
       69
       +
       

     

       70
       70
       +
             expect(response.cursor, null);

     

       71
       71
       +
             expect(response.communities.length, 1);

     

       72
       72
       +
           });

     

       73
       73
       +
         });

     

       74
       74
       +
       

     

       75
       75
       +
         group('CommunityView', () {

     

       76
       76
       +
           test('should parse complete JSON with all fields', () {

     

       77
       77
       +
             final json = {

     

       78
       78
       +
               'did': 'did:plc:community1',

     

       79
       79
       +
               'name': 'test-community',

     

       80
       80
       +
               'handle': 'test.coves.social',

     

       81
       81
       +
               'displayName': 'Test Community',

     

       82
       82
       +
               'description': 'A community for testing',

     

       83
       83
       +
               'avatar': 'https://example.com/avatar.jpg',

     

       84
       84
       +
               'visibility': 'public',

     

       85
       85
       +
               'subscriberCount': 1000,

     

       86
       86
       +
               'memberCount': 500,

     

       87
       87
       +
               'postCount': 2500,

     

       88
       88
       +
               'viewer': {

     

       89
       89
       +
                 'subscribed': true,

     

       90
       90
       +
                 'member': false,

     

       91
       91
       +
               },

     

       92
       92
       +
             };

     

       93
       93
       +
       

     

       94
       94
       +
             final community = CommunityView.fromJson(json);

     

       95
       95
       +
       

     

       96
       96
       +
             expect(community.did, 'did:plc:community1');

     

       97
       97
       +
             expect(community.name, 'test-community');

     

       98
       98
       +
             expect(community.handle, 'test.coves.social');

     

       99
       99
       +
             expect(community.displayName, 'Test Community');

     

       100
       100
       +
             expect(community.description, 'A community for testing');

     

       101
       101
       +
             expect(community.avatar, 'https://example.com/avatar.jpg');

     

       102
       102
       +
             expect(community.visibility, 'public');

     

       103
       103
       +
             expect(community.subscriberCount, 1000);

     

       104
       104
       +
             expect(community.memberCount, 500);

     

       105
       105
       +
             expect(community.postCount, 2500);

     

       106
       106
       +
             expect(community.viewer, isNotNull);

     

       107
       107
       +
             expect(community.viewer!.subscribed, true);

     

       108
       108
       +
             expect(community.viewer!.member, false);

     

       109
       109
       +
           });

     

       110
       110
       +
       

     

       111
       111
       +
           test('should parse minimal JSON with required fields only', () {

     

       112
       112
       +
             final json = {

     

       113
       113
       +
               'did': 'did:plc:community1',

     

       114
       114
       +
               'name': 'test-community',

     

       115
       115
       +
             };

     

       116
       116
       +
       

     

       117
       117
       +
             final community = CommunityView.fromJson(json);

     

       118
       118
       +
       

     

       119
       119
       +
             expect(community.did, 'did:plc:community1');

     

       120
       120
       +
             expect(community.name, 'test-community');

     

       121
       121
       +
             expect(community.handle, null);

     

       122
       122
       +
             expect(community.displayName, null);

     

       123
       123
       +
             expect(community.description, null);

     

       124
       124
       +
             expect(community.avatar, null);

     

       125
       125
       +
             expect(community.visibility, null);

     

       126
       126
       +
             expect(community.subscriberCount, null);

     

       127
       127
       +
             expect(community.memberCount, null);

     

       128
       128
       +
             expect(community.postCount, null);

     

       129
       129
       +
             expect(community.viewer, null);

     

       130
       130
       +
           });

     

       131
       131
       +
       

     

       132
       132
       +
           test('should handle null optional fields', () {

     

       133
       133
       +
             final json = {

     

       134
       134
       +
               'did': 'did:plc:community1',

     

       135
       135
       +
               'name': 'test-community',

     

       136
       136
       +
               'handle': null,

     

       137
       137
       +
               'displayName': null,

     

       138
       138
       +
               'description': null,

     

       139
       139
       +
               'avatar': null,

     

       140
       140
       +
               'visibility': null,

     

       141
       141
       +
               'subscriberCount': null,

     

       142
       142
       +
               'memberCount': null,

     

       143
       143
       +
               'postCount': null,

     

       144
       144
       +
               'viewer': null,

     

       145
       145
       +
             };

     

       146
       146
       +
       

     

       147
       147
       +
             final community = CommunityView.fromJson(json);

     

       148
       148
       +
       

     

       149
       149
       +
             expect(community.did, 'did:plc:community1');

     

       150
       150
       +
             expect(community.name, 'test-community');

     

       151
       151
       +
             expect(community.handle, null);

     

       152
       152
       +
             expect(community.displayName, null);

     

       153
       153
       +
             expect(community.description, null);

     

       154
       154
       +
             expect(community.avatar, null);

     

       155
       155
       +
             expect(community.visibility, null);

     

       156
       156
       +
             expect(community.subscriberCount, null);

     

       157
       157
       +
             expect(community.memberCount, null);

     

       158
       158
       +
             expect(community.postCount, null);

     

       159
       159
       +
             expect(community.viewer, null);

     

       160
       160
       +
           });

     

       161
       161
       +
         });

     

       162
       162
       +
       

     

       163
       163
       +
         group('CommunityViewerState', () {

     

       164
       164
       +
           test('should parse with all fields', () {

     

       165
       165
       +
             final json = {

     

       166
       166
       +
               'subscribed': true,

     

       167
       167
       +
               'member': true,

     

       168
       168
       +
             };

     

       169
       169
       +
       

     

       170
       170
       +
             final viewer = CommunityViewerState.fromJson(json);

     

       171
       171
       +
       

     

       172
       172
       +
             expect(viewer.subscribed, true);

     

       173
       173
       +
             expect(viewer.member, true);

     

       174
       174
       +
           });

     

       175
       175
       +
       

     

       176
       176
       +
           test('should parse with false values', () {

     

       177
       177
       +
             final json = {

     

       178
       178
       +
               'subscribed': false,

     

       179
       179
       +
               'member': false,

     

       180
       180
       +
             };

     

       181
       181
       +
       

     

       182
       182
       +
             final viewer = CommunityViewerState.fromJson(json);

     

       183
       183
       +
       

     

       184
       184
       +
             expect(viewer.subscribed, false);

     

       185
       185
       +
             expect(viewer.member, false);

     

       186
       186
       +
           });

     

       187
       187
       +
       

     

       188
       188
       +
           test('should handle null values', () {

     

       189
       189
       +
             final json = {

     

       190
       190
       +
               'subscribed': null,

     

       191
       191
       +
               'member': null,

     

       192
       192
       +
             };

     

       193
       193
       +
       

     

       194
       194
       +
             final viewer = CommunityViewerState.fromJson(json);

     

       195
       195
       +
       

     

       196
       196
       +
             expect(viewer.subscribed, null);

     

       197
       197
       +
             expect(viewer.member, null);

     

       198
       198
       +
           });

     

       199
       199
       +
       

     

       200
       200
       +
           test('should handle missing fields', () {

     

       201
       201
       +
             final json = <String, dynamic>{};

     

       202
       202
       +
       

     

       203
       203
       +
             final viewer = CommunityViewerState.fromJson(json);

     

       204
       204
       +
       

     

       205
       205
       +
             expect(viewer.subscribed, null);

     

       206
       206
       +
             expect(viewer.member, null);

     

       207
       207
       +
           });

     

       208
       208
       +
         });

     

       209
       209
       +
       

     

       210
       210
       +
         group('CreatePostResponse', () {

     

       211
       211
       +
           test('should parse valid JSON', () {

     

       212
       212
       +
             final json = {

     

       213
       213
       +
               'uri': 'at://did:plc:test/social.coves.community.post/123',

     

       214
       214
       +
               'cid': 'bafyreicid123',

     

       215
       215
       +
             };

     

       216
       216
       +
       

     

       217
       217
       +
             final response = CreatePostResponse.fromJson(json);

     

       218
       218
       +
       

     

       219
       219
       +
             expect(response.uri, 'at://did:plc:test/social.coves.community.post/123');

     

       220
       220
       +
             expect(response.cid, 'bafyreicid123');

     

       221
       221
       +
           });

     

       222
       222
       +
       

     

       223
       223
       +
           test('should be const constructible', () {

     

       224
       224
       +
             const response = CreatePostResponse(

     

       225
       225
       +
               uri: 'at://did:plc:test/post/123',

     

       226
       226
       +
               cid: 'cid123',

     

       227
       227
       +
             );

     

       228
       228
       +
       

     

       229
       229
       +
             expect(response.uri, 'at://did:plc:test/post/123');

     

       230
       230
       +
             expect(response.cid, 'cid123');

     

       231
       231
       +
           });

     

       232
       232
       +
         });

     

       233
       233
       +
       

     

       234
       234
       +
         group('ExternalEmbedInput', () {

     

       235
       235
       +
           test('should serialize complete JSON', () {

     

       236
       236
       +
             const embed = ExternalEmbedInput(

     

       237
       237
       +
               uri: 'https://example.com/article',

     

       238
       238
       +
               title: 'Article Title',

     

       239
       239
       +
               description: 'Article description',

     

       240
       240
       +
               thumb: 'https://example.com/thumb.jpg',

     

       241
       241
       +
             );

     

       242
       242
       +
       

     

       243
       243
       +
             final json = embed.toJson();

     

       244
       244
       +
       

     

       245
       245
       +
             expect(json['uri'], 'https://example.com/article');

     

       246
       246
       +
             expect(json['title'], 'Article Title');

     

       247
       247
       +
             expect(json['description'], 'Article description');

     

       248
       248
       +
             expect(json['thumb'], 'https://example.com/thumb.jpg');

     

       249
       249
       +
           });

     

       250
       250
       +
       

     

       251
       251
       +
           test('should serialize minimal JSON with only required fields', () {

     

       252
       252
       +
             const embed = ExternalEmbedInput(

     

       253
       253
       +
               uri: 'https://example.com/article',

     

       254
       254
       +
             );

     

       255
       255
       +
       

     

       256
       256
       +
             final json = embed.toJson();

     

       257
       257
       +
       

     

       258
       258
       +
             expect(json['uri'], 'https://example.com/article');

     

       259
       259
       +
             expect(json.containsKey('title'), false);

     

       260
       260
       +
             expect(json.containsKey('description'), false);

     

       261
       261
       +
             expect(json.containsKey('thumb'), false);

     

       262
       262
       +
           });

     

       263
       263
       +
       

     

       264
       264
       +
           test('should be const constructible', () {

     

       265
       265
       +
             const embed = ExternalEmbedInput(

     

       266
       266
       +
               uri: 'https://example.com',

     

       267
       267
       +
               title: 'Test',

     

       268
       268
       +
             );

     

       269
       269
       +
       

     

       270
       270
       +
             expect(embed.uri, 'https://example.com');

     

       271
       271
       +
             expect(embed.title, 'Test');

     

       272
       272
       +
           });

     

       273
       273
       +
         });

     

       274
       274
       +
       

     

       275
       275
       +
         group('SelfLabels', () {

     

       276
       276
       +
           test('should serialize to JSON', () {

     

       277
       277
       +
             const labels = SelfLabels(

     

       278
       278
       +
               values: [

     

       279
       279
       +
                 SelfLabel(val: 'nsfw'),

     

       280
       280
       +
                 SelfLabel(val: 'spoiler'),

     

       281
       281
       +
               ],

     

       282
       282
       +
             );

     

       283
       283
       +
       

     

       284
       284
       +
             final json = labels.toJson();

     

       285
       285
       +
       

     

       286
       286
       +
             expect(json['values'], isA<List>());

     

       287
       287
       +
             expect((json['values'] as List).length, 2);

     

       288
       288
       +
             expect((json['values'] as List)[0]['val'], 'nsfw');

     

       289
       289
       +
             expect((json['values'] as List)[1]['val'], 'spoiler');

     

       290
       290
       +
           });

     

       291
       291
       +
       

     

       292
       292
       +
           test('should be const constructible', () {

     

       293
       293
       +
             const labels = SelfLabels(

     

       294
       294
       +
               values: [SelfLabel(val: 'nsfw')],

     

       295
       295
       +
             );

     

       296
       296
       +
       

     

       297
       297
       +
             expect(labels.values.length, 1);

     

       298
       298
       +
             expect(labels.values[0].val, 'nsfw');

     

       299
       299
       +
           });

     

       300
       300
       +
         });

     

       301
       301
       +
       

     

       302
       302
       +
         group('SelfLabel', () {

     

       303
       303
       +
           test('should serialize to JSON', () {

     

       304
       304
       +
             const label = SelfLabel(val: 'nsfw');

     

       305
       305
       +
       

     

       306
       306
       +
             final json = label.toJson();

     

       307
       307
       +
       

     

       308
       308
       +
             expect(json['val'], 'nsfw');

     

       309
       309
       +
           });

     

       310
       310
       +
       

     

       311
       311
       +
           test('should be const constructible', () {

     

       312
       312
       +
             const label = SelfLabel(val: 'spoiler');

     

       313
       313
       +
       

     

       314
       314
       +
             expect(label.val, 'spoiler');

     

       315
       315
       +
           });

     

       316
       316
       +
         });

     

       317
       317
       +
       

     

       318
       318
       +
         group('CreatePostRequest', () {

     

       319
       319
       +
           test('should serialize complete request', () {

     

       320
       320
       +
             final request = CreatePostRequest(

     

       321
       321
       +
               community: 'did:plc:community1',

     

       322
       322
       +
               title: 'Test Post',

     

       323
       323
       +
               content: 'Post content here',

     

       324
       324
       +
               embed: const ExternalEmbedInput(

     

       325
       325
       +
                 uri: 'https://example.com',

     

       326
       326
       +
                 title: 'Link Title',

     

       327
       327
       +
               ),

     

       328
       328
       +
               langs: ['en', 'es'],

     

       329
       329
       +
               labels: const SelfLabels(values: [SelfLabel(val: 'nsfw')]),

     

       330
       330
       +
             );

     

       331
       331
       +
       

     

       332
       332
       +
             final json = request.toJson();

     

       333
       333
       +
       

     

       334
       334
       +
             expect(json['community'], 'did:plc:community1');

     

       335
       335
       +
             expect(json['title'], 'Test Post');

     

       336
       336
       +
             expect(json['content'], 'Post content here');

     

       337
       337
       +
             expect(json['embed'], isA<Map>());

     

       338
       338
       +
             expect(json['langs'], ['en', 'es']);

     

       339
       339
       +
             expect(json['labels'], isA<Map>());

     

       340
       340
       +
           });

     

       341
       341
       +
       

     

       342
       342
       +
           test('should serialize minimal request with only required fields', () {

     

       343
       343
       +
             final request = CreatePostRequest(

     

       344
       344
       +
               community: 'did:plc:community1',

     

       345
       345
       +
             );

     

       346
       346
       +
       

     

       347
       347
       +
             final json = request.toJson();

     

       348
       348
       +
       

     

       349
       349
       +
             expect(json['community'], 'did:plc:community1');

     

       350
       350
       +
             expect(json.containsKey('title'), false);

     

       351
       351
       +
             expect(json.containsKey('content'), false);

     

       352
       352
       +
             expect(json.containsKey('embed'), false);

     

       353
       353
       +
             expect(json.containsKey('langs'), false);

     

       354
       354
       +
             expect(json.containsKey('labels'), false);

     

       355
       355
       +
           });

     

       356
       356
       +
       

     

       357
       357
       +
           test('should not include empty langs array', () {

     

       358
       358
       +
             final request = CreatePostRequest(

     

       359
       359
       +
               community: 'did:plc:community1',

     

       360
       360
       +
               langs: [],

     

       361
       361
       +
             );

     

       362
       362
       +
       

     

       363
       363
       +
             final json = request.toJson();

     

       364
       364
       +
       

     

       365
       365
       +
             expect(json.containsKey('langs'), false);

     

       366
       366
       +
           });

     

       367
       367
       +
         });

     

       368
       368
       +
       }

+269

test/screens/community_picker_screen_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/models/community.dart';

     

       2
       2
       +
       import 'package:flutter_test/flutter_test.dart';

     

       3
       3
       +
       

     

       4
       4
       +
       void main() {

     

       5
       5
       +
         // Note: Full widget tests for CommunityPickerScreen require mocking the API

     

       6
       6
       +
         // service and proper timer management. The core business logic is thoroughly

     

       7
       7
       +
         // tested in the unit test groups below (search filtering, count formatting,

     

       8
       8
       +
         // description building). Widget integration tests would need a mock API service

     

       9
       9
       +
         // to avoid real network calls and pending timer issues from the search debounce.

     

       10
       10
       +
       

     

       11
       11
       +
         group('CommunityPickerScreen Search Filtering', () {

     

       12
       12
       +
           test('client-side filtering should match name', () {

     

       13
       13
       +
             final communities = [

     

       14
       14
       +
               CommunityView(did: 'did:1', name: 'programming'),

     

       15
       15
       +
               CommunityView(did: 'did:2', name: 'gaming'),

     

       16
       16
       +
               CommunityView(did: 'did:3', name: 'music'),

     

       17
       17
       +
             ];

     

       18
       18
       +
       

     

       19
       19
       +
             final query = 'prog';

     

       20
       20
       +
       

     

       21
       21
       +
             final filtered = communities.where((community) {

     

       22
       22
       +
               final name = community.name.toLowerCase();

     

       23
       23
       +
               return name.contains(query.toLowerCase());

     

       24
       24
       +
             }).toList();

     

       25
       25
       +
       

     

       26
       26
       +
             expect(filtered.length, 1);

     

       27
       27
       +
             expect(filtered[0].name, 'programming');

     

       28
       28
       +
           });

     

       29
       29
       +
       

     

       30
       30
       +
           test('client-side filtering should match displayName', () {

     

       31
       31
       +
             final communities = [

     

       32
       32
       +
               CommunityView(

     

       33
       33
       +
                 did: 'did:1',

     

       34
       34
       +
                 name: 'prog',

     

       35
       35
       +
                 displayName: 'Programming Discussion',

     

       36
       36
       +
               ),

     

       37
       37
       +
               CommunityView(did: 'did:2', name: 'gaming', displayName: 'Gaming'),

     

       38
       38
       +
               CommunityView(did: 'did:3', name: 'music', displayName: 'Music'),

     

       39
       39
       +
             ];

     

       40
       40
       +
       

     

       41
       41
       +
             final query = 'discussion';

     

       42
       42
       +
       

     

       43
       43
       +
             final filtered = communities.where((community) {

     

       44
       44
       +
               final name = community.name.toLowerCase();

     

       45
       45
       +
               final displayName = community.displayName?.toLowerCase() ?? '';

     

       46
       46
       +
               return name.contains(query.toLowerCase()) ||

     

       47
       47
       +
                   displayName.contains(query.toLowerCase());

     

       48
       48
       +
             }).toList();

     

       49
       49
       +
       

     

       50
       50
       +
             expect(filtered.length, 1);

     

       51
       51
       +
             expect(filtered[0].displayName, 'Programming Discussion');

     

       52
       52
       +
           });

     

       53
       53
       +
       

     

       54
       54
       +
           test('client-side filtering should match description', () {

     

       55
       55
       +
             final communities = [

     

       56
       56
       +
               CommunityView(

     

       57
       57
       +
                 did: 'did:1',

     

       58
       58
       +
                 name: 'prog',

     

       59
       59
       +
                 description: 'A place to discuss coding and software',

     

       60
       60
       +
               ),

     

       61
       61
       +
               CommunityView(

     

       62
       62
       +
                 did: 'did:2',

     

       63
       63
       +
                 name: 'gaming',

     

       64
       64
       +
                 description: 'Gaming news and discussions',

     

       65
       65
       +
               ),

     

       66
       66
       +
               CommunityView(

     

       67
       67
       +
                 did: 'did:3',

     

       68
       68
       +
                 name: 'music',

     

       69
       69
       +
                 description: 'Music appreciation',

     

       70
       70
       +
               ),

     

       71
       71
       +
             ];

     

       72
       72
       +
       

     

       73
       73
       +
             final query = 'software';

     

       74
       74
       +
       

     

       75
       75
       +
             final filtered = communities.where((community) {

     

       76
       76
       +
               final name = community.name.toLowerCase();

     

       77
       77
       +
               final description = community.description?.toLowerCase() ?? '';

     

       78
       78
       +
               return name.contains(query.toLowerCase()) ||

     

       79
       79
       +
                   description.contains(query.toLowerCase());

     

       80
       80
       +
             }).toList();

     

       81
       81
       +
       

     

       82
       82
       +
             expect(filtered.length, 1);

     

       83
       83
       +
             expect(filtered[0].name, 'prog');

     

       84
       84
       +
           });

     

       85
       85
       +
       

     

       86
       86
       +
           test('client-side filtering should be case insensitive', () {

     

       87
       87
       +
             final communities = [

     

       88
       88
       +
               CommunityView(did: 'did:1', name: 'Programming'),

     

       89
       89
       +
               CommunityView(did: 'did:2', name: 'GAMING'),

     

       90
       90
       +
               CommunityView(did: 'did:3', name: 'music'),

     

       91
       91
       +
             ];

     

       92
       92
       +
       

     

       93
       93
       +
             final query = 'PROG';

     

       94
       94
       +
       

     

       95
       95
       +
             final filtered = communities.where((community) {

     

       96
       96
       +
               final name = community.name.toLowerCase();

     

       97
       97
       +
               return name.contains(query.toLowerCase());

     

       98
       98
       +
             }).toList();

     

       99
       99
       +
       

     

       100
       100
       +
             expect(filtered.length, 1);

     

       101
       101
       +
             expect(filtered[0].name, 'Programming');

     

       102
       102
       +
           });

     

       103
       103
       +
       

     

       104
       104
       +
           test('empty query should return all communities', () {

     

       105
       105
       +
             final communities = [

     

       106
       106
       +
               CommunityView(did: 'did:1', name: 'programming'),

     

       107
       107
       +
               CommunityView(did: 'did:2', name: 'gaming'),

     

       108
       108
       +
               CommunityView(did: 'did:3', name: 'music'),

     

       109
       109
       +
             ];

     

       110
       110
       +
       

     

       111
       111
       +
             final query = '';

     

       112
       112
       +
       

     

       113
       113
       +
             List<CommunityView> filtered;

     

       114
       114
       +
             if (query.isEmpty) {

     

       115
       115
       +
               filtered = communities;

     

       116
       116
       +
             } else {

     

       117
       117
       +
               filtered = communities.where((community) {

     

       118
       118
       +
                 final name = community.name.toLowerCase();

     

       119
       119
       +
                 return name.contains(query.toLowerCase());

     

       120
       120
       +
               }).toList();

     

       121
       121
       +
             }

     

       122
       122
       +
       

     

       123
       123
       +
             expect(filtered.length, 3);

     

       124
       124
       +
           });

     

       125
       125
       +
       

     

       126
       126
       +
           test('no match should return empty list', () {

     

       127
       127
       +
             final communities = [

     

       128
       128
       +
               CommunityView(did: 'did:1', name: 'programming'),

     

       129
       129
       +
               CommunityView(did: 'did:2', name: 'gaming'),

     

       130
       130
       +
               CommunityView(did: 'did:3', name: 'music'),

     

       131
       131
       +
             ];

     

       132
       132
       +
       

     

       133
       133
       +
             final query = 'xyz123';

     

       134
       134
       +
       

     

       135
       135
       +
             final filtered = communities.where((community) {

     

       136
       136
       +
               final name = community.name.toLowerCase();

     

       137
       137
       +
               final displayName = community.displayName?.toLowerCase() ?? '';

     

       138
       138
       +
               final description = community.description?.toLowerCase() ?? '';

     

       139
       139
       +
               return name.contains(query.toLowerCase()) ||

     

       140
       140
       +
                   displayName.contains(query.toLowerCase()) ||

     

       141
       141
       +
                   description.contains(query.toLowerCase());

     

       142
       142
       +
             }).toList();

     

       143
       143
       +
       

     

       144
       144
       +
             expect(filtered.length, 0);

     

       145
       145
       +
           });

     

       146
       146
       +
         });

     

       147
       147
       +
       

     

       148
       148
       +
         group('CommunityPickerScreen Member Count Formatting', () {

     

       149
       149
       +
           String formatCount(int? count) {

     

       150
       150
       +
             if (count == null) {

     

       151
       151
       +
               return '0';

     

       152
       152
       +
             }

     

       153
       153
       +
             if (count >= 1000000) {

     

       154
       154
       +
               return '${(count / 1000000).toStringAsFixed(1)}M';

     

       155
       155
       +
             } else if (count >= 1000) {

     

       156
       156
       +
               return '${(count / 1000).toStringAsFixed(1)}K';

     

       157
       157
       +
             }

     

       158
       158
       +
             return count.toString();

     

       159
       159
       +
           }

     

       160
       160
       +
       

     

       161
       161
       +
           test('should format null count as 0', () {

     

       162
       162
       +
             expect(formatCount(null), '0');

     

       163
       163
       +
           });

     

       164
       164
       +
       

     

       165
       165
       +
           test('should format small numbers as-is', () {

     

       166
       166
       +
             expect(formatCount(0), '0');

     

       167
       167
       +
             expect(formatCount(1), '1');

     

       168
       168
       +
             expect(formatCount(100), '100');

     

       169
       169
       +
             expect(formatCount(999), '999');

     

       170
       170
       +
           });

     

       171
       171
       +
       

     

       172
       172
       +
           test('should format thousands with K suffix', () {

     

       173
       173
       +
             expect(formatCount(1000), '1.0K');

     

       174
       174
       +
             expect(formatCount(1500), '1.5K');

     

       175
       175
       +
             expect(formatCount(10000), '10.0K');

     

       176
       176
       +
             expect(formatCount(999999), '1000.0K');

     

       177
       177
       +
           });

     

       178
       178
       +
       

     

       179
       179
       +
           test('should format millions with M suffix', () {

     

       180
       180
       +
             expect(formatCount(1000000), '1.0M');

     

       181
       181
       +
             expect(formatCount(1500000), '1.5M');

     

       182
       182
       +
             expect(formatCount(10000000), '10.0M');

     

       183
       183
       +
           });

     

       184
       184
       +
         });

     

       185
       185
       +
       

     

       186
       186
       +
         group('CommunityPickerScreen Description Building', () {

     

       187
       187
       +
           test('should build description with member count only', () {

     

       188
       188
       +
             const memberCount = 1000;

     

       189
       189
       +
             const subscriberCount = 0;

     

       190
       190
       +
       

     

       191
       191
       +
             String formatCount(int count) {

     

       192
       192
       +
               if (count >= 1000) {

     

       193
       193
       +
                 return '${(count / 1000).toStringAsFixed(1)}K';

     

       194
       194
       +
               }

     

       195
       195
       +
               return count.toString();

     

       196
       196
       +
             }

     

       197
       197
       +
       

     

       198
       198
       +
             var descriptionLine = '';

     

       199
       199
       +
             if (memberCount > 0) {

     

       200
       200
       +
               descriptionLine = '${formatCount(memberCount)} members';

     

       201
       201
       +
             }

     

       202
       202
       +
       

     

       203
       203
       +
             expect(descriptionLine, '1.0K members');

     

       204
       204
       +
           });

     

       205
       205
       +
       

     

       206
       206
       +
           test('should build description with member and subscriber counts', () {

     

       207
       207
       +
             const memberCount = 1000;

     

       208
       208
       +
             const subscriberCount = 500;

     

       209
       209
       +
       

     

       210
       210
       +
             String formatCount(int count) {

     

       211
       211
       +
               if (count >= 1000) {

     

       212
       212
       +
                 return '${(count / 1000).toStringAsFixed(1)}K';

     

       213
       213
       +
               }

     

       214
       214
       +
               return count.toString();

     

       215
       215
       +
             }

     

       216
       216
       +
       

     

       217
       217
       +
             var descriptionLine = '';

     

       218
       218
       +
             if (memberCount > 0) {

     

       219
       219
       +
               descriptionLine = '${formatCount(memberCount)} members';

     

       220
       220
       +
               if (subscriberCount > 0) {

     

       221
       221
       +
                 descriptionLine += ' · ${formatCount(subscriberCount)} subscribers';

     

       222
       222
       +
               }

     

       223
       223
       +
             }

     

       224
       224
       +
       

     

       225
       225
       +
             expect(descriptionLine, '1.0K members · 500 subscribers');

     

       226
       226
       +
           });

     

       227
       227
       +
       

     

       228
       228
       +
           test('should build description with subscriber count only', () {

     

       229
       229
       +
             const memberCount = 0;

     

       230
       230
       +
             const subscriberCount = 500;

     

       231
       231
       +
       

     

       232
       232
       +
             String formatCount(int count) {

     

       233
       233
       +
               if (count >= 1000) {

     

       234
       234
       +
                 return '${(count / 1000).toStringAsFixed(1)}K';

     

       235
       235
       +
               }

     

       236
       236
       +
               return count.toString();

     

       237
       237
       +
             }

     

       238
       238
       +
       

     

       239
       239
       +
             var descriptionLine = '';

     

       240
       240
       +
             if (memberCount > 0) {

     

       241
       241
       +
               descriptionLine = '${formatCount(memberCount)} members';

     

       242
       242
       +
             } else if (subscriberCount > 0) {

     

       243
       243
       +
               descriptionLine = '${formatCount(subscriberCount)} subscribers';

     

       244
       244
       +
             }

     

       245
       245
       +
       

     

       246
       246
       +
             expect(descriptionLine, '500 subscribers');

     

       247
       247
       +
           });

     

       248
       248
       +
       

     

       249
       249
       +
           test('should append community description with separator', () {

     

       250
       250
       +
             const memberCount = 100;

     

       251
       251
       +
             const description = 'A great community';

     

       252
       252
       +
       

     

       253
       253
       +
             String formatCount(int count) => count.toString();

     

       254
       254
       +
       

     

       255
       255
       +
             var descriptionLine = '';

     

       256
       256
       +
             if (memberCount > 0) {

     

       257
       257
       +
               descriptionLine = '${formatCount(memberCount)} members';

     

       258
       258
       +
             }

     

       259
       259
       +
             if (description.isNotEmpty) {

     

       260
       260
       +
               if (descriptionLine.isNotEmpty) {

     

       261
       261
       +
                 descriptionLine += ' · ';

     

       262
       262
       +
               }

     

       263
       263
       +
               descriptionLine += description;

     

       264
       264
       +
             }

     

       265
       265
       +
       

     

       266
       266
       +
             expect(descriptionLine, '100 members · A great community');

     

       267
       267
       +
           });

     

       268
       268
       +
         });

     

       269
       269
       +
       }

+339

test/screens/create_post_screen_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/models/community.dart';

     

       2
       2
       +
       import 'package:coves_flutter/providers/auth_provider.dart';

     

       3
       3
       +
       import 'package:coves_flutter/screens/home/create_post_screen.dart';

     

       4
       4
       +
       import 'package:flutter/material.dart';

     

       5
       5
       +
       import 'package:flutter_test/flutter_test.dart';

     

       6
       6
       +
       import 'package:provider/provider.dart';

     

       7
       7
       +
       

     

       8
       8
       +
       // Fake AuthProvider for testing

     

       9
       9
       +
       class FakeAuthProvider extends AuthProvider {

     

       10
       10
       +
         bool _isAuthenticated = true;

     

       11
       11
       +
         String? _did = 'did:plc:testuser';

     

       12
       12
       +
         String? _handle = 'testuser.coves.social';

     

       13
       13
       +
       

     

       14
       14
       +
         @override

     

       15
       15
       +
         bool get isAuthenticated => _isAuthenticated;

     

       16
       16
       +
       

     

       17
       17
       +
         @override

     

       18
       18
       +
         String? get did => _did;

     

       19
       19
       +
       

     

       20
       20
       +
         @override

     

       21
       21
       +
         String? get handle => _handle;

     

       22
       22
       +
       

     

       23
       23
       +
         void setAuthenticated({required bool value, String? did, String? handle}) {

     

       24
       24
       +
           _isAuthenticated = value;

     

       25
       25
       +
           _did = did;

     

       26
       26
       +
           _handle = handle;

     

       27
       27
       +
           notifyListeners();

     

       28
       28
       +
         }

     

       29
       29
       +
       

     

       30
       30
       +
         @override

     

       31
       31
       +
         Future<String?> getAccessToken() async {

     

       32
       32
       +
           return _isAuthenticated ? 'mock_access_token' : null;

     

       33
       33
       +
         }

     

       34
       34
       +
       

     

       35
       35
       +
         @override

     

       36
       36
       +
         Future<bool> refreshToken() async {

     

       37
       37
       +
           return _isAuthenticated;

     

       38
       38
       +
         }

     

       39
       39
       +
       

     

       40
       40
       +
         @override

     

       41
       41
       +
         Future<void> signOut() async {

     

       42
       42
       +
           _isAuthenticated = false;

     

       43
       43
       +
           _did = null;

     

       44
       44
       +
           _handle = null;

     

       45
       45
       +
           notifyListeners();

     

       46
       46
       +
         }

     

       47
       47
       +
       }

     

       48
       48
       +
       

     

       49
       49
       +
       void main() {

     

       50
       50
       +
         group('CreatePostScreen Widget Tests', () {

     

       51
       51
       +
           late FakeAuthProvider fakeAuthProvider;

     

       52
       52
       +
       

     

       53
       53
       +
           setUp(() {

     

       54
       54
       +
             fakeAuthProvider = FakeAuthProvider();

     

       55
       55
       +
           });

     

       56
       56
       +
       

     

       57
       57
       +
           Widget createTestWidget({VoidCallback? onNavigateToFeed}) {

     

       58
       58
       +
             return MultiProvider(

     

       59
       59
       +
               providers: [

     

       60
       60
       +
                 ChangeNotifierProvider<AuthProvider>.value(value: fakeAuthProvider),

     

       61
       61
       +
               ],

     

       62
       62
       +
               child: MaterialApp(

     

       63
       63
       +
                 home: CreatePostScreen(onNavigateToFeed: onNavigateToFeed),

     

       64
       64
       +
               ),

     

       65
       65
       +
             );

     

       66
       66
       +
           }

     

       67
       67
       +
       

     

       68
       68
       +
           testWidgets('should display Create Post title', (tester) async {

     

       69
       69
       +
             await tester.pumpWidget(createTestWidget());

     

       70
       70
       +
             await tester.pumpAndSettle();

     

       71
       71
       +
       

     

       72
       72
       +
             expect(find.text('Create Post'), findsOneWidget);

     

       73
       73
       +
           });

     

       74
       74
       +
       

     

       75
       75
       +
           testWidgets('should display user handle', (tester) async {

     

       76
       76
       +
             await tester.pumpWidget(createTestWidget());

     

       77
       77
       +
             await tester.pumpAndSettle();

     

       78
       78
       +
       

     

       79
       79
       +
             expect(find.text('@testuser.coves.social'), findsOneWidget);

     

       80
       80
       +
           });

     

       81
       81
       +
       

     

       82
       82
       +
           testWidgets('should display community selector', (tester) async {

     

       83
       83
       +
             await tester.pumpWidget(createTestWidget());

     

       84
       84
       +
             await tester.pumpAndSettle();

     

       85
       85
       +
       

     

       86
       86
       +
             expect(find.text('Select a community'), findsOneWidget);

     

       87
       87
       +
           });

     

       88
       88
       +
       

     

       89
       89
       +
           testWidgets('should display title field', (tester) async {

     

       90
       90
       +
             await tester.pumpWidget(createTestWidget());

     

       91
       91
       +
             await tester.pumpAndSettle();

     

       92
       92
       +
       

     

       93
       93
       +
             expect(find.widgetWithText(TextField, 'Title'), findsOneWidget);

     

       94
       94
       +
           });

     

       95
       95
       +
       

     

       96
       96
       +
           testWidgets('should display URL field', (tester) async {

     

       97
       97
       +
             await tester.pumpWidget(createTestWidget());

     

       98
       98
       +
             await tester.pumpAndSettle();

     

       99
       99
       +
       

     

       100
       100
       +
             expect(find.widgetWithText(TextField, 'URL'), findsOneWidget);

     

       101
       101
       +
           });

     

       102
       102
       +
       

     

       103
       103
       +
           testWidgets('should display body field', (tester) async {

     

       104
       104
       +
             await tester.pumpWidget(createTestWidget());

     

       105
       105
       +
             await tester.pumpAndSettle();

     

       106
       106
       +
       

     

       107
       107
       +
             expect(

     

       108
       108
       +
               find.widgetWithText(TextField, 'What are your thoughts?'),

     

       109
       109
       +
               findsOneWidget,

     

       110
       110
       +
             );

     

       111
       111
       +
           });

     

       112
       112
       +
       

     

       113
       113
       +
           testWidgets('should display language dropdown', (tester) async {

     

       114
       114
       +
             await tester.pumpWidget(createTestWidget());

     

       115
       115
       +
             await tester.pumpAndSettle();

     

       116
       116
       +
       

     

       117
       117
       +
             // Default language should be English

     

       118
       118
       +
             expect(find.text('English'), findsOneWidget);

     

       119
       119
       +
           });

     

       120
       120
       +
       

     

       121
       121
       +
           testWidgets('should display NSFW toggle', (tester) async {

     

       122
       122
       +
             await tester.pumpWidget(createTestWidget());

     

       123
       123
       +
             await tester.pumpAndSettle();

     

       124
       124
       +
       

     

       125
       125
       +
             expect(find.text('NSFW'), findsOneWidget);

     

       126
       126
       +
             expect(find.byType(Switch), findsOneWidget);

     

       127
       127
       +
           });

     

       128
       128
       +
       

     

       129
       129
       +
           testWidgets('should have disabled Post button initially', (tester) async {

     

       130
       130
       +
             await tester.pumpWidget(createTestWidget());

     

       131
       131
       +
             await tester.pumpAndSettle();

     

       132
       132
       +
       

     

       133
       133
       +
             // Find the Post button

     

       134
       134
       +
             final postButton = find.widgetWithText(TextButton, 'Post');

     

       135
       135
       +
             expect(postButton, findsOneWidget);

     

       136
       136
       +
       

     

       137
       137
       +
             // Button should be disabled (no community selected, no content)

     

       138
       138
       +
             final button = tester.widget<TextButton>(postButton);

     

       139
       139
       +
             expect(button.onPressed, isNull);

     

       140
       140
       +
           });

     

       141
       141
       +
       

     

       142
       142
       +
           testWidgets('should enable Post button when title is entered and community selected', (tester) async {

     

       143
       143
       +
             await tester.pumpWidget(createTestWidget());

     

       144
       144
       +
             await tester.pumpAndSettle();

     

       145
       145
       +
       

     

       146
       146
       +
             // Enter a title

     

       147
       147
       +
             await tester.enterText(find.widgetWithText(TextField, 'Title'), 'Test Post');

     

       148
       148
       +
             await tester.pumpAndSettle();

     

       149
       149
       +
       

     

       150
       150
       +
             // Post button should still be disabled (no community selected)

     

       151
       151
       +
             final postButton = find.widgetWithText(TextButton, 'Post');

     

       152
       152
       +
             final button = tester.widget<TextButton>(postButton);

     

       153
       153
       +
             expect(button.onPressed, isNull);

     

       154
       154
       +
           });

     

       155
       155
       +
       

     

       156
       156
       +
           testWidgets('should toggle NSFW switch', (tester) async {

     

       157
       157
       +
             await tester.pumpWidget(createTestWidget());

     

       158
       158
       +
             await tester.pumpAndSettle();

     

       159
       159
       +
       

     

       160
       160
       +
             // Find the switch

     

       161
       161
       +
             final switchWidget = find.byType(Switch);

     

       162
       162
       +
             expect(switchWidget, findsOneWidget);

     

       163
       163
       +
       

     

       164
       164
       +
             // Initially should be off

     

       165
       165
       +
             Switch switchBefore = tester.widget<Switch>(switchWidget);

     

       166
       166
       +
             expect(switchBefore.value, false);

     

       167
       167
       +
       

     

       168
       168
       +
             // Scroll to make switch visible, then tap

     

       169
       169
       +
             await tester.ensureVisible(switchWidget);

     

       170
       170
       +
             await tester.pumpAndSettle();

     

       171
       171
       +
             await tester.tap(switchWidget);

     

       172
       172
       +
             await tester.pumpAndSettle();

     

       173
       173
       +
       

     

       174
       174
       +
             // Should be on now

     

       175
       175
       +
             Switch switchAfter = tester.widget<Switch>(switchWidget);

     

       176
       176
       +
             expect(switchAfter.value, true);

     

       177
       177
       +
           });

     

       178
       178
       +
       

     

       179
       179
       +
           testWidgets('should show thumbnail field when URL is entered', (tester) async {

     

       180
       180
       +
             await tester.pumpWidget(createTestWidget());

     

       181
       181
       +
             await tester.pumpAndSettle();

     

       182
       182
       +
       

     

       183
       183
       +
             // Initially no thumbnail field

     

       184
       184
       +
             expect(find.widgetWithText(TextField, 'Thumbnail URL'), findsNothing);

     

       185
       185
       +
       

     

       186
       186
       +
             // Enter a URL

     

       187
       187
       +
             await tester.enterText(

     

       188
       188
       +
               find.widgetWithText(TextField, 'URL'),

     

       189
       189
       +
               'https://example.com',

     

       190
       190
       +
             );

     

       191
       191
       +
             await tester.pumpAndSettle();

     

       192
       192
       +
       

     

       193
       193
       +
             // Thumbnail field should now be visible

     

       194
       194
       +
             expect(find.widgetWithText(TextField, 'Thumbnail URL'), findsOneWidget);

     

       195
       195
       +
           });

     

       196
       196
       +
       

     

       197
       197
       +
           testWidgets('should hide thumbnail field when URL is cleared', (tester) async {

     

       198
       198
       +
             await tester.pumpWidget(createTestWidget());

     

       199
       199
       +
             await tester.pumpAndSettle();

     

       200
       200
       +
       

     

       201
       201
       +
             // Enter a URL

     

       202
       202
       +
             final urlField = find.widgetWithText(TextField, 'URL');

     

       203
       203
       +
             await tester.enterText(urlField, 'https://example.com');

     

       204
       204
       +
             await tester.pumpAndSettle();

     

       205
       205
       +
       

     

       206
       206
       +
             // Thumbnail field should be visible

     

       207
       207
       +
             expect(find.widgetWithText(TextField, 'Thumbnail URL'), findsOneWidget);

     

       208
       208
       +
       

     

       209
       209
       +
             // Clear the URL

     

       210
       210
       +
             await tester.enterText(urlField, '');

     

       211
       211
       +
             await tester.pumpAndSettle();

     

       212
       212
       +
       

     

       213
       213
       +
             // Thumbnail field should be hidden

     

       214
       214
       +
             expect(find.widgetWithText(TextField, 'Thumbnail URL'), findsNothing);

     

       215
       215
       +
           });

     

       216
       216
       +
       

     

       217
       217
       +
           testWidgets('should display close button', (tester) async {

     

       218
       218
       +
             await tester.pumpWidget(createTestWidget());

     

       219
       219
       +
             await tester.pumpAndSettle();

     

       220
       220
       +
       

     

       221
       221
       +
             expect(find.byIcon(Icons.close), findsOneWidget);

     

       222
       222
       +
           });

     

       223
       223
       +
       

     

       224
       224
       +
           testWidgets('should call onNavigateToFeed when close button is tapped', (tester) async {

     

       225
       225
       +
             bool callbackCalled = false;

     

       226
       226
       +
       

     

       227
       227
       +
             await tester.pumpWidget(

     

       228
       228
       +
               createTestWidget(onNavigateToFeed: () => callbackCalled = true),

     

       229
       229
       +
             );

     

       230
       230
       +
             await tester.pumpAndSettle();

     

       231
       231
       +
       

     

       232
       232
       +
             await tester.tap(find.byIcon(Icons.close));

     

       233
       233
       +
             await tester.pumpAndSettle();

     

       234
       234
       +
       

     

       235
       235
       +
             expect(callbackCalled, true);

     

       236
       236
       +
           });

     

       237
       237
       +
       

     

       238
       238
       +
           testWidgets('should have character limit on title field', (tester) async {

     

       239
       239
       +
             await tester.pumpWidget(createTestWidget());

     

       240
       240
       +
             await tester.pumpAndSettle();

     

       241
       241
       +
       

     

       242
       242
       +
             // Find the title TextField

     

       243
       243
       +
             final titleField = find.widgetWithText(TextField, 'Title');

     

       244
       244
       +
             final textField = tester.widget<TextField>(titleField);

     

       245
       245
       +
       

     

       246
       246
       +
             // Should have maxLength set to 300 (kTitleMaxLength)

     

       247
       247
       +
             expect(textField.maxLength, 300);

     

       248
       248
       +
           });

     

       249
       249
       +
       

     

       250
       250
       +
           testWidgets('should have character limit on body field', (tester) async {

     

       251
       251
       +
             await tester.pumpWidget(createTestWidget());

     

       252
       252
       +
             await tester.pumpAndSettle();

     

       253
       253
       +
       

     

       254
       254
       +
             // Find the body TextField

     

       255
       255
       +
             final bodyField = find.widgetWithText(TextField, 'What are your thoughts?');

     

       256
       256
       +
             final textField = tester.widget<TextField>(bodyField);

     

       257
       257
       +
       

     

       258
       258
       +
             // Should have maxLength set to 10000 (kContentMaxLength)

     

       259
       259
       +
             expect(textField.maxLength, 10000);

     

       260
       260
       +
           });

     

       261
       261
       +
       

     

       262
       262
       +
           testWidgets('should be scrollable', (tester) async {

     

       263
       263
       +
             await tester.pumpWidget(createTestWidget());

     

       264
       264
       +
             await tester.pumpAndSettle();

     

       265
       265
       +
       

     

       266
       266
       +
             // Should have a SingleChildScrollView

     

       267
       267
       +
             expect(find.byType(SingleChildScrollView), findsOneWidget);

     

       268
       268
       +
           });

     

       269
       269
       +
         });

     

       270
       270
       +
       

     

       271
       271
       +
         group('CreatePostScreen Form Validation', () {

     

       272
       272
       +
           late FakeAuthProvider fakeAuthProvider;

     

       273
       273
       +
       

     

       274
       274
       +
           setUp(() {

     

       275
       275
       +
             fakeAuthProvider = FakeAuthProvider();

     

       276
       276
       +
           });

     

       277
       277
       +
       

     

       278
       278
       +
           Widget createTestWidget() {

     

       279
       279
       +
             return MultiProvider(

     

       280
       280
       +
               providers: [

     

       281
       281
       +
                 ChangeNotifierProvider<AuthProvider>.value(value: fakeAuthProvider),

     

       282
       282
       +
               ],

     

       283
       283
       +
               child: const MaterialApp(home: CreatePostScreen()),

     

       284
       284
       +
             );

     

       285
       285
       +
           }

     

       286
       286
       +
       

     

       287
       287
       +
           testWidgets('form is invalid with no community and no content', (tester) async {

     

       288
       288
       +
             await tester.pumpWidget(createTestWidget());

     

       289
       289
       +
             await tester.pumpAndSettle();

     

       290
       290
       +
       

     

       291
       291
       +
             final postButton = find.widgetWithText(TextButton, 'Post');

     

       292
       292
       +
             final button = tester.widget<TextButton>(postButton);

     

       293
       293
       +
             expect(button.onPressed, isNull);

     

       294
       294
       +
           });

     

       295
       295
       +
       

     

       296
       296
       +
           testWidgets('form is invalid with content but no community', (tester) async {

     

       297
       297
       +
             await tester.pumpWidget(createTestWidget());

     

       298
       298
       +
             await tester.pumpAndSettle();

     

       299
       299
       +
       

     

       300
       300
       +
             // Enter title

     

       301
       301
       +
             await tester.enterText(find.widgetWithText(TextField, 'Title'), 'Test');

     

       302
       302
       +
             await tester.pumpAndSettle();

     

       303
       303
       +
       

     

       304
       304
       +
             final postButton = find.widgetWithText(TextButton, 'Post');

     

       305
       305
       +
             final button = tester.widget<TextButton>(postButton);

     

       306
       306
       +
             expect(button.onPressed, isNull);

     

       307
       307
       +
           });

     

       308
       308
       +
       

     

       309
       309
       +
           testWidgets('entering text updates form state', (tester) async {

     

       310
       310
       +
             await tester.pumpWidget(createTestWidget());

     

       311
       311
       +
             await tester.pumpAndSettle();

     

       312
       312
       +
       

     

       313
       313
       +
             // Enter title

     

       314
       314
       +
             await tester.enterText(

     

       315
       315
       +
               find.widgetWithText(TextField, 'Title'),

     

       316
       316
       +
               'My Test Post',

     

       317
       317
       +
             );

     

       318
       318
       +
             await tester.pumpAndSettle();

     

       319
       319
       +
       

     

       320
       320
       +
             // Verify text was entered

     

       321
       321
       +
             expect(find.text('My Test Post'), findsOneWidget);

     

       322
       322
       +
           });

     

       323
       323
       +
       

     

       324
       324
       +
           testWidgets('entering body text updates form state', (tester) async {

     

       325
       325
       +
             await tester.pumpWidget(createTestWidget());

     

       326
       326
       +
             await tester.pumpAndSettle();

     

       327
       327
       +
       

     

       328
       328
       +
             // Enter body

     

       329
       329
       +
             await tester.enterText(

     

       330
       330
       +
               find.widgetWithText(TextField, 'What are your thoughts?'),

     

       331
       331
       +
               'This is my post content',

     

       332
       332
       +
             );

     

       333
       333
       +
             await tester.pumpAndSettle();

     

       334
       334
       +
       

     

       335
       335
       +
             // Verify text was entered

     

       336
       336
       +
             expect(find.text('This is my post content'), findsOneWidget);

     

       337
       337
       +
           });

     

       338
       338
       +
         });

     

       339
       339
       +
       }

+463

test/services/coves_api_service_community_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/models/community.dart';

     

       2
       2
       +
       import 'package:coves_flutter/services/api_exceptions.dart';

     

       3
       3
       +
       import 'package:coves_flutter/services/coves_api_service.dart';

     

       4
       4
       +
       import 'package:dio/dio.dart';

     

       5
       5
       +
       import 'package:flutter_test/flutter_test.dart';

     

       6
       6
       +
       import 'package:http_mock_adapter/http_mock_adapter.dart';

     

       7
       7
       +
       

     

       8
       8
       +
       void main() {

     

       9
       9
       +
         TestWidgetsFlutterBinding.ensureInitialized();

     

       10
       10
       +
       

     

       11
       11
       +
         group('CovesApiService - listCommunities', () {

     

       12
       12
       +
           late Dio dio;

     

       13
       13
       +
           late DioAdapter dioAdapter;

     

       14
       14
       +
           late CovesApiService apiService;

     

       15
       15
       +
       

     

       16
       16
       +
           setUp(() {

     

       17
       17
       +
             dio = Dio(BaseOptions(baseUrl: 'https://api.test.coves.social'));

     

       18
       18
       +
             dioAdapter = DioAdapter(dio: dio);

     

       19
       19
       +
             apiService = CovesApiService(

     

       20
       20
       +
               dio: dio,

     

       21
       21
       +
               tokenGetter: () async => 'test-token',

     

       22
       22
       +
             );

     

       23
       23
       +
           });

     

       24
       24
       +
       

     

       25
       25
       +
           tearDown(() {

     

       26
       26
       +
             apiService.dispose();

     

       27
       27
       +
           });

     

       28
       28
       +
       

     

       29
       29
       +
           test('should successfully fetch communities', () async {

     

       30
       30
       +
             final mockResponse = {

     

       31
       31
       +
               'communities': [

     

       32
       32
       +
                 {

     

       33
       33
       +
                   'did': 'did:plc:community1',

     

       34
       34
       +
                   'name': 'test-community-1',

     

       35
       35
       +
                   'displayName': 'Test Community 1',

     

       36
       36
       +
                   'subscriberCount': 100,

     

       37
       37
       +
                   'memberCount': 50,

     

       38
       38
       +
                 },

     

       39
       39
       +
                 {

     

       40
       40
       +
                   'did': 'did:plc:community2',

     

       41
       41
       +
                   'name': 'test-community-2',

     

       42
       42
       +
                   'displayName': 'Test Community 2',

     

       43
       43
       +
                   'subscriberCount': 200,

     

       44
       44
       +
                   'memberCount': 100,

     

       45
       45
       +
                 },

     

       46
       46
       +
               ],

     

       47
       47
       +
               'cursor': 'next-cursor',

     

       48
       48
       +
             };

     

       49
       49
       +
       

     

       50
       50
       +
             dioAdapter.onGet(

     

       51
       51
       +
               '/xrpc/social.coves.community.list',

     

       52
       52
       +
               (server) => server.reply(200, mockResponse),

     

       53
       53
       +
               queryParameters: {

     

       54
       54
       +
                 'limit': 50,

     

       55
       55
       +
                 'sort': 'popular',

     

       56
       56
       +
               },

     

       57
       57
       +
             );

     

       58
       58
       +
       

     

       59
       59
       +
             final response = await apiService.listCommunities();

     

       60
       60
       +
       

     

       61
       61
       +
             expect(response, isA<CommunitiesResponse>());

     

       62
       62
       +
             expect(response.communities.length, 2);

     

       63
       63
       +
             expect(response.cursor, 'next-cursor');

     

       64
       64
       +
             expect(response.communities[0].did, 'did:plc:community1');

     

       65
       65
       +
             expect(response.communities[0].name, 'test-community-1');

     

       66
       66
       +
             expect(response.communities[1].did, 'did:plc:community2');

     

       67
       67
       +
           });

     

       68
       68
       +
       

     

       69
       69
       +
           test('should handle empty communities response', () async {

     

       70
       70
       +
             final mockResponse = {

     

       71
       71
       +
               'communities': [],

     

       72
       72
       +
               'cursor': null,

     

       73
       73
       +
             };

     

       74
       74
       +
       

     

       75
       75
       +
             dioAdapter.onGet(

     

       76
       76
       +
               '/xrpc/social.coves.community.list',

     

       77
       77
       +
               (server) => server.reply(200, mockResponse),

     

       78
       78
       +
               queryParameters: {

     

       79
       79
       +
                 'limit': 50,

     

       80
       80
       +
                 'sort': 'popular',

     

       81
       81
       +
               },

     

       82
       82
       +
             );

     

       83
       83
       +
       

     

       84
       84
       +
             final response = await apiService.listCommunities();

     

       85
       85
       +
       

     

       86
       86
       +
             expect(response.communities, isEmpty);

     

       87
       87
       +
             expect(response.cursor, null);

     

       88
       88
       +
           });

     

       89
       89
       +
       

     

       90
       90
       +
           test('should handle null communities array', () async {

     

       91
       91
       +
             final mockResponse = {

     

       92
       92
       +
               'communities': null,

     

       93
       93
       +
               'cursor': null,

     

       94
       94
       +
             };

     

       95
       95
       +
       

     

       96
       96
       +
             dioAdapter.onGet(

     

       97
       97
       +
               '/xrpc/social.coves.community.list',

     

       98
       98
       +
               (server) => server.reply(200, mockResponse),

     

       99
       99
       +
               queryParameters: {

     

       100
       100
       +
                 'limit': 50,

     

       101
       101
       +
                 'sort': 'popular',

     

       102
       102
       +
               },

     

       103
       103
       +
             );

     

       104
       104
       +
       

     

       105
       105
       +
             final response = await apiService.listCommunities();

     

       106
       106
       +
       

     

       107
       107
       +
             expect(response.communities, isEmpty);

     

       108
       108
       +
           });

     

       109
       109
       +
       

     

       110
       110
       +
           test('should fetch communities with custom limit', () async {

     

       111
       111
       +
             final mockResponse = {

     

       112
       112
       +
               'communities': [],

     

       113
       113
       +
               'cursor': null,

     

       114
       114
       +
             };

     

       115
       115
       +
       

     

       116
       116
       +
             dioAdapter.onGet(

     

       117
       117
       +
               '/xrpc/social.coves.community.list',

     

       118
       118
       +
               (server) => server.reply(200, mockResponse),

     

       119
       119
       +
               queryParameters: {

     

       120
       120
       +
                 'limit': 25,

     

       121
       121
       +
                 'sort': 'popular',

     

       122
       122
       +
               },

     

       123
       123
       +
             );

     

       124
       124
       +
       

     

       125
       125
       +
             final response = await apiService.listCommunities(limit: 25);

     

       126
       126
       +
       

     

       127
       127
       +
             expect(response, isA<CommunitiesResponse>());

     

       128
       128
       +
           });

     

       129
       129
       +
       

     

       130
       130
       +
           test('should fetch communities with cursor for pagination', () async {

     

       131
       131
       +
             const cursor = 'pagination-cursor-123';

     

       132
       132
       +
       

     

       133
       133
       +
             final mockResponse = {

     

       134
       134
       +
               'communities': [

     

       135
       135
       +
                 {

     

       136
       136
       +
                   'did': 'did:plc:community3',

     

       137
       137
       +
                   'name': 'paginated-community',

     

       138
       138
       +
                 },

     

       139
       139
       +
               ],

     

       140
       140
       +
               'cursor': 'next-cursor-456',

     

       141
       141
       +
             };

     

       142
       142
       +
       

     

       143
       143
       +
             dioAdapter.onGet(

     

       144
       144
       +
               '/xrpc/social.coves.community.list',

     

       145
       145
       +
               (server) => server.reply(200, mockResponse),

     

       146
       146
       +
               queryParameters: {

     

       147
       147
       +
                 'limit': 50,

     

       148
       148
       +
                 'sort': 'popular',

     

       149
       149
       +
                 'cursor': cursor,

     

       150
       150
       +
               },

     

       151
       151
       +
             );

     

       152
       152
       +
       

     

       153
       153
       +
             final response = await apiService.listCommunities(cursor: cursor);

     

       154
       154
       +
       

     

       155
       155
       +
             expect(response.communities.length, 1);

     

       156
       156
       +
             expect(response.cursor, 'next-cursor-456');

     

       157
       157
       +
           });

     

       158
       158
       +
       

     

       159
       159
       +
           test('should fetch communities with custom sort', () async {

     

       160
       160
       +
             final mockResponse = {

     

       161
       161
       +
               'communities': [],

     

       162
       162
       +
               'cursor': null,

     

       163
       163
       +
             };

     

       164
       164
       +
       

     

       165
       165
       +
             dioAdapter.onGet(

     

       166
       166
       +
               '/xrpc/social.coves.community.list',

     

       167
       167
       +
               (server) => server.reply(200, mockResponse),

     

       168
       168
       +
               queryParameters: {

     

       169
       169
       +
                 'limit': 50,

     

       170
       170
       +
                 'sort': 'new',

     

       171
       171
       +
               },

     

       172
       172
       +
             );

     

       173
       173
       +
       

     

       174
       174
       +
             final response = await apiService.listCommunities(sort: 'new');

     

       175
       175
       +
       

     

       176
       176
       +
             expect(response, isA<CommunitiesResponse>());

     

       177
       177
       +
           });

     

       178
       178
       +
       

     

       179
       179
       +
           test('should handle 401 unauthorized error', () async {

     

       180
       180
       +
             dioAdapter.onGet(

     

       181
       181
       +
               '/xrpc/social.coves.community.list',

     

       182
       182
       +
               (server) => server.reply(401, {

     

       183
       183
       +
                 'error': 'Unauthorized',

     

       184
       184
       +
                 'message': 'Invalid token',

     

       185
       185
       +
               }),

     

       186
       186
       +
               queryParameters: {

     

       187
       187
       +
                 'limit': 50,

     

       188
       188
       +
                 'sort': 'popular',

     

       189
       189
       +
               },

     

       190
       190
       +
             );

     

       191
       191
       +
       

     

       192
       192
       +
             expect(

     

       193
       193
       +
               () => apiService.listCommunities(),

     

       194
       194
       +
               throwsA(isA<AuthenticationException>()),

     

       195
       195
       +
             );

     

       196
       196
       +
           });

     

       197
       197
       +
       

     

       198
       198
       +
           test('should handle 500 server error', () async {

     

       199
       199
       +
             dioAdapter.onGet(

     

       200
       200
       +
               '/xrpc/social.coves.community.list',

     

       201
       201
       +
               (server) => server.reply(500, {

     

       202
       202
       +
                 'error': 'InternalServerError',

     

       203
       203
       +
                 'message': 'Database error',

     

       204
       204
       +
               }),

     

       205
       205
       +
               queryParameters: {

     

       206
       206
       +
                 'limit': 50,

     

       207
       207
       +
                 'sort': 'popular',

     

       208
       208
       +
               },

     

       209
       209
       +
             );

     

       210
       210
       +
       

     

       211
       211
       +
             expect(

     

       212
       212
       +
               () => apiService.listCommunities(),

     

       213
       213
       +
               throwsA(isA<ServerException>()),

     

       214
       214
       +
             );

     

       215
       215
       +
           });

     

       216
       216
       +
       

     

       217
       217
       +
           test('should handle network timeout', () async {

     

       218
       218
       +
             dioAdapter.onGet(

     

       219
       219
       +
               '/xrpc/social.coves.community.list',

     

       220
       220
       +
               (server) => server.throws(

     

       221
       221
       +
                 408,

     

       222
       222
       +
                 DioException.connectionTimeout(

     

       223
       223
       +
                   timeout: const Duration(seconds: 30),

     

       224
       224
       +
                   requestOptions: RequestOptions(),

     

       225
       225
       +
                 ),

     

       226
       226
       +
               ),

     

       227
       227
       +
               queryParameters: {

     

       228
       228
       +
                 'limit': 50,

     

       229
       229
       +
                 'sort': 'popular',

     

       230
       230
       +
               },

     

       231
       231
       +
             );

     

       232
       232
       +
       

     

       233
       233
       +
             expect(

     

       234
       234
       +
               () => apiService.listCommunities(),

     

       235
       235
       +
               throwsA(isA<NetworkException>()),

     

       236
       236
       +
             );

     

       237
       237
       +
           });

     

       238
       238
       +
         });

     

       239
       239
       +
       

     

       240
       240
       +
         group('CovesApiService - createPost', () {

     

       241
       241
       +
           late Dio dio;

     

       242
       242
       +
           late DioAdapter dioAdapter;

     

       243
       243
       +
           late CovesApiService apiService;

     

       244
       244
       +
       

     

       245
       245
       +
           setUp(() {

     

       246
       246
       +
             dio = Dio(BaseOptions(baseUrl: 'https://api.test.coves.social'));

     

       247
       247
       +
             dioAdapter = DioAdapter(dio: dio);

     

       248
       248
       +
             apiService = CovesApiService(

     

       249
       249
       +
               dio: dio,

     

       250
       250
       +
               tokenGetter: () async => 'test-token',

     

       251
       251
       +
             );

     

       252
       252
       +
           });

     

       253
       253
       +
       

     

       254
       254
       +
           tearDown(() {

     

       255
       255
       +
             apiService.dispose();

     

       256
       256
       +
           });

     

       257
       257
       +
       

     

       258
       258
       +
           test('should successfully create a post with all fields', () async {

     

       259
       259
       +
             final mockResponse = {

     

       260
       260
       +
               'uri': 'at://did:plc:user/social.coves.community.post/123',

     

       261
       261
       +
               'cid': 'bafyreicid123',

     

       262
       262
       +
             };

     

       263
       263
       +
       

     

       264
       264
       +
             dioAdapter.onPost(

     

       265
       265
       +
               '/xrpc/social.coves.community.post.create',

     

       266
       266
       +
               (server) => server.reply(200, mockResponse),

     

       267
       267
       +
               data: {

     

       268
       268
       +
                 'community': 'did:plc:community1',

     

       269
       269
       +
                 'title': 'Test Post Title',

     

       270
       270
       +
                 'content': 'Test post content',

     

       271
       271
       +
                 'embed': {

     

       272
       272
       +
                   'uri': 'https://example.com/article',

     

       273
       273
       +
                   'title': 'Article Title',

     

       274
       274
       +
                 },

     

       275
       275
       +
                 'langs': ['en'],

     

       276
       276
       +
                 'labels': {

     

       277
       277
       +
                   'values': [

     

       278
       278
       +
                     {'val': 'nsfw'},

     

       279
       279
       +
                   ],

     

       280
       280
       +
                 },

     

       281
       281
       +
               },

     

       282
       282
       +
             );

     

       283
       283
       +
       

     

       284
       284
       +
             final response = await apiService.createPost(

     

       285
       285
       +
               community: 'did:plc:community1',

     

       286
       286
       +
               title: 'Test Post Title',

     

       287
       287
       +
               content: 'Test post content',

     

       288
       288
       +
               embed: const ExternalEmbedInput(

     

       289
       289
       +
                 uri: 'https://example.com/article',

     

       290
       290
       +
                 title: 'Article Title',

     

       291
       291
       +
               ),

     

       292
       292
       +
               langs: ['en'],

     

       293
       293
       +
               labels: const SelfLabels(values: [SelfLabel(val: 'nsfw')]),

     

       294
       294
       +
             );

     

       295
       295
       +
       

     

       296
       296
       +
             expect(response, isA<CreatePostResponse>());

     

       297
       297
       +
             expect(response.uri, 'at://did:plc:user/social.coves.community.post/123');

     

       298
       298
       +
             expect(response.cid, 'bafyreicid123');

     

       299
       299
       +
           });

     

       300
       300
       +
       

     

       301
       301
       +
           test('should successfully create a minimal post', () async {

     

       302
       302
       +
             final mockResponse = {

     

       303
       303
       +
               'uri': 'at://did:plc:user/social.coves.community.post/456',

     

       304
       304
       +
               'cid': 'bafyreicid456',

     

       305
       305
       +
             };

     

       306
       306
       +
       

     

       307
       307
       +
             dioAdapter.onPost(

     

       308
       308
       +
               '/xrpc/social.coves.community.post.create',

     

       309
       309
       +
               (server) => server.reply(200, mockResponse),

     

       310
       310
       +
               data: {

     

       311
       311
       +
                 'community': 'did:plc:community1',

     

       312
       312
       +
                 'title': 'Just a title',

     

       313
       313
       +
               },

     

       314
       314
       +
             );

     

       315
       315
       +
       

     

       316
       316
       +
             final response = await apiService.createPost(

     

       317
       317
       +
               community: 'did:plc:community1',

     

       318
       318
       +
               title: 'Just a title',

     

       319
       319
       +
             );

     

       320
       320
       +
       

     

       321
       321
       +
             expect(response, isA<CreatePostResponse>());

     

       322
       322
       +
             expect(response.uri, 'at://did:plc:user/social.coves.community.post/456');

     

       323
       323
       +
           });

     

       324
       324
       +
       

     

       325
       325
       +
           test('should successfully create a link post', () async {

     

       326
       326
       +
             final mockResponse = {

     

       327
       327
       +
               'uri': 'at://did:plc:user/social.coves.community.post/789',

     

       328
       328
       +
               'cid': 'bafyreicid789',

     

       329
       329
       +
             };

     

       330
       330
       +
       

     

       331
       331
       +
             dioAdapter.onPost(

     

       332
       332
       +
               '/xrpc/social.coves.community.post.create',

     

       333
       333
       +
               (server) => server.reply(200, mockResponse),

     

       334
       334
       +
               data: {

     

       335
       335
       +
                 'community': 'did:plc:community1',

     

       336
       336
       +
                 'embed': {

     

       337
       337
       +
                   'uri': 'https://example.com/article',

     

       338
       338
       +
                 },

     

       339
       339
       +
               },

     

       340
       340
       +
             );

     

       341
       341
       +
       

     

       342
       342
       +
             final response = await apiService.createPost(

     

       343
       343
       +
               community: 'did:plc:community1',

     

       344
       344
       +
               embed: const ExternalEmbedInput(uri: 'https://example.com/article'),

     

       345
       345
       +
             );

     

       346
       346
       +
       

     

       347
       347
       +
             expect(response, isA<CreatePostResponse>());

     

       348
       348
       +
           });

     

       349
       349
       +
       

     

       350
       350
       +
           test('should handle 401 unauthorized error', () async {

     

       351
       351
       +
             dioAdapter.onPost(

     

       352
       352
       +
               '/xrpc/social.coves.community.post.create',

     

       353
       353
       +
               (server) => server.reply(401, {

     

       354
       354
       +
                 'error': 'Unauthorized',

     

       355
       355
       +
                 'message': 'Authentication required',

     

       356
       356
       +
               }),

     

       357
       357
       +
               data: {

     

       358
       358
       +
                 'community': 'did:plc:community1',

     

       359
       359
       +
                 'title': 'Test',

     

       360
       360
       +
               },

     

       361
       361
       +
             );

     

       362
       362
       +
       

     

       363
       363
       +
             expect(

     

       364
       364
       +
               () => apiService.createPost(

     

       365
       365
       +
                 community: 'did:plc:community1',

     

       366
       366
       +
                 title: 'Test',

     

       367
       367
       +
               ),

     

       368
       368
       +
               throwsA(isA<AuthenticationException>()),

     

       369
       369
       +
             );

     

       370
       370
       +
           });

     

       371
       371
       +
       

     

       372
       372
       +
           test('should handle 404 community not found', () async {

     

       373
       373
       +
             dioAdapter.onPost(

     

       374
       374
       +
               '/xrpc/social.coves.community.post.create',

     

       375
       375
       +
               (server) => server.reply(404, {

     

       376
       376
       +
                 'error': 'NotFound',

     

       377
       377
       +
                 'message': 'Community not found',

     

       378
       378
       +
               }),

     

       379
       379
       +
               data: {

     

       380
       380
       +
                 'community': 'did:plc:nonexistent',

     

       381
       381
       +
                 'title': 'Test',

     

       382
       382
       +
               },

     

       383
       383
       +
             );

     

       384
       384
       +
       

     

       385
       385
       +
             expect(

     

       386
       386
       +
               () => apiService.createPost(

     

       387
       387
       +
                 community: 'did:plc:nonexistent',

     

       388
       388
       +
                 title: 'Test',

     

       389
       389
       +
               ),

     

       390
       390
       +
               throwsA(isA<NotFoundException>()),

     

       391
       391
       +
             );

     

       392
       392
       +
           });

     

       393
       393
       +
       

     

       394
       394
       +
           test('should handle 400 validation error', () async {

     

       395
       395
       +
             dioAdapter.onPost(

     

       396
       396
       +
               '/xrpc/social.coves.community.post.create',

     

       397
       397
       +
               (server) => server.reply(400, {

     

       398
       398
       +
                 'error': 'ValidationError',

     

       399
       399
       +
                 'message': 'Title exceeds maximum length',

     

       400
       400
       +
               }),

     

       401
       401
       +
               data: {

     

       402
       402
       +
                 'community': 'did:plc:community1',

     

       403
       403
       +
                 'title': 'a' * 1000, // Very long title

     

       404
       404
       +
               },

     

       405
       405
       +
             );

     

       406
       406
       +
       

     

       407
       407
       +
             expect(

     

       408
       408
       +
               () => apiService.createPost(

     

       409
       409
       +
                 community: 'did:plc:community1',

     

       410
       410
       +
                 title: 'a' * 1000,

     

       411
       411
       +
               ),

     

       412
       412
       +
               throwsA(isA<ApiException>()),

     

       413
       413
       +
             );

     

       414
       414
       +
           });

     

       415
       415
       +
       

     

       416
       416
       +
           test('should handle 500 server error', () async {

     

       417
       417
       +
             dioAdapter.onPost(

     

       418
       418
       +
               '/xrpc/social.coves.community.post.create',

     

       419
       419
       +
               (server) => server.reply(500, {

     

       420
       420
       +
                 'error': 'InternalServerError',

     

       421
       421
       +
                 'message': 'Database error',

     

       422
       422
       +
               }),

     

       423
       423
       +
               data: {

     

       424
       424
       +
                 'community': 'did:plc:community1',

     

       425
       425
       +
                 'title': 'Test',

     

       426
       426
       +
               },

     

       427
       427
       +
             );

     

       428
       428
       +
       

     

       429
       429
       +
             expect(

     

       430
       430
       +
               () => apiService.createPost(

     

       431
       431
       +
                 community: 'did:plc:community1',

     

       432
       432
       +
                 title: 'Test',

     

       433
       433
       +
               ),

     

       434
       434
       +
               throwsA(isA<ServerException>()),

     

       435
       435
       +
             );

     

       436
       436
       +
           });

     

       437
       437
       +
       

     

       438
       438
       +
           test('should handle network timeout', () async {

     

       439
       439
       +
             dioAdapter.onPost(

     

       440
       440
       +
               '/xrpc/social.coves.community.post.create',

     

       441
       441
       +
               (server) => server.throws(

     

       442
       442
       +
                 408,

     

       443
       443
       +
                 DioException.connectionTimeout(

     

       444
       444
       +
                   timeout: const Duration(seconds: 30),

     

       445
       445
       +
                   requestOptions: RequestOptions(),

     

       446
       446
       +
                 ),

     

       447
       447
       +
               ),

     

       448
       448
       +
               data: {

     

       449
       449
       +
                 'community': 'did:plc:community1',

     

       450
       450
       +
                 'title': 'Test',

     

       451
       451
       +
               },

     

       452
       452
       +
             );

     

       453
       453
       +
       

     

       454
       454
       +
             expect(

     

       455
       455
       +
               () => apiService.createPost(

     

       456
       456
       +
                 community: 'did:plc:community1',

     

       457
       457
       +
                 title: 'Test',

     

       458
       458
       +
               ),

     

       459
       459
       +
               throwsA(isA<NetworkException>()),

     

       460
       460
       +
             );

     

       461
       461
       +
           });

     

       462
       462
       +
         });

     

       463
       463
       +
       }

+51 -44

lib/screens/home/post_detail_screen.dart

···

       37
       37
        
       /// - Loading, empty, and error states

     

       38
       38
        
       /// - Automatic comment loading on screen init

     

       39
       39
        
       class PostDetailScreen extends StatefulWidget {

     

       40
       40
       -
         const PostDetailScreen({required this.post, this.isOptimistic = false, super.key});

     

       40
       40
       +
         const PostDetailScreen({

     

       41
       41
       +
           required this.post,

     

       42
       42
       +
           this.isOptimistic = false,

     

       43
       43
       +
           super.key,

     

       44
       44
       +
         });

     

       41
       45
        
       

     

       42
       46
        
         /// Post to display (passed via route extras)

     

       43
       47
        
         final FeedViewPost post;

     
···

       51
       55
        
       }

     

       52
       56
        
       

     

       53
       57
        
       class _PostDetailScreenState extends State<PostDetailScreen> {

     

       54
       54
       -
         final ScrollController _scrollController = ScrollController();

     

       58
       58
       +
         // ScrollController created lazily with cached scroll position for instant restoration

     

       59
       59
       +
         late ScrollController _scrollController;

     

       55
       60
        
         final GlobalKey _commentsHeaderKey = GlobalKey();

     

       56
       61
        
       

     

       57
       62
        
         // Cached provider from CommentsProviderCache

     
···

       67
       72
        
         @override

     

       68
       73
        
         void initState() {

     

       69
       74
        
           super.initState();

     

       70
       70
       -
           _scrollController.addListener(_onScroll);

     

       75
       75
       +
           // ScrollController and provider initialization moved to didChangeDependencies

     

       76
       76
       +
           // where we have access to context for synchronous provider acquisition

     

       77
       77
       +
         }

     

       71
       78
        
       

     

       72
       72
       -
           // Initialize provider after frame is built

     

       73
       73
       -
           WidgetsBinding.instance.addPostFrameCallback((_) {

     

       74
       74
       -
             if (mounted) {

     

       75
       75
       -
               _initializeProvider();

     

       76
       76
       -
               _setupAuthListener();

     

       77
       77
       -
             }

     

       78
       78
       -
           });

     

       79
       79
       +
         @override

     

       80
       80
       +
         void didChangeDependencies() {

     

       81
       81
       +
           super.didChangeDependencies();

     

       82
       82
       +
           // Initialize provider synchronously on first call (has context access)

     

       83
       83
       +
           // This ensures cached data is available for the first build, avoiding

     

       84
       84
       +
           // the flash from loading state → content → scroll position jump

     

       85
       85
       +
           if (!_isInitialized) {

     

       86
       86
       +
             _initializeProviderSync();

     

       87
       87
       +
           }

     

       79
       88
        
         }

     

       80
       89
        
       

     

       81
       90
        
         /// Listen for auth state changes to handle sign-out

     
···

       92
       101
        
       

     

       93
       102
        
           // If user signed out while viewing this screen, navigate back

     

       94
       103
        
           // The CommentsProviderCache has already disposed our provider

     

       95
       95
       -
           if (!authProvider.isAuthenticated && _isInitialized && !_providerInvalidated) {

     

       104
       104
       +
           if (!authProvider.isAuthenticated &&

     

       105
       105
       +
               _isInitialized &&

     

       106
       106
       +
               !_providerInvalidated) {

     

       96
       107
        
             _providerInvalidated = true;

     

       97
       108
        
       

     

       98
       109
        
             if (kDebugMode) {

     
···

       113
       124
        
           }

     

       114
       125
        
         }

     

       115
       126
        
       

     

       116
       116
       -
         /// Initialize provider from cache and restore state

     

       117
       117
       -
         void _initializeProvider() {

     

       127
       127
       +
         /// Initialize provider synchronously from cache

     

       128
       128
       +
         ///

     

       129
       129
       +
         /// Called from didChangeDependencies to ensure cached data is available

     

       130
       130
       +
         /// for the first build. Creates ScrollController with initialScrollOffset

     

       131
       131
       +
         /// set to cached position for instant scroll restoration without flicker.

     

       132
       132
       +
         void _initializeProviderSync() {

     

       118
       133
        
           // Get or create provider from cache

     

       119
       134
        
           final cache = context.read<CommentsProviderCache>();

     

       120
       135
        
           _commentsCache = cache;

     
···

       123
       138
        
             postCid: widget.post.post.cid,

     

       124
       139
        
           );

     

       125
       140
        
       

     

       141
       141
       +
           // Create scroll controller with cached position for instant restoration

     

       142
       142
       +
           // This avoids the flash: loading → content at top → jump to cached position

     

       143
       143
       +
           final cachedScrollPosition = _commentsProvider.scrollPosition;

     

       144
       144
       +
           _scrollController = ScrollController(

     

       145
       145
       +
             initialScrollOffset: cachedScrollPosition,

     

       146
       146
       +
           );

     

       147
       147
       +
           _scrollController.addListener(_onScroll);

     

       148
       148
       +
       

     

       149
       149
       +
           if (kDebugMode && cachedScrollPosition > 0) {

     

       150
       150
       +
             debugPrint(

     

       151
       151
       +
               '📍 Created ScrollController with initial offset: $cachedScrollPosition',

     

       152
       152
       +
             );

     

       153
       153
       +
           }

     

       154
       154
       +
       

     

       126
       155
        
           // Listen for changes to trigger rebuilds

     

       127
       156
        
           _commentsProvider.addListener(_onProviderChanged);

     

       128
       157
        
       

     

       158
       158
       +
           // Setup auth listener

     

       159
       159
       +
           _setupAuthListener();

     

       160
       160
       +
       

     

       161
       161
       +
           // Mark as initialized before triggering any loads

     

       162
       162
       +
           // This ensures the first build shows content (not loading) when cached

     

       163
       163
       +
           _isInitialized = true;

     

       164
       164
       +
       

     

       129
       165
        
           // Skip loading for optimistic posts (just created, not yet indexed)

     

       130
       166
        
           if (widget.isOptimistic) {

     

       131
       167
        
             if (kDebugMode) {

     
···

       133
       169
        
             }

     

       134
       170
        
             // Don't load comments - there won't be any yet

     

       135
       171
        
           } else if (_commentsProvider.comments.isNotEmpty) {

     

       136
       136
       -
             // Already have data - restore scroll position immediately

     

       172
       172
       +
             // Already have cached data - it will render immediately

     

       137
       173
        
             if (kDebugMode) {

     

       138
       174
        
               debugPrint(

     

       139
       175
        
                 '📦 Using cached comments (${_commentsProvider.comments.length})',

     

       140
       176
        
               );

     

       141
       177
        
             }

     

       142
       142
       -
             _restoreScrollPosition();

     

       143
       178
        
       

     

       144
       144
       -
             // Background refresh if data is stale

     

       179
       179
       +
             // Background refresh if data is stale (won't cause flicker)

     

       145
       180
        
             if (_commentsProvider.isStale) {

     

       146
       181
        
               if (kDebugMode) {

     

       147
       182
        
                 debugPrint('🔄 Data stale, refreshing in background');

     
···

       152
       187
        
             // No cached data - load fresh

     

       153
       188
        
             _commentsProvider.loadComments(refresh: true);

     

       154
       189
        
           }

     

       155
       155
       -
       

     

       156
       156
       -
           setState(() {

     

       157
       157
       -
             _isInitialized = true;

     

       158
       158
       -
           });

     

       159
       190
        
         }

     

       160
       191
        
       

     

       161
       192
        
         @override

     
···

       196
       227
        
           }

     

       197
       228
        
         }

     

       198
       229
        
       

     

       199
       199
       -
         /// Restore scroll position from provider

     

       200
       200
       -
         void _restoreScrollPosition() {

     

       201
       201
       -
           final savedPosition = _commentsProvider.scrollPosition;

     

       202
       202
       -
           if (savedPosition <= 0) {

     

       203
       203
       -
             return;

     

       204
       204
       -
           }

     

       205
       205
       -
       

     

       206
       206
       -
           WidgetsBinding.instance.addPostFrameCallback((_) {

     

       207
       207
       -
             if (!mounted || !_scrollController.hasClients) {

     

       208
       208
       -
               return;

     

       209
       209
       -
             }

     

       210
       210
       -
       

     

       211
       211
       -
             final maxExtent = _scrollController.position.maxScrollExtent;

     

       212
       212
       -
             final targetPosition = savedPosition.clamp(0.0, maxExtent);

     

       213
       213
       -
       

     

       214
       214
       -
             if (targetPosition > 0) {

     

       215
       215
       -
               _scrollController.jumpTo(targetPosition);

     

       216
       216
       -
               if (kDebugMode) {

     

       217
       217
       -
                 debugPrint('📍 Restored scroll to $targetPosition (max: $maxExtent)');

     

       218
       218
       -
               }

     

       219
       219
       -
             }

     

       220
       220
       -
           });

     

       221
       221
       -
         }

     

       222
       222
       -
       

     

       223
       230
        
         /// Handle sort changes from dropdown

     

       224
       231
        
         Future<void> _onSortChanged(String newSort) async {

     

       225
       232
        
           final success = await _commentsProvider.setSortOption(newSort);

-335

lib/providers/feed_provider.dart

···

       1
       1
       -
       import 'dart:async';

     

       2
       2
       -
       

     

       3
       3
       -
       import 'package:flutter/foundation.dart';

     

       4
       4
       -
       import '../models/post.dart';

     

       5
       5
       -
       import '../services/coves_api_service.dart';

     

       6
       6
       -
       import 'auth_provider.dart';

     

       7
       7
       -
       import 'vote_provider.dart';

     

       8
       8
       -
       

     

       9
       9
       -
       /// Feed types available in the app

     

       10
       10
       -
       enum FeedType {

     

       11
       11
       -
         /// All posts across the network

     

       12
       12
       -
         discover,

     

       13
       13
       -
       

     

       14
       14
       -
         /// Posts from subscribed communities (authenticated only)

     

       15
       15
       -
         forYou,

     

       16
       16
       -
       }

     

       17
       17
       -
       

     

       18
       18
       -
       /// Feed Provider

     

       19
       19
       -
       ///

     

       20
       20
       -
       /// Manages feed state and fetching logic.

     

       21
       21
       -
       /// Supports both authenticated timeline and public discover feed.

     

       22
       22
       -
       ///

     

       23
       23
       -
       /// IMPORTANT: Accepts AuthProvider reference to fetch fresh access

     

       24
       24
       -
       /// tokens before each authenticated request (critical for atProto OAuth

     

       25
       25
       -
       /// token rotation).

     

       26
       26
       -
       class FeedProvider with ChangeNotifier {

     

       27
       27
       -
         FeedProvider(

     

       28
       28
       -
           this._authProvider, {

     

       29
       29
       -
           CovesApiService? apiService,

     

       30
       30
       -
           VoteProvider? voteProvider,

     

       31
       31
       -
         }) : _voteProvider = voteProvider {

     

       32
       32
       -
           // Use injected service (for testing) or create new one (for production)

     

       33
       33
       -
           // Pass token getter, refresh handler, and sign out handler to API service

     

       34
       34
       -
           // for automatic fresh token retrieval and automatic token refresh on 401

     

       35
       35
       -
           _apiService =

     

       36
       36
       -
               apiService ??

     

       37
       37
       -
               CovesApiService(

     

       38
       38
       -
                 tokenGetter: _authProvider.getAccessToken,

     

       39
       39
       -
                 tokenRefresher: _authProvider.refreshToken,

     

       40
       40
       -
                 signOutHandler: _authProvider.signOut,

     

       41
       41
       -
               );

     

       42
       42
       -
       

     

       43
       43
       -
           // Track initial auth state

     

       44
       44
       -
           _wasAuthenticated = _authProvider.isAuthenticated;

     

       45
       45
       -
       

     

       46
       46
       -
           // [P0 FIX] Listen to auth state changes and clear feed on sign-out

     

       47
       47
       -
           // This prevents privacy bug where logged-out users see their private

     

       48
       48
       -
           // timeline until they manually refresh.

     

       49
       49
       -
           _authProvider.addListener(_onAuthChanged);

     

       50
       50
       -
         }

     

       51
       51
       -
       

     

       52
       52
       -
         /// Handle authentication state changes

     

       53
       53
       -
         ///

     

       54
       54
       -
         /// Only clears and reloads feed when transitioning from authenticated

     

       55
       55
       -
         /// to unauthenticated (actual sign-out), not when staying unauthenticated

     

       56
       56
       -
         /// (e.g., failed sign-in attempt). This prevents unnecessary API calls.

     

       57
       57
       -
         void _onAuthChanged() {

     

       58
       58
       -
           final isAuthenticated = _authProvider.isAuthenticated;

     

       59
       59
       -
       

     

       60
       60
       -
           // Only reload if transitioning from authenticated → unauthenticated

     

       61
       61
       -
           if (_wasAuthenticated && !isAuthenticated && _posts.isNotEmpty) {

     

       62
       62
       -
             if (kDebugMode) {

     

       63
       63
       -
               debugPrint('🔒 User signed out - clearing feed');

     

       64
       64
       -
             }

     

       65
       65
       -
             // Reset feed type to Discover since For You requires auth

     

       66
       66
       -
             _feedType = FeedType.discover;

     

       67
       67
       -
             reset();

     

       68
       68
       -
             // Automatically load the public discover feed

     

       69
       69
       -
             loadFeed(refresh: true);

     

       70
       70
       -
           }

     

       71
       71
       -
       

     

       72
       72
       -
           // Update tracked state

     

       73
       73
       -
           _wasAuthenticated = isAuthenticated;

     

       74
       74
       -
         }

     

       75
       75
       -
       

     

       76
       76
       -
         final AuthProvider _authProvider;

     

       77
       77
       -
         late final CovesApiService _apiService;

     

       78
       78
       -
         final VoteProvider? _voteProvider;

     

       79
       79
       -
       

     

       80
       80
       -
         // Track previous auth state to detect transitions

     

       81
       81
       -
         bool _wasAuthenticated = false;

     

       82
       82
       -
       

     

       83
       83
       -
         // Feed state

     

       84
       84
       -
         List<FeedViewPost> _posts = [];

     

       85
       85
       -
         bool _isLoading = false;

     

       86
       86
       -
         bool _isLoadingMore = false;

     

       87
       87
       -
         String? _error;

     

       88
       88
       -
         String? _cursor;

     

       89
       89
       -
         bool _hasMore = true;

     

       90
       90
       -
       

     

       91
       91
       -
         // Feed configuration

     

       92
       92
       -
         String _sort = 'hot';

     

       93
       93
       -
         String? _timeframe;

     

       94
       94
       -
         FeedType _feedType = FeedType.discover;

     

       95
       95
       -
       

     

       96
       96
       -
         // Time update mechanism for periodic UI refreshes

     

       97
       97
       -
         Timer? _timeUpdateTimer;

     

       98
       98
       -
         DateTime? _currentTime;

     

       99
       99
       -
       

     

       100
       100
       -
         // Getters

     

       101
       101
       -
         List<FeedViewPost> get posts => _posts;

     

       102
       102
       -
         bool get isLoading => _isLoading;

     

       103
       103
       -
         bool get isLoadingMore => _isLoadingMore;

     

       104
       104
       -
         String? get error => _error;

     

       105
       105
       -
         bool get hasMore => _hasMore;

     

       106
       106
       -
         String get sort => _sort;

     

       107
       107
       -
         String? get timeframe => _timeframe;

     

       108
       108
       -
         DateTime? get currentTime => _currentTime;

     

       109
       109
       -
         FeedType get feedType => _feedType;

     

       110
       110
       -
       

     

       111
       111
       -
         /// Check if For You feed is available (requires authentication)

     

       112
       112
       -
         bool get isForYouAvailable => _authProvider.isAuthenticated;

     

       113
       113
       -
       

     

       114
       114
       -
         /// Start periodic time updates for "time ago" strings

     

       115
       115
       -
         ///

     

       116
       116
       -
         /// Updates currentTime every minute to trigger UI rebuilds for

     

       117
       117
       -
         /// post timestamps. This ensures "5m ago" updates to "6m ago" without

     

       118
       118
       -
         /// requiring user interaction.

     

       119
       119
       -
         void startTimeUpdates() {

     

       120
       120
       -
           // Cancel existing timer if any

     

       121
       121
       -
           _timeUpdateTimer?.cancel();

     

       122
       122
       -
       

     

       123
       123
       -
           // Update current time immediately

     

       124
       124
       -
           _currentTime = DateTime.now();

     

       125
       125
       -
           notifyListeners();

     

       126
       126
       -
       

     

       127
       127
       -
           // Set up periodic updates (every minute)

     

       128
       128
       -
           _timeUpdateTimer = Timer.periodic(const Duration(minutes: 1), (_) {

     

       129
       129
       -
             _currentTime = DateTime.now();

     

       130
       130
       -
             notifyListeners();

     

       131
       131
       -
           });

     

       132
       132
       -
       

     

       133
       133
       -
           if (kDebugMode) {

     

       134
       134
       -
             debugPrint('⏰ Started periodic time updates for feed timestamps');

     

       135
       135
       -
           }

     

       136
       136
       -
         }

     

       137
       137
       -
       

     

       138
       138
       -
         /// Stop periodic time updates

     

       139
       139
       -
         void stopTimeUpdates() {

     

       140
       140
       -
           _timeUpdateTimer?.cancel();

     

       141
       141
       -
           _timeUpdateTimer = null;

     

       142
       142
       -
           _currentTime = null;

     

       143
       143
       -
       

     

       144
       144
       -
           if (kDebugMode) {

     

       145
       145
       -
             debugPrint('⏰ Stopped periodic time updates');

     

       146
       146
       -
           }

     

       147
       147
       -
         }

     

       148
       148
       -
       

     

       149
       149
       -
         /// Load feed based on current feed type

     

       150
       150
       -
         ///

     

       151
       151
       -
         /// This method encapsulates the business logic of deciding which feed

     

       152
       152
       -
         /// to fetch based on the selected feed type.

     

       153
       153
       -
         Future<void> loadFeed({bool refresh = false}) async {

     

       154
       154
       -
           // For You requires authentication - fall back to Discover if not

     

       155
       155
       -
           if (_feedType == FeedType.forYou && _authProvider.isAuthenticated) {

     

       156
       156
       -
             await fetchTimeline(refresh: refresh);

     

       157
       157
       -
           } else {

     

       158
       158
       -
             await fetchDiscover(refresh: refresh);

     

       159
       159
       -
           }

     

       160
       160
       -
       

     

       161
       161
       -
           // Start time updates when feed is loaded

     

       162
       162
       -
           if (_posts.isNotEmpty && _timeUpdateTimer == null) {

     

       163
       163
       -
             startTimeUpdates();

     

       164
       164
       -
           }

     

       165
       165
       -
         }

     

       166
       166
       -
       

     

       167
       167
       -
         /// Switch feed type and reload

     

       168
       168
       -
         Future<void> setFeedType(FeedType type) async {

     

       169
       169
       -
           if (_feedType == type) {

     

       170
       170
       -
             return;

     

       171
       171
       -
           }

     

       172
       172
       -
       

     

       173
       173
       -
           // For You requires authentication

     

       174
       174
       -
           if (type == FeedType.forYou && !_authProvider.isAuthenticated) {

     

       175
       175
       -
             return;

     

       176
       176
       -
           }

     

       177
       177
       -
       

     

       178
       178
       -
           _feedType = type;

     

       179
       179
       -
           // Reset pagination state but keep posts visible until new feed loads

     

       180
       180
       -
           _cursor = null;

     

       181
       181
       -
           _hasMore = true;

     

       182
       182
       -
           _error = null;

     

       183
       183
       -
           notifyListeners();

     

       184
       184
       -
       

     

       185
       185
       -
           // Load new feed - old posts stay visible until new ones arrive

     

       186
       186
       -
           await loadFeed(refresh: true);

     

       187
       187
       -
         }

     

       188
       188
       -
       

     

       189
       189
       -
         /// Common feed fetching logic (DRY principle - eliminates code

     

       190
       190
       -
         /// duplication)

     

       191
       191
       -
         Future<void> _fetchFeed({

     

       192
       192
       -
           required bool refresh,

     

       193
       193
       -
           required Future<TimelineResponse> Function() fetcher,

     

       194
       194
       -
           required String feedName,

     

       195
       195
       -
         }) async {

     

       196
       196
       -
           if (_isLoading || _isLoadingMore) {

     

       197
       197
       -
             return;

     

       198
       198
       -
           }

     

       199
       199
       -
       

     

       200
       200
       -
           try {

     

       201
       201
       -
             if (refresh) {

     

       202
       202
       -
               _isLoading = true;

     

       203
       203
       -
               // DON'T clear _posts, _cursor, or _hasMore yet

     

       204
       204
       -
               // Keep existing data visible until refresh succeeds

     

       205
       205
       -
               // This prevents transient failures from wiping the user's feed

     

       206
       206
       -
               // and pagination state

     

       207
       207
       -
               _error = null;

     

       208
       208
       -
             } else {

     

       209
       209
       -
               _isLoadingMore = true;

     

       210
       210
       -
             }

     

       211
       211
       -
             notifyListeners();

     

       212
       212
       -
       

     

       213
       213
       -
             final response = await fetcher();

     

       214
       214
       -
       

     

       215
       215
       -
             // Only update state after successful fetch

     

       216
       216
       -
             if (refresh) {

     

       217
       217
       -
               _posts = response.feed;

     

       218
       218
       -
             } else {

     

       219
       219
       -
               // Create new list instance to trigger context.select rebuilds

     

       220
       220
       -
               // Using spread operator instead of addAll to ensure reference changes

     

       221
       221
       -
               _posts = [..._posts, ...response.feed];

     

       222
       222
       -
             }

     

       223
       223
       -
       

     

       224
       224
       -
             _cursor = response.cursor;

     

       225
       225
       -
             _hasMore = response.cursor != null;

     

       226
       226
       -
             _error = null;

     

       227
       227
       -
       

     

       228
       228
       -
             if (kDebugMode) {

     

       229
       229
       -
               debugPrint('✅ $feedName loaded: ${_posts.length} posts total');

     

       230
       230
       -
             }

     

       231
       231
       -
       

     

       232
       232
       -
             // Initialize vote state from viewer data in feed response

     

       233
       233
       -
             // IMPORTANT: Call setInitialVoteState for ALL feed items, even when

     

       234
       234
       -
             // viewer.vote is null. This ensures that if a user removed their vote

     

       235
       235
       -
             // on another device, the local state is cleared on refresh.

     

       236
       236
       -
             if (_authProvider.isAuthenticated && _voteProvider != null) {

     

       237
       237
       -
               for (final feedItem in response.feed) {

     

       238
       238
       -
                 final viewer = feedItem.post.viewer;

     

       239
       239
       -
                 _voteProvider.setInitialVoteState(

     

       240
       240
       -
                   postUri: feedItem.post.uri,

     

       241
       241
       -
                   voteDirection: viewer?.vote,

     

       242
       242
       -
                   voteUri: viewer?.voteUri,

     

       243
       243
       -
                 );

     

       244
       244
       -
               }

     

       245
       245
       -
             }

     

       246
       246
       -
           } on Exception catch (e) {

     

       247
       247
       -
             _error = e.toString();

     

       248
       248
       -
             if (kDebugMode) {

     

       249
       249
       -
               debugPrint('❌ Failed to fetch $feedName: $e');

     

       250
       250
       -
             }

     

       251
       251
       -
           } finally {

     

       252
       252
       -
             _isLoading = false;

     

       253
       253
       -
             _isLoadingMore = false;

     

       254
       254
       -
             notifyListeners();

     

       255
       255
       -
           }

     

       256
       256
       -
         }

     

       257
       257
       -
       

     

       258
       258
       -
         /// Fetch timeline feed (authenticated)

     

       259
       259
       -
         ///

     

       260
       260
       -
         /// Fetches the user's personalized timeline.

     

       261
       261
       -
         /// Authentication is handled automatically via tokenGetter.

     

       262
       262
       -
         Future<void> fetchTimeline({bool refresh = false}) => _fetchFeed(

     

       263
       263
       -
           refresh: refresh,

     

       264
       264
       -
           fetcher:

     

       265
       265
       -
               () => _apiService.getTimeline(

     

       266
       266
       -
                 sort: _sort,

     

       267
       267
       -
                 timeframe: _timeframe,

     

       268
       268
       -
                 cursor: refresh ? null : _cursor,

     

       269
       269
       -
               ),

     

       270
       270
       -
           feedName: 'Timeline',

     

       271
       271
       -
         );

     

       272
       272
       -
       

     

       273
       273
       -
         /// Fetch discover feed (public)

     

       274
       274
       -
         ///

     

       275
       275
       -
         /// Fetches the public discover feed.

     

       276
       276
       -
         /// Does not require authentication.

     

       277
       277
       -
         Future<void> fetchDiscover({bool refresh = false}) => _fetchFeed(

     

       278
       278
       -
           refresh: refresh,

     

       279
       279
       -
           fetcher:

     

       280
       280
       -
               () => _apiService.getDiscover(

     

       281
       281
       -
                 sort: _sort,

     

       282
       282
       -
                 timeframe: _timeframe,

     

       283
       283
       -
                 cursor: refresh ? null : _cursor,

     

       284
       284
       -
               ),

     

       285
       285
       -
           feedName: 'Discover',

     

       286
       286
       -
         );

     

       287
       287
       -
       

     

       288
       288
       -
         /// Load more posts (pagination)

     

       289
       289
       -
         Future<void> loadMore() async {

     

       290
       290
       -
           if (!_hasMore || _isLoadingMore) {

     

       291
       291
       -
             return;

     

       292
       292
       -
           }

     

       293
       293
       -
           await loadFeed();

     

       294
       294
       -
         }

     

       295
       295
       -
       

     

       296
       296
       -
         /// Change sort order

     

       297
       297
       -
         void setSort(String newSort, {String? newTimeframe}) {

     

       298
       298
       -
           _sort = newSort;

     

       299
       299
       -
           _timeframe = newTimeframe;

     

       300
       300
       -
           notifyListeners();

     

       301
       301
       -
         }

     

       302
       302
       -
       

     

       303
       303
       -
         /// Retry loading after error

     

       304
       304
       -
         Future<void> retry() async {

     

       305
       305
       -
           _error = null;

     

       306
       306
       -
           await loadFeed(refresh: true);

     

       307
       307
       -
         }

     

       308
       308
       -
       

     

       309
       309
       -
         /// Clear error

     

       310
       310
       -
         void clearError() {

     

       311
       311
       -
           _error = null;

     

       312
       312
       -
           notifyListeners();

     

       313
       313
       -
         }

     

       314
       314
       -
       

     

       315
       315
       -
         /// Reset feed state

     

       316
       316
       -
         void reset() {

     

       317
       317
       -
           _posts = [];

     

       318
       318
       -
           _cursor = null;

     

       319
       319
       -
           _hasMore = true;

     

       320
       320
       -
           _error = null;

     

       321
       321
       -
           _isLoading = false;

     

       322
       322
       -
           _isLoadingMore = false;

     

       323
       323
       -
           notifyListeners();

     

       324
       324
       -
         }

     

       325
       325
       -
       

     

       326
       326
       -
         @override

     

       327
       327
       -
         void dispose() {

     

       328
       328
       -
           // Stop time updates and cancel timer

     

       329
       329
       -
           stopTimeUpdates();

     

       330
       330
       -
           // Remove auth listener to prevent memory leaks

     

       331
       331
       -
           _authProvider.removeListener(_onAuthChanged);

     

       332
       332
       -
           _apiService.dispose();

     

       333
       333
       -
           super.dispose();

     

       334
       334
       -
         }

     

       335
       335
       -
       }

+4 -2

test/widget_test.dart

···

       1
       1
        
       import 'package:coves_flutter/main.dart';

     

       2
       2
        
       import 'package:coves_flutter/providers/auth_provider.dart';

     

       3
       3
       -
       import 'package:coves_flutter/providers/feed_provider.dart';

     

       3
       3
       +
       import 'package:coves_flutter/providers/multi_feed_provider.dart';

     

       4
       4
        
       import 'package:flutter/material.dart';

     

       5
       5
        
       import 'package:flutter_test/flutter_test.dart';

     

       6
       6
        
       import 'package:provider/provider.dart';

     
···

       15
       15
        
             MultiProvider(

     

       16
       16
        
               providers: [

     

       17
       17
        
                 ChangeNotifierProvider.value(value: authProvider),

     

       18
       18
       -
                 ChangeNotifierProvider(create: (_) => FeedProvider(authProvider)),

     

       18
       18
       +
                 ChangeNotifierProvider(

     

       19
       19
       +
                   create: (_) => MultiFeedProvider(authProvider),

     

       20
       20
       +
                 ),

     

       19
       21
        
               ],

     

       20
       22
        
               child: const CovesApp(),

     

       21
       23
        
             ),

+4 -4

pubspec.lock

···

       548
       548
        
           dependency: transitive

     

       549
       549
        
           description:

     

       550
       550
        
             name: meta

     

       551
       551
       -
             sha256: "23f08335362185a5ea2ad3a4e597f1375e78bce8a040df5c600c8d3552ef2394"

     

       551
       551
       +
             sha256: e3641ec5d63ebf0d9b41bd43201a66e3fc79a65db5f61fc181f04cd27aab950c

     

       552
       552
        
             url: "https://pub.dev"

     

       553
       553
        
           source: hosted

     

       554
       554
       -
           version: "1.17.0"

     

       554
       554
       +
           version: "1.16.0"

     

       555
       555
        
         mime:

     

       556
       556
        
           dependency: transitive

     

       557
       557
        
           description:

     
···

       937
       937
        
           dependency: transitive

     

       938
       938
        
           description:

     

       939
       939
        
             name: test_api

     

       940
       940
       -
             sha256: ab2726c1a94d3176a45960b6234466ec367179b87dd74f1611adb1f3b5fb9d55

     

       940
       940
       +
             sha256: "522f00f556e73044315fa4585ec3270f1808a4b186c936e612cab0b565ff1e00"

     

       941
       941
        
             url: "https://pub.dev"

     

       942
       942
        
           source: hosted

     

       943
       943
       -
           version: "0.7.7"

     

       943
       943
       +
           version: "0.7.6"

     

       944
       944
        
         typed_data:

     

       945
       945
        
           dependency: transitive

     

       946
       946
        
           description:

+9 -7

lib/screens/home/feed_screen.dart

···

       286
       286
        
       

     

       287
       287
        
         /// Switch to a feed type and animate PageView

     

       288
       288
        
         void _switchToFeedType(FeedType type, int pageIndex) {

     

       289
       289
       -
           final provider = context.read<MultiFeedProvider>();

     

       290
       290
       -
           provider.setCurrentFeed(type);

     

       289
       289
       +
           context.read<MultiFeedProvider>().setCurrentFeed(type);

     

       291
       290
        
       

     

       292
       291
        
           // Animate to the corresponding page

     

       293
       292
        
           _pageController.animateToPage(

     
···

       321
       320
        
         void _restoreScrollPosition(FeedType type) {

     

       322
       321
        
           // Wait for the next frame to ensure the controller has clients

     

       323
       322
        
           WidgetsBinding.instance.addPostFrameCallback((_) {

     

       324
       324
       -
             if (!mounted) return;

     

       323
       323
       +
             if (!mounted) {

     

       324
       324
       +
               return;

     

       325
       325
       +
             }

     

       325
       326
        
       

     

       326
       327
        
             final controller = _scrollControllers[type];

     

       327
       328
        
             if (controller != null && controller.hasClients) {

     
···

       379
       380
        
                 scrollController: _getOrCreateScrollController(feedType),

     

       380
       381
        
                 onRefresh: () => provider.loadFeed(feedType, refresh: true),

     

       381
       382
        
                 onRetry: () => provider.retry(feedType),

     

       382
       382
       -
                 onClearErrorAndLoadMore: () {

     

       383
       383
       -
                   provider.clearError(feedType);

     

       384
       384
       -
                   provider.loadMore(feedType);

     

       385
       385
       -
                 },

     

       383
       383
       +
                 onClearErrorAndLoadMore:

     

       384
       384
       +
                     () =>

     

       385
       385
       +
                         provider

     

       386
       386
       +
                           ..clearError(feedType)

     

       387
       387
       +
                           ..loadMore(feedType),

     

       386
       388
        
                 isAuthenticated: isAuthenticated,

     

       387
       389
        
                 currentTime: provider.currentTime,

     

       388
       390
        
               );

+3 -2

test/widgets/feed_screen_test.dart

···

       362
       362
        
             tester,

     

       363
       363
        
           ) async {

     

       364
       364
        
             fakeAuthProvider.setAuthenticated(value: true);

     

       365
       365
       -
             fakeFeedProvider.setPosts(FeedType.discover, [_createMockPost('Post 1')]);

     

       366
       366
       -
             fakeFeedProvider.setPosts(FeedType.forYou, [_createMockPost('Post 2')]);

     

       365
       365
       +
             fakeFeedProvider

     

       366
       366
       +
               ..setPosts(FeedType.discover, [_createMockPost('Post 1')])

     

       367
       367
       +
               ..setPosts(FeedType.forYou, [_createMockPost('Post 2')]);

     

       367
       368
        
       

     

       368
       369
        
             await tester.pumpWidget(createTestWidget());

     

       369
       370
        
             await tester.pumpAndSettle();

.claude/settings.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "enabledPlugins": {

     

       3
       3
       +
           "pr-review-toolkit@claude-plugins-official": true

     

       4
       4
       +
         }

     

       5
       5
       +
       }

+48

assets/icons/atproto/providers_landing.svg

···

       1
       1
       +
       <svg width="2266" height="825" viewBox="0 0 2266 825" fill="none" xmlns="http://www.w3.org/2000/svg">

     

       2
       2
       +
       <path d="M900 412.5C900 639.765 698.528 824 450 824C201.472 824 0 639.765 0 412.5C0 185.235 201.472 1 450 1C698.528 1 900 185.235 900 412.5Z" fill="#D9D9D9"/>

     

       3
       3
       +
       <path d="M2266 411.5C2266 638.765 2064.53 823 1816 823C1567.47 823 1366 638.765 1366 411.5C1366 184.235 1567.47 0 1816 0C2064.53 0 2266 184.235 2266 411.5Z" fill="#D9D9D9"/>

     

       4
       4
       +
       <path d="M2266 411.5C2266 638.765 2064.53 823 1816 823C1567.47 823 1366 638.765 1366 411.5C1366 184.235 1567.47 0 1816 0C2064.53 0 2266 184.235 2266 411.5Z" fill="url(#paint0_linear_41_51)"/>

     

       5
       5
       +
       <path d="M2266 411.5C2266 638.765 2064.53 823 1816 823C1567.47 823 1366 638.765 1366 411.5C1366 184.235 1567.47 0 1816 0C2064.53 0 2266 184.235 2266 411.5Z" fill="url(#paint1_linear_41_51)"/>

     

       6
       6
       +
       <path d="M1946.84 657.771H1828.59L1946.83 657.765V541.604L1946.84 657.771ZM1828.59 457.695C1828.59 488.549 1853.62 513.559 1884.49 513.559H1946.83V541.604H1884.49C1853.62 541.604 1828.59 566.615 1828.59 597.469V657.771L1802.53 657.765V597.469C1802.53 566.615 1777.5 541.605 1746.63 541.604H1684.29V513.559H1746.62C1777.5 513.559 1802.53 488.544 1802.53 457.688V395.392H1828.59V457.695Z" fill="black"/>

     

       7
       7
       +
       <path d="M1873.52 228.76C1851.69 250.579 1851.69 285.953 1873.52 307.771L1917.6 351.824L1897.76 371.653L1853.68 327.599C1831.85 305.781 1796.45 305.781 1774.62 327.599L1731.95 370.236L1713.53 351.823L1756.19 309.186C1778.03 287.368 1778.03 251.994 1756.19 230.176L1712.11 186.124L1731.95 166.295L1776.04 210.349C1797.87 232.167 1833.26 232.167 1855.1 210.349L1899.18 166.295L1917.6 184.707L1873.52 228.76Z" fill="black"/>

     

       8
       8
       +
       <path d="M1686.71 317.031C1678.72 346.835 1696.41 377.47 1726.24 385.456L1786.45 401.581L1779.19 428.665L1718.98 412.541C1689.15 404.555 1658.5 422.242 1650.51 452.046L1634.89 510.291L1609.72 503.551L1625.34 445.309C1633.33 415.505 1615.63 384.869 1585.81 376.884L1525.59 360.759L1532.85 333.672L1593.07 349.797C1622.89 357.784 1653.55 340.096 1661.54 310.292L1677.67 250.114L1702.84 256.853L1686.71 317.031Z" fill="black"/>

     

       9
       9
       +
       <path d="M1585 413.5C1585 640.765 1383.53 825 1135 825C886.472 825 685 640.765 685 413.5C685 186.235 886.472 2 1135 2C1383.53 2 1585 186.235 1585 413.5Z" fill="#D9D9D9"/>

     

       10
       10
       +
       <path d="M1585 413.5C1585 640.765 1383.53 825 1135 825C886.472 825 685 640.765 685 413.5C685 186.235 886.472 2 1135 2C1383.53 2 1585 186.235 1585 413.5Z" fill="url(#paint2_linear_41_51)"/>

     

       11
       11
       +
       <path d="M1585 413.5C1585 640.765 1383.53 825 1135 825C886.472 825 685 640.765 685 413.5C685 186.235 886.472 2 1135 2C1383.53 2 1585 186.235 1585 413.5Z" fill="url(#paint3_linear_41_51)"/>

     

       12
       12
       +
       <path d="M1227.39 691.928C1208.53 691.774 1194.14 686.291 1178.53 676.76C1156.15 664.983 1139.05 645.197 1126.84 623.382C1107.43 647.469 1081.49 662.084 1052.45 670.341C1040.08 673.933 1018.42 677.577 982.521 664.567C930.781 647.182 893.093 593.331 897.376 538.461C896.593 515.716 904.883 493.392 916.635 474.202C885.285 457.37 859.722 429.117 849.933 394.468C843.984 375.5 844.234 355.066 846.428 335.567C854.284 289.529 888.808 249.496 933.253 235.097C950.993 194.658 989.706 164.502 1033.57 158.362C1062.69 154.306 1092.83 160.404 1118.31 175.209C1155.43 134.029 1220.1 121.859 1269.48 147.155C1307.15 165.149 1334.08 202.689 1340.62 243.624C1376.46 257.987 1406.65 287.278 1418.5 324.461C1426.42 347.482 1426.68 372.84 1421.55 396.478C1412.39 433.363 1386.36 464.764 1352.66 481.926C1352.75 488.49 1374.32 535.818 1370.71 571.536C1369.92 616.189 1341.61 658.508 1302.34 679.064C1279.43 692.442 1252.27 692.19 1227.39 691.928ZM1120.02 563.391C1151.78 559.853 1172.6 532.155 1188.77 507.209C1196.41 495.846 1202.25 483.126 1208.06 471.03C1215.58 477.929 1221.96 490.926 1233.86 494.021C1246.39 497.926 1261.09 494.754 1268.76 483.364C1283.45 455.963 1276.21 422.901 1267.66 394.507C1262.39 378.198 1255.48 361.467 1242.33 349.908C1245.14 330.122 1233.42 310.028 1216.75 299.672C1202.55 310.998 1180.95 310.93 1167.25 298.814C1141 325.598 1116.94 324.709 1093.7 303.482C1088.47 298.711 1078.51 332.601 1043.53 313.403C1023.44 330.244 1007.86 346.445 994.052 369.771C980.637 394.919 966.588 417.253 965.377 444.562C964.795 460.523 977.264 477.246 994.158 475.948C1011.04 477.456 1022.54 460.833 1035.32 453.928C1037.23 476.204 1039.38 500.136 1046.9 521.883C1055.54 550.024 1085.97 567.91 1114.76 563.814C1116.8 563.655 1120.02 563.389 1120.02 563.391ZM1136.5 479.359C1121.05 469.889 1128.49 449.336 1127.87 434.408C1129.41 416.394 1130.64 397.454 1138.74 381.042C1147.3 369.341 1168.2 373.855 1169.12 388.868C1168.51 403.968 1161.58 419 1162.41 434.654C1160.61 447.726 1163.71 462.408 1157.93 474.355C1153.18 480.965 1143.52 482.887 1136.5 479.359ZM1069.04 470.755C1054.49 462.859 1059.11 442.989 1056.83 429.175C1058.72 413.181 1057.14 392.893 1070.53 381.677C1083.62 372.545 1101.44 388.184 1095.25 402.541C1088.65 420.686 1092.97 440.511 1093.11 458.909C1090.62 469.762 1079.01 475.523 1069.04 470.755Z" fill="black"/>

     

       13
       13
       +
       <path d="M1970.01 309.102C1978.01 338.906 2008.66 356.594 2038.48 348.608L2098.7 332.483L2105.96 359.567L2045.74 375.692C2015.92 383.678 1998.22 414.313 2006.21 444.117L2021.83 502.362L1996.66 509.101L1981.05 450.858C1973.06 421.054 1942.4 403.367 1912.58 411.352L1852.36 427.477L1845.1 400.392L1905.32 384.267C1935.14 376.28 1952.84 345.646 1944.85 315.841L1928.71 255.663L1953.88 248.925L1970.01 309.102Z" fill="black"/>

     

       14
       14
       +
       <path d="M900 412.5C900 639.765 698.528 824 450 824C201.472 824 0 639.765 0 412.5C0 185.235 201.472 1 450 1C698.528 1 900 185.235 900 412.5Z" fill="url(#paint4_linear_41_51)"/>

     

       15
       15
       +
       <path d="M900 412.5C900 639.765 698.528 824 450 824C201.472 824 0 639.765 0 412.5C0 185.235 201.472 1 450 1C698.528 1 900 185.235 900 412.5Z" fill="url(#paint5_linear_41_51)"/>

     

       16
       16
       +
       <path d="M900 412.5C900 639.765 698.528 824 450 824C201.472 824 0 639.765 0 412.5C0 185.235 201.472 1 450 1C698.528 1 900 185.235 900 412.5Z" fill="url(#paint6_linear_41_51)"/>

     

       17
       17
       +
       <path d="M285.723 191.375C352.219 241.296 423.743 342.515 450.003 396.835C476.265 342.519 547.785 241.295 614.283 191.375C662.263 155.354 740.003 127.483 740.003 216.17C740.003 233.882 729.848 364.96 723.892 386.24C703.189 460.224 627.748 479.094 560.642 467.673C677.942 487.637 707.782 553.765 643.339 619.893C520.949 745.483 467.429 588.382 453.709 548.127C451.195 540.747 450.019 537.295 450.001 540.231C449.984 537.295 448.808 540.747 446.294 548.127C432.58 588.382 379.061 745.487 256.664 619.893C192.22 553.765 222.059 487.633 339.361 467.673C272.253 479.094 196.811 460.223 176.111 386.24C170.153 364.958 160 233.88 160 216.17C160 127.483 237.742 155.354 285.72 191.375H285.723Z" fill="#1185FE"/>

     

       18
       18
       +
       <defs>

     

       19
       19
       +
       <linearGradient id="paint0_linear_41_51" x1="1133" y1="0" x2="1133" y2="825" gradientUnits="userSpaceOnUse">

     

       20
       20
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       21
       21
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       22
       22
       +
       </linearGradient>

     

       23
       23
       +
       <linearGradient id="paint1_linear_41_51" x1="1133" y1="0" x2="1133" y2="825" gradientUnits="userSpaceOnUse">

     

       24
       24
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       25
       25
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       26
       26
       +
       </linearGradient>

     

       27
       27
       +
       <linearGradient id="paint2_linear_41_51" x1="1133" y1="0" x2="1133" y2="825" gradientUnits="userSpaceOnUse">

     

       28
       28
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       29
       29
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       30
       30
       +
       </linearGradient>

     

       31
       31
       +
       <linearGradient id="paint3_linear_41_51" x1="1133" y1="0" x2="1133" y2="825" gradientUnits="userSpaceOnUse">

     

       32
       32
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       33
       33
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       34
       34
       +
       </linearGradient>

     

       35
       35
       +
       <linearGradient id="paint4_linear_41_51" x1="1136.96" y1="825" x2="1135.7" y2="-0.0100808" gradientUnits="userSpaceOnUse">

     

       36
       36
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       37
       37
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       38
       38
       +
       </linearGradient>

     

       39
       39
       +
       <linearGradient id="paint5_linear_41_51" x1="1136.96" y1="825" x2="1135.7" y2="-0.0100808" gradientUnits="userSpaceOnUse">

     

       40
       40
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       41
       41
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       42
       42
       +
       </linearGradient>

     

       43
       43
       +
       <linearGradient id="paint6_linear_41_51" x1="1136.96" y1="825" x2="1135.7" y2="-0.0100808" gradientUnits="userSpaceOnUse">

     

       44
       44
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       45
       45
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       46
       46
       +
       </linearGradient>

     

       47
       47
       +
       </defs>

     

       48
       48
       +
       </svg>

+132

assets/icons/atproto/providers_stack.svg

···

       1
       1
       +
       <svg width="2947" height="825" viewBox="0 0 2947 825" fill="none" xmlns="http://www.w3.org/2000/svg">

     

       2
       2
       +
       <path d="M1581 412.5C1581 639.765 1379.53 824 1131 824C882.472 824 681 639.765 681 412.5C681 185.235 882.472 1 1131 1C1379.53 1 1581 185.235 1581 412.5Z" fill="#D9D9D9"/>

     

       3
       3
       +
       <path d="M2947 411.5C2947 638.765 2745.53 823 2497 823C2248.47 823 2047 638.765 2047 411.5C2047 184.235 2248.47 0 2497 0C2745.53 0 2947 184.235 2947 411.5Z" fill="#D9D9D9"/>

     

       4
       4
       +
       <path d="M2947 411.5C2947 638.765 2745.53 823 2497 823C2248.47 823 2047 638.765 2047 411.5C2047 184.235 2248.47 0 2497 0C2745.53 0 2947 184.235 2947 411.5Z" fill="url(#paint0_linear_43_123)"/>

     

       5
       5
       +
       <path d="M2947 411.5C2947 638.765 2745.53 823 2497 823C2248.47 823 2047 638.765 2047 411.5C2047 184.235 2248.47 0 2497 0C2745.53 0 2947 184.235 2947 411.5Z" fill="url(#paint1_linear_43_123)"/>

     

       6
       6
       +
       <path d="M2627.84 657.771H2509.59L2627.83 657.765V541.604L2627.84 657.771ZM2509.59 457.695C2509.59 488.549 2534.62 513.559 2565.49 513.559H2627.83V541.604H2565.49C2534.62 541.604 2509.59 566.615 2509.59 597.469V657.771L2483.53 657.765V597.469C2483.53 566.615 2458.5 541.605 2427.63 541.604H2365.29V513.559H2427.62C2458.5 513.559 2483.53 488.544 2483.53 457.688V395.392H2509.59V457.695Z" fill="black"/>

     

       7
       7
       +
       <path d="M2554.52 228.76C2532.69 250.578 2532.69 285.953 2554.52 307.77L2598.6 351.824L2578.76 371.652L2534.68 327.599C2512.85 305.78 2477.45 305.78 2455.62 327.599L2412.95 370.236L2394.53 351.823L2437.19 309.186C2459.03 287.367 2459.03 251.994 2437.19 230.175L2393.11 186.123L2412.95 166.295L2457.04 210.348C2478.87 232.167 2514.27 232.167 2536.1 210.348L2580.18 166.295L2598.6 184.706L2554.52 228.76Z" fill="black"/>

     

       8
       8
       +
       <path d="M2367.71 317.031C2359.72 346.835 2377.41 377.471 2407.24 385.456L2467.45 401.581L2460.19 428.666L2399.98 412.541C2370.15 404.555 2339.5 422.242 2331.51 452.046L2315.89 510.291L2290.72 503.551L2306.34 445.309C2314.33 415.505 2296.63 384.87 2266.81 376.884L2206.59 360.759L2213.85 333.673L2274.07 349.798C2303.89 357.784 2334.55 340.096 2342.54 310.292L2358.67 250.114L2383.84 256.853L2367.71 317.031Z" fill="black"/>

     

       9
       9
       +
       <path d="M2266 413.5C2266 640.765 2064.53 825 1816 825C1567.47 825 1366 640.765 1366 413.5C1366 186.235 1567.47 2 1816 2C2064.53 2 2266 186.235 2266 413.5Z" fill="#D9D9D9"/>

     

       10
       10
       +
       <path d="M2266 413.5C2266 640.765 2064.53 825 1816 825C1567.47 825 1366 640.765 1366 413.5C1366 186.235 1567.47 2 1816 2C2064.53 2 2266 186.235 2266 413.5Z" fill="url(#paint2_linear_43_123)"/>

     

       11
       11
       +
       <path d="M2266 413.5C2266 640.765 2064.53 825 1816 825C1567.47 825 1366 640.765 1366 413.5C1366 186.235 1567.47 2 1816 2C2064.53 2 2266 186.235 2266 413.5Z" fill="url(#paint3_linear_43_123)"/>

     

       12
       12
       +
       <path d="M1908.39 691.928C1889.53 691.774 1875.14 686.291 1859.53 676.76C1837.15 664.983 1820.05 645.197 1807.84 623.382C1788.43 647.469 1762.49 662.084 1733.45 670.341C1721.08 673.933 1699.42 677.577 1663.52 664.567C1611.78 647.182 1574.09 593.331 1578.38 538.461C1577.59 515.716 1585.88 493.392 1597.64 474.202C1566.29 457.37 1540.72 429.117 1530.93 394.468C1524.98 375.5 1525.23 355.066 1527.43 335.567C1535.28 289.529 1569.81 249.496 1614.25 235.097C1631.99 194.658 1670.71 164.502 1714.57 158.362C1743.69 154.306 1773.83 160.404 1799.31 175.209C1836.43 134.029 1901.1 121.859 1950.48 147.155C1988.15 165.149 2015.08 202.689 2021.62 243.624C2057.46 257.987 2087.65 287.278 2099.5 324.461C2107.42 347.482 2107.68 372.84 2102.55 396.478C2093.39 433.363 2067.36 464.764 2033.66 481.926C2033.75 488.49 2055.32 535.818 2051.71 571.536C2050.92 616.189 2022.61 658.508 1983.34 679.064C1960.43 692.442 1933.27 692.19 1908.39 691.928ZM1801.02 563.391C1832.78 559.853 1853.6 532.155 1869.77 507.209C1877.41 495.846 1883.25 483.126 1889.06 471.03C1896.58 477.929 1902.96 490.926 1914.86 494.021C1927.39 497.926 1942.09 494.754 1949.76 483.364C1964.45 455.963 1957.21 422.901 1948.66 394.507C1943.39 378.198 1936.48 361.467 1923.33 349.908C1926.14 330.122 1914.42 310.028 1897.75 299.672C1883.55 310.998 1861.95 310.93 1848.25 298.814C1822 325.598 1797.94 324.709 1774.7 303.482C1769.47 298.711 1759.51 332.601 1724.53 313.403C1704.44 330.244 1688.86 346.445 1675.05 369.771C1661.64 394.919 1647.59 417.253 1646.38 444.562C1645.8 460.523 1658.26 477.246 1675.16 475.948C1692.04 477.456 1703.54 460.833 1716.32 453.928C1718.23 476.204 1720.38 500.136 1727.9 521.883C1736.54 550.024 1766.97 567.91 1795.76 563.814C1797.8 563.655 1801.02 563.389 1801.02 563.391ZM1817.5 479.359C1802.05 469.889 1809.49 449.336 1808.87 434.408C1810.41 416.394 1811.64 397.454 1819.74 381.042C1828.3 369.341 1849.2 373.855 1850.12 388.868C1849.51 403.968 1842.58 419 1843.41 434.654C1841.61 447.726 1844.71 462.408 1838.93 474.355C1834.18 480.965 1824.52 482.887 1817.5 479.359ZM1750.04 470.755C1735.49 462.859 1740.11 442.989 1737.83 429.175C1739.72 413.181 1738.14 392.893 1751.53 381.677C1764.62 372.545 1782.44 388.184 1776.25 402.541C1769.65 420.686 1773.97 440.511 1774.11 458.909C1771.62 469.762 1760.01 475.523 1750.04 470.755Z" fill="black"/>

     

       13
       13
       +
       <path d="M2651.01 309.103C2659.01 338.907 2689.66 356.594 2719.48 348.608L2779.7 332.483L2786.96 359.568L2726.74 375.692C2696.92 383.678 2679.22 414.313 2687.21 444.117L2702.83 502.362L2677.66 509.101L2662.05 450.858C2654.06 421.054 2623.4 403.367 2593.58 411.353L2533.36 427.477L2526.1 400.392L2586.32 384.267C2616.14 376.281 2633.84 345.646 2625.85 315.841L2609.71 255.664L2634.88 248.925L2651.01 309.103Z" fill="black"/>

     

       14
       14
       +
       <path d="M1581 412.5C1581 639.765 1379.53 824 1131 824C882.472 824 681 639.765 681 412.5C681 185.235 882.472 1 1131 1C1379.53 1 1581 185.235 1581 412.5Z" fill="url(#paint4_linear_43_123)"/>

     

       15
       15
       +
       <path d="M1581 412.5C1581 639.765 1379.53 824 1131 824C882.472 824 681 639.765 681 412.5C681 185.235 882.472 1 1131 1C1379.53 1 1581 185.235 1581 412.5Z" fill="url(#paint5_linear_43_123)"/>

     

       16
       16
       +
       <path d="M1581 412.5C1581 639.765 1379.53 824 1131 824C882.472 824 681 639.765 681 412.5C681 185.235 882.472 1 1131 1C1379.53 1 1581 185.235 1581 412.5Z" fill="url(#paint6_linear_43_123)"/>

     

       17
       17
       +
       <path d="M966.723 191.375C1033.22 241.296 1104.74 342.515 1131 396.835C1157.26 342.519 1228.78 241.295 1295.28 191.375C1343.26 155.354 1421 127.483 1421 216.17C1421 233.882 1410.85 364.96 1404.89 386.24C1384.19 460.224 1308.75 479.094 1241.64 467.673C1358.94 487.637 1388.78 553.765 1324.34 619.893C1201.95 745.483 1148.43 588.382 1134.71 548.127C1132.19 540.747 1131.02 537.295 1131 540.231C1130.98 537.295 1129.81 540.747 1127.29 548.127C1113.58 588.382 1060.06 745.487 937.664 619.893C873.22 553.765 903.059 487.633 1020.36 467.673C953.253 479.094 877.811 460.223 857.111 386.24C851.153 364.958 841 233.88 841 216.17C841 127.483 918.742 155.354 966.72 191.375H966.723Z" fill="#1185FE"/>

     

       18
       18
       +
       <path d="M900 413.5C900 640.765 698.528 825 450 825C201.472 825 0 640.765 0 413.5C0 186.235 201.472 2 450 2C698.528 2 900 186.235 900 413.5Z" fill="url(#paint7_linear_43_123)"/>

     

       19
       19
       +
       <path d="M486.784 149.972C495.12 150.218 503.341 152.013 511.019 155.268C524.964 161.428 535.885 172.888 541.369 187.118C547.013 201.61 546.676 217.752 540.425 231.995C532.095 250.772 520.436 258.342 502.204 265.37C494.867 288.819 488.558 312.417 485.651 336.856C484.994 342.414 484.337 348.605 483.188 354.046C516.692 363.194 543.972 380.336 568.387 404.647C572.953 398.282 578.281 395.46 585.137 392.085C586.485 382.618 590.368 375.181 596.029 367.542C591.872 360.952 588.254 355.397 585.399 348.038C569.255 306.213 584.476 252.122 621.186 225.959C631.745 217.883 642.978 216.272 638.728 233.862C634.423 251.704 636.31 265.635 641.904 282.819C646.077 279.339 653.372 273.415 656.43 269.228C665.527 256.765 665.397 239.306 664.474 224.575C664.293 220.613 662.836 216.033 664.39 212.212C668.248 202.722 680.576 212.228 685.297 215.947C726.387 248.307 734.343 309.139 711.145 354.42C699.074 377.974 686.199 389.819 661.379 398.236C654.042 418.948 642.906 430.422 622.753 435.435C622.171 435.578 616.637 439.917 615.369 440.78C628.304 453.123 608.365 471.489 601.947 482.664L601.656 483.178C609.052 480.714 618.533 477.137 626.299 476.607C629.786 476.371 631.117 477.255 633.531 479.484C638.913 480.212 646.157 480.718 651.06 482.921C653.894 484.197 657.234 489.341 659.235 491.965C676.794 514.977 686.91 543.318 690.57 571.865C690.659 575.652 689.265 579.321 688.747 583.024C688.452 585.163 688.292 587.388 688.098 589.54C686.708 604.827 682.817 620.088 675.652 633.715C673.626 637.57 668.724 645.994 663.472 642.254C662.566 641.609 661.606 640.506 661.45 639.381C659.686 632.313 659.816 624.907 659.062 617.696C658.148 609.616 656.969 601.533 655.954 593.47C655.516 593.226 655.091 592.969 654.674 592.699C640.025 583.066 632.217 546.17 628.868 529.35C618.853 534.295 613.15 536.805 602.591 540.82C612.539 549.236 615.976 547.994 618.857 562.471C622.652 581.537 622.171 598.782 618.714 617.788L614.388 619.3C605.712 633.193 597.52 642.755 582.977 651.087C577.476 654.044 570.274 658.231 563.784 657.069C561.362 656.635 559.762 652.839 560.705 650.523C562.895 645.143 565.717 640.03 568.29 634.806C572.047 627.005 575.623 619.115 579.009 611.145C575.484 600.008 578.369 590.277 580.488 578.879C556.455 576.01 543.879 571.305 522.766 559.944C513.453 562.632 506.609 565.058 496.897 567.379C480.736 570.547 464.281 572.008 447.813 571.73C438.994 571.663 429.9 570.968 421.135 571.018C412.877 571.065 404.523 571.511 396.203 571.566C380.459 571.756 364.721 570.833 349.108 568.803C354.483 588.07 357.307 613.765 332.703 589.237C325.165 581.722 311.451 577.27 301.211 574.523C301.625 576.267 302.083 578.007 302.585 579.73C307.893 597.548 314.567 605.408 331.638 612.679C336.396 614.709 348.184 618.273 349.608 623.273C348.559 634.857 317.425 644.267 307.345 646.306C278.31 652.182 253.074 645.139 228.686 629.17C230.525 634.36 238.063 649.221 236.403 654.503C233.978 662.216 222.014 655.165 217.645 652.393C204.579 644.107 196.386 633.412 189.559 619.776C181.384 615.589 183.781 598.18 184.445 590.416L178.56 593.407C178.372 595.581 177.939 598.175 177.569 600.336C175.547 612.114 175.176 624.06 173.729 635.889C173.396 638.349 172.418 643.277 169.173 643.37C160.859 643.597 155.703 627.67 153.454 621.845C148.363 608.656 146.643 595.105 145.511 581.191C145.333 579.005 144.292 576.869 144 574.7C146.569 543.107 158.914 512.024 178.648 487.222C184.497 479.867 191.193 480.671 199.818 479.922C200.552 479.193 201.75 477.992 202.695 477.681C211.381 474.812 229.13 482.689 237.224 485.773C232.308 474.231 213.982 457.866 219.206 444.374C222.007 437.141 236.454 437.065 242.39 432.233C251.565 424.765 258.883 415.148 266.904 406.488C288.845 382.818 314.421 366.418 345.06 356.525C341.968 340.168 338.76 324.072 333.624 308.201C330.904 299.798 327.446 291.262 324.482 282.865C312.306 280.948 302.359 277.576 292.662 269.555C280.76 259.723 273.361 245.477 272.161 230.085C270.859 214.725 275.444 199.109 285.546 187.366C295.62 175.693 309.91 168.488 325.285 167.329C340.607 166.199 355.743 171.25 367.317 181.354C378.836 191.625 385.861 206.009 386.879 221.409C387.997 240.828 380.654 254.093 368.211 267.984C369.362 275.096 370.229 282.024 371.572 289.141C375.338 308.445 380.361 327.483 386.61 346.132C402.163 343.299 425.714 343.765 441.436 345.125C444.275 331.271 447.91 317.909 450.488 303.802C453.389 287.941 455.049 274.116 456.544 258.147C453.966 256.457 452.021 255.217 449.649 253.194C437.958 243.196 430.713 228.966 429.509 213.629C426.973 178.12 452 152.499 486.784 149.972Z" fill="black"/>

     

       20
       20
       +
       <path d="M359.136 443.186C365.418 442.465 373.024 444.015 378.817 446.661C380.66 449.096 384.002 453.38 386.452 454.913C398.521 462.461 416.296 464.825 430.039 461.796C441.251 459.323 449.738 454.18 455.904 444.63C465.822 442.933 467.97 444.306 476.508 443.809C483.343 445.856 491.43 448.417 497.891 451.379C516.97 460.124 530.629 469.749 551.654 473.953C571.479 477.049 573.884 475.44 593.081 474.151C588.267 482.441 583.95 490.739 578.592 498.696C559.109 527.618 537.052 545.192 503.017 554.064C474.389 561.524 449.961 560.593 420.747 560.011C404.266 559.683 386.793 560.631 370.314 559.813C361.993 559.401 351.668 557.733 343.291 556.553C339.725 551.351 336.584 546.435 332.626 541.485C321.456 527.526 306.295 520.483 288.952 517.193C284.456 494.534 275.83 486.902 252.622 489.037C249.983 484.576 246.725 479.092 244.726 474.336C259.555 477.045 265.855 475.625 279.953 474.85C303.322 469.778 316.78 460.831 337.731 450.658C343.352 447.929 352.958 444.955 359.136 443.186Z" fill="#FBCA90"/>

     

       21
       21
       +
       <path d="M551.654 473.953C571.479 477.049 573.884 475.44 593.081 474.151C588.267 482.441 583.95 490.739 578.592 498.696C559.109 527.618 537.052 545.192 503.017 554.064C474.389 561.524 449.961 560.593 420.747 560.011C404.266 559.683 386.793 560.631 370.314 559.813C361.993 559.401 351.668 557.733 343.291 556.553C339.725 551.351 336.584 546.435 332.626 541.485C321.456 527.526 306.295 520.483 288.952 517.193C284.456 494.534 275.83 486.902 252.622 489.037C249.983 484.576 246.725 479.092 244.726 474.336C259.555 477.045 265.855 475.625 279.953 474.85C280.88 478.018 284.257 482.18 286.289 484.745C296.483 497.631 308.334 506.738 323.037 514.038C342.637 523.604 364.266 528.267 386.065 527.627C395.8 527.437 405.679 526.452 415.406 526.582C428.228 526.725 441.23 527.993 454.038 527.441C487.315 526.009 521.363 513.292 542.632 486.67C545.631 482.917 549.519 478.27 551.654 473.953Z" fill="#DAA66F"/>

     

       22
       22
       +
       <path d="M389.063 356.665C401.33 355.048 426.417 354.909 438.64 356.724C437.802 360.016 436.829 363.387 435.927 366.673C435.211 377.357 442.258 383.823 451.498 387.338C463.683 391.972 479.873 391.374 482.147 375.511L482.253 365.638C503.695 373.117 537.726 387.582 552.404 405.401L564.988 418.147C567.928 438.695 576.015 451.257 599.184 447.175C602.128 448.321 604.979 449.437 607.965 450.473C605.59 456.37 604.688 458.999 600.826 464.134C584.017 468.7 566.357 469.168 549.333 465.499C543.673 464.193 538.113 462.504 532.684 460.444C519.83 455.549 489.16 440.911 476.508 443.809C467.97 444.306 465.822 442.933 455.904 444.63C449.738 454.18 441.251 459.323 430.039 461.796C416.296 464.825 398.521 462.461 386.452 454.913C384.002 453.38 380.66 449.096 378.817 446.661C373.024 444.015 365.418 442.465 359.136 443.186C351.318 438.876 314.777 454.753 306.297 458.363C284.213 467.769 262.001 470.772 238.368 465.28C235.133 461.118 233.239 458.114 230.815 453.409C230.21 452.129 230.154 452.188 230.098 450.797C231.749 447.769 234.944 447.899 238.119 446.825C254.116 441.4 264.251 426.105 275.211 413.906C295.545 391.281 319.073 377.859 347.273 367.162C347.276 371.514 347.2 375.957 347.546 380.288C357.958 402.216 398.069 383.967 393.25 367.62C391.563 363.714 390.437 360.648 389.063 356.665Z" fill="#DF7E40"/>

     

       23
       23
       +
       <path d="M230.815 453.409C230.21 452.129 230.154 452.188 230.098 450.797C231.749 447.769 234.944 447.899 238.119 446.825C254.116 441.4 264.251 426.105 275.211 413.906C295.545 391.281 319.073 377.859 347.273 367.162C347.276 371.514 347.2 375.957 347.546 380.288C343.188 382.664 338.514 384.656 334.117 386.816C315.532 395.948 298.854 407.583 284.935 422.949C276.163 432.634 267.783 443.308 255.181 447.786C246.112 451.299 238.936 451.113 230.815 453.409Z" fill="#DAA66F"/>

     

       24
       24
       +
       <path d="M378.817 446.661C377.999 443.75 377.431 441.589 377.954 438.535C378.791 437.554 378.903 437.44 380.542 438.358C383.309 439.963 385.702 442.267 388.408 443.956C404.878 454.252 426.771 455.006 443.34 444.588C446.305 442.722 450.942 438.472 454.299 438.143C457.281 439.559 456.38 441.8 455.904 444.63C449.738 454.18 441.251 459.323 430.039 461.796C416.296 464.825 398.521 462.461 386.452 454.913C384.002 453.38 380.66 449.096 378.817 446.661Z" fill="black"/>

     

       25
       25
       +
       <path d="M389.063 356.665C401.33 355.048 426.417 354.909 438.64 356.724C437.802 360.016 436.829 363.387 435.927 366.673C420.926 366.655 408.299 366.762 393.25 367.62C391.563 363.714 390.437 360.648 389.063 356.665Z" fill="#DAA66F"/>

     

       26
       26
       +
       <path d="M482.253 365.638C503.695 373.117 537.726 387.582 552.404 405.401C548.461 405.957 539.44 398.429 535.645 396.403C520.335 388.235 499.138 378.027 482.147 375.511L482.253 365.638Z" fill="#DAA66F"/>

     

       27
       27
       +
       <path d="M302.546 418.16C313.039 417.848 311.009 425.304 305.25 430.443C303.06 432.394 301.209 433.076 298.58 434.196C282.94 434.205 293.179 421.572 302.546 418.16Z" fill="#DAA66F"/>

     

       28
       28
       +
       <path d="M348.688 403.21C352.118 402.637 355.37 404.933 355.976 408.362C356.581 411.787 354.315 415.06 350.896 415.7C347.429 416.349 344.1 414.04 343.486 410.569C342.872 407.094 345.209 403.787 348.688 403.21Z" fill="black"/>

     

       29
       29
       +
       <path d="M481.861 403.223C485.167 402.738 488.28 404.921 488.953 408.194C489.627 411.471 487.631 414.702 484.401 415.565C482.139 416.168 479.726 415.468 478.138 413.75C476.55 412.031 476.044 409.571 476.824 407.364C477.603 405.156 479.544 403.56 481.861 403.223Z" fill="black"/>

     

       30
       30
       +
       <path d="M320.504 406.513C323.825 405.708 327.172 407.739 327.999 411.054C328.826 414.369 326.823 417.73 323.514 418.581C320.171 419.441 316.768 417.414 315.933 414.061C315.098 410.713 317.149 407.326 320.504 406.513Z" fill="black"/>

     

       31
       31
       +
       <path d="M410.25 378.971C418.943 380.13 420.983 385.737 412.672 390.388C402.285 390.784 401.18 381.845 410.25 378.971Z" fill="#DAA66F"/>

     

       32
       32
       +
       <path d="M509.486 406.964C512.708 406.247 515.917 408.202 516.76 411.395C517.602 414.584 515.774 417.869 512.619 418.838C510.463 419.499 508.121 418.927 506.512 417.347C504.903 415.767 504.289 413.438 504.912 411.269C505.531 409.103 507.287 407.452 509.486 406.964Z" fill="black"/>

     

       33
       33
       +
       <path d="M674.907 223.502L674.806 222.742L675.391 222.371C682.863 224.376 696.1 242.405 699.899 249.075C713.625 272.738 716.515 301.107 709.822 327.51C702.422 356.713 680.096 389.322 646.831 389.583C636.209 389.667 626.594 382.904 621.611 373.799C621.346 373.304 621.089 372.802 620.845 372.294L620.36 371.086C609.397 348.637 622.896 316.403 639.41 300.245C656.586 283.439 667.932 278.611 673.98 253.865C675.846 243.368 675.842 234.08 674.907 223.502Z" fill="#EC7558"/>

     

       34
       34
       +
       <path d="M674.907 223.502L674.806 222.742L675.391 222.371C682.863 224.376 696.1 242.405 699.899 249.075C713.625 272.738 716.515 301.107 709.822 327.51C702.422 356.713 680.096 389.322 646.831 389.583C636.209 389.667 626.594 382.904 621.611 373.799C621.346 373.304 621.089 372.802 620.845 372.294C630.388 374.504 644.919 376.223 653.722 371.819C698.198 349.559 705.547 283.972 686.106 242.595C684.396 238.957 677.548 224.562 674.907 223.502Z" fill="#D25742"/>

     

       35
       35
       +
       <path d="M673.98 253.865C675.218 255.065 675.29 255.341 675.311 257.05C675.568 275.686 667.999 288.339 655.899 301.625C645.504 313.04 634.845 325.424 628.102 339.353C625.663 344.531 624.871 348.951 623.586 354.314C622.723 357.94 621.957 368.604 620.36 371.086C609.397 348.637 622.896 316.403 639.41 300.245C656.586 283.439 667.932 278.611 673.98 253.865Z" fill="#FCA78D"/>

     

       36
       36
       +
       <path d="M638.997 330.878C647.547 330.662 644.826 337.94 640.842 342.173C632.991 342.04 634.659 334.964 638.997 330.878Z" fill="#FCA78D"/>

     

       37
       37
       +
       <path d="M230.926 544.207C248.351 538.137 264.226 544.796 277.105 556.785C290.827 569.557 292.87 584.645 300.046 600.909C308.524 613.66 318.891 618.155 332.509 624.178L333.821 624.684L334.002 625.248C326.877 630.206 310.751 635.093 302.146 636.382C278.633 639.966 254.599 635.324 235.367 620.922C215.625 606.141 202.121 575.13 218.694 553.251C222.938 548.861 225.251 546.595 230.926 544.207Z" fill="#EC7558"/>

     

       38
       38
       +
       <path d="M218.694 553.251C219.18 558.836 219.304 565.622 220.102 570.875C222.189 584.607 232.221 599.616 242.955 608.277C263.707 625.025 289.295 629.697 315.276 626.765C318.359 626.415 330.422 624.545 332.306 624.583L332.509 624.178L333.821 624.684L334.002 625.248C326.877 630.206 310.751 635.093 302.146 636.382C278.633 639.966 254.599 635.324 235.367 620.922C215.625 606.141 202.121 575.13 218.694 553.251Z" fill="#D25742"/>

     

       39
       39
       +
       <path d="M230.926 544.207C248.351 538.137 264.226 544.796 277.105 556.785C290.827 569.557 292.87 584.645 300.046 600.909C294.339 600.77 283.239 578.028 279.481 573.061C276.728 569.426 274.126 565.121 270.415 561.802C262.505 554.771 252.881 549.308 242.554 546.835C239.147 546.018 233.955 545.849 230.926 544.207Z" fill="#FCA78D"/>

     

       40
       40
       +
       <path d="M259.89 560.37C265.721 560.765 269.614 564.325 264.783 569.721C259.381 568.803 255.082 565.761 259.89 560.37Z" fill="#FCA78D"/>

     

       41
       41
       +
       <path d="M442.056 197.202C446.785 183.2 453.432 173.442 467.061 166.663C478.02 161.298 490.651 160.46 502.229 164.329C514.216 168.46 524.054 177.21 529.559 188.634C531.909 193.554 532.768 197.227 533.792 202.518C534.52 207.326 534.087 213.746 533.076 218.504C530.38 230.662 523.001 241.267 512.535 248.013C502.111 254.721 488.836 256.799 476.803 254.088C464.677 251.288 454.173 243.755 447.628 233.166C440.99 222.504 439.217 209.359 442.056 197.202Z" fill="white"/>

     

       42
       42
       +
       <path d="M442.056 197.202C444.823 200.703 446.92 206.892 448.866 211.096C454.649 223.59 468.396 232.074 481.688 234.016C493.89 235.762 506.285 232.592 516.149 225.203C522.222 220.61 525.886 215.345 529.812 208.89C530.911 207.08 532.545 204.107 533.792 202.518C534.52 207.326 534.087 213.746 533.076 218.504C530.38 230.662 523.001 241.267 512.535 248.013C502.111 254.721 488.836 256.799 476.803 254.088C464.677 251.288 454.173 243.755 447.628 233.166C440.99 222.504 439.217 209.359 442.056 197.202Z" fill="#CBCBCB"/>

     

       43
       43
       +
       <path d="M471.121 188.328C474.448 188.138 477.493 187.934 480.77 188.657C497.895 192.405 499.028 216.562 484.868 224.783C479.115 228.123 473.067 227.557 466.989 225.854C465.283 225.083 464.15 224.53 462.643 223.384C458.734 220.43 456.211 215.997 455.668 211.126C455.024 205.06 457.348 198.624 461.185 193.943C461.986 197.105 463.102 201.814 466.724 202.878C469.878 203.806 474.76 200.849 475.337 197.591C475.83 194.833 472.641 191.213 470.982 189.168L471.121 188.328Z" fill="black"/>

     

       44
       44
       +
       <path d="M283.388 221.28C285.234 199.363 302.311 181.807 324.166 179.36C346.022 176.913 366.558 190.258 373.203 211.225C378.829 228.979 373.215 248.374 358.975 260.376C344.735 272.377 324.671 274.624 308.131 266.068C291.59 257.513 281.826 239.839 283.388 221.28Z" fill="white"/>

     

       45
       45
       +
       <path d="M373.203 211.225C378.829 228.979 373.215 248.374 358.975 260.376C344.735 272.377 324.671 274.624 308.131 266.068C291.59 257.513 281.826 239.839 283.388 221.28C285.921 224.102 287.409 228.255 289.641 231.4C300.801 247.128 320.426 253.928 338.961 248.664C341.889 247.833 349.187 245.587 350.334 242.601C349.911 241.742 350.117 241.982 349.462 241.321C351.21 240.276 353.081 238.927 354.778 237.763L355.977 238.263C361.677 236.839 366.593 227.165 368.774 222.009C370.076 218.933 371.352 213.775 373.203 211.225Z" fill="#CBCBCB"/>

     

       46
       46
       +
       <path d="M333.257 205.278C339.992 203.067 347.483 203.449 353.222 207.95C357.163 211.078 359.7 215.642 360.277 220.64C361.097 227.378 358.779 232.623 354.778 237.763C353.081 238.927 351.21 240.276 349.462 241.321C345.455 242.999 341.05 243.492 336.77 242.74C325.294 240.715 319.303 229.21 321.603 218.414C322.057 216.283 322.448 214.195 324.355 212.918C326.871 213.833 328.746 221.097 333.393 219.468C344.342 215.63 340.773 209.483 333.257 205.278Z" fill="black"/>

     

       47
       47
       +
       <path d="M625.558 235.792L626.383 235.212L626.893 235.539C627.171 238.122 626.046 248.279 625.84 251.667C624.884 267.447 628.721 277.364 634.095 291.7C630.102 295.894 626.598 299.651 623.047 304.289C615.222 315.313 610.008 326.032 607.851 339.533C607.262 343.228 607.249 346.606 606.803 349.998C607.026 355.87 607.712 360.568 608.757 366.327C589.863 342.096 585.862 314.845 593.435 285.243C597.579 269.032 610.627 244.458 625.558 235.792Z" fill="#EC7558"/>

     

       48
       48
       +
       <path d="M608.757 366.327C589.863 342.096 585.862 314.845 593.435 285.243C597.579 269.032 610.627 244.458 625.558 235.792C623.566 243.297 620.723 250.768 618.73 258.489C603.829 279.622 598.278 309.808 601.892 335.316C602.364 338.655 604.794 347.541 606.803 349.998C607.026 355.87 607.712 360.568 608.757 366.327Z" fill="#FCA78D"/>

     

       49
       49
       +
       <path d="M625.558 235.792L626.383 235.212L626.893 235.539C627.171 238.122 626.046 248.279 625.84 251.667C624.884 267.447 628.721 277.364 634.095 291.7C630.102 295.894 626.598 299.651 623.047 304.289C619.543 292.822 618.141 286.54 618.25 274.215C618.297 269.218 618.794 263.359 618.73 258.489C620.723 250.768 623.566 243.297 625.558 235.792Z" fill="#D25742"/>

     

       50
       50
       +
       <path d="M250.056 532.774C265.122 525.373 281.953 523.57 297.972 529.097C314.579 534.914 328.204 547.075 335.862 562.922C337.964 567.303 340.013 573.036 341.245 577.771C341.839 579.658 342.182 581.971 342.544 583.942C339.029 581.52 335.654 578.567 331.892 576.103C318.722 567.459 309.398 565.652 294.358 563.402C292.044 559.409 288.944 555.5 286.039 551.907C277.385 542.884 271.948 539.602 260.433 535.268C257.014 534.438 253.478 533.528 250.056 532.774Z" fill="#EC7558"/>

     

       51
       51
       +
       <path d="M250.056 532.774C265.122 525.373 281.953 523.57 297.972 529.097C314.579 534.914 328.204 547.075 335.862 562.922C337.964 567.303 340.013 573.036 341.245 577.771L340.477 577.897C338.511 576.322 335.538 572.969 333.703 571.014C330.307 562.728 317.204 552.556 310.12 547.231C297.038 537.404 276.645 532.374 260.433 535.268C257.014 534.438 253.478 533.528 250.056 532.774Z" fill="#FCA78D"/>

     

       52
       52
       +
       <path d="M286.039 551.907L286.705 552.075C290.92 553.112 294.861 553.508 299.098 554.253C306.878 555.626 314.373 558.289 321.278 562.126C325.432 564.434 330.278 569.502 333.703 571.014C335.538 572.969 338.511 576.322 340.477 577.897L341.245 577.771C341.839 579.658 342.182 581.971 342.544 583.942C339.029 581.52 335.654 578.567 331.892 576.103C318.722 567.459 309.398 565.652 294.358 563.402C292.044 559.409 288.944 555.5 286.039 551.907Z" fill="#D25742"/>

     

       53
       53
       +
       <path d="M466.218 275.965C467.739 275.235 469.942 276.847 471.344 277.661C476.55 280.347 481.486 280.473 484.961 282.05C477.177 307.207 470.691 350.412 470.695 376.699C464.344 378.485 460.659 378.649 454.35 376.367C450.504 374.5 448.862 373.153 446.389 369.81C455.377 339.079 462.007 307.706 466.218 275.965Z" fill="#EC7558"/>

     

       54
       54
       +
       <path d="M466.218 275.965C467.739 275.235 469.942 276.847 471.344 277.661C469.474 287.957 467.735 298.277 466.138 308.619C464.858 316.841 457.268 372.713 454.35 376.367C450.504 374.5 448.862 373.153 446.389 369.81C455.377 339.079 462.007 307.706 466.218 275.965Z" fill="#FCA78D"/>

     

       55
       55
       +
       <path d="M647.707 508.157C648.861 505.326 650.192 502.698 651.54 499.956C666.677 519.585 676.853 549.805 679.422 574.241L675.652 576.431C673.45 577.548 669.478 579.397 667.49 580.593C665.106 581.705 662.566 581.844 659.976 582.118C649.114 573.099 640.796 536.405 638.429 522.176L643.42 515.895C645.467 513.17 646.642 511.371 647.707 508.157Z" fill="#EC7558"/>

     

       56
       56
       +
       <path d="M638.429 522.176L643.42 515.895C646.553 523.73 648.343 530.896 650.828 538.895C655.541 554.047 660.187 566.583 667.49 580.593C665.106 581.705 662.566 581.844 659.976 582.118C649.114 573.099 640.796 536.405 638.429 522.176Z" fill="#D25742"/>

     

       57
       57
       +
       <path d="M647.707 508.157C648.861 505.326 650.192 502.698 651.54 499.956C666.677 519.585 676.853 549.805 679.422 574.241L675.652 576.431C673.812 570.926 672.889 563.301 671.31 557.733C667.212 543.267 658.131 518.296 647.707 508.157Z" fill="#FCA78D"/>

     

       58
       58
       +
       <path d="M182.872 500.019C183.958 502.441 185.002 504.884 186.004 507.34C187.554 510.428 188.852 513.022 190.652 515.958L195.727 522.18C192.603 538.718 188.941 554.54 181.975 569.969C178.112 578.529 176.652 585.151 166.162 580.534C163.495 579.211 161.471 578.036 158.911 576.494C157.823 575.787 156.44 574.704 155.36 573.916C158.781 545.723 166.105 523.136 182.872 500.019Z" fill="#EC7558"/>

     

       59
       59
       +
       <path d="M190.652 515.958L195.727 522.18C192.603 538.718 188.941 554.54 181.975 569.969C178.112 578.529 176.652 585.151 166.162 580.534C167.579 576.431 172.725 568.971 174.811 563.086C180.344 547.475 185.401 531.658 190.652 515.958Z" fill="#D25742"/>

     

       60
       60
       +
       <path d="M182.872 500.019C183.958 502.441 185.002 504.884 186.004 507.34C183.776 511.14 180.964 514.88 178.888 518.747C171.27 532.926 165.437 548.541 161.726 564.194C161.182 566.49 159.818 575.054 158.911 576.494C157.823 575.787 156.44 574.704 155.36 573.916C158.781 545.723 166.105 523.136 182.872 500.019Z" fill="#FCA78D"/>

     

       61
       61
       +
       <path d="M359.33 286.516C361.904 298.375 364.269 309.346 367.347 321.089C371.851 338.272 377.098 354.137 382.637 370.936C380.426 372.961 377.74 375.454 375.006 376.749C368.914 379.082 364.931 378.923 358.773 377.535C356.185 346.417 351.389 325.092 341.538 295.169C344.817 293.992 352.155 291.573 354.684 289.954C356.202 288.761 357.767 287.649 359.33 286.516Z" fill="#EC7558"/>

     

       62
       62
       +
       <path d="M359.33 286.516C361.904 298.375 364.269 309.346 367.347 321.089C371.851 338.272 377.098 354.137 382.637 370.936C380.426 372.961 377.74 375.454 375.006 376.749C373.576 375.505 364.592 331.266 363.501 326.202C361.072 314.928 357.175 301.169 354.684 289.954C356.202 288.761 357.767 287.649 359.33 286.516Z" fill="#FCA78D"/>

     

       63
       63
       +
       <path d="M603.812 376.34C608.963 380.474 613.192 382.848 618.718 386.365C620.099 387.245 622.58 390.304 624.307 391.546C631.867 396.98 639.857 398.724 648.87 399.246C647.45 402.583 646.153 405.527 643.988 408.451C633.147 423.101 607.097 435.262 596.758 412.991C596.425 412.322 596.143 411.622 595.911 410.91C592.984 401.989 596.56 388.602 600.645 380.481C601.622 379.143 602.713 377.553 603.812 376.34Z" fill="#D25742"/>

     

       64
       64
       +
       <path d="M600.645 380.481L600.923 380.812C605.514 386.382 608.732 393.046 614.544 397.654C618.579 400.851 622.976 403.042 627.503 405.422C618.848 413.686 608.635 419.841 596.758 412.991C596.425 412.322 596.143 411.622 595.911 410.91C592.984 401.989 596.56 388.602 600.645 380.481Z" fill="#EC7558"/>

     

       65
       65
       +
       <path d="M597.398 497.428C604.73 493.709 614.426 490.293 622.323 488.528C621.948 490.92 621.948 493.203 621.877 495.621C621.872 500.259 621.906 503.393 622.546 507.968C623.069 512.306 623.456 514.518 624.387 518.852C613.836 522.791 600.114 530.158 588.848 531.784C586.864 532.071 572.548 528.979 569.461 528.402C574.035 523.566 577.539 519.476 581.469 514.135C583.924 510.798 587.942 504.526 590.634 501.733L591.164 501.19C592.887 499.4 594.913 498.675 597.191 497.622L597.398 497.428Z" fill="#D25742"/>

     

       66
       66
       +
       <path d="M597.398 497.428C604.73 493.709 614.426 490.293 622.323 488.528C621.948 490.92 621.948 493.203 621.877 495.621C621.872 500.259 621.906 503.393 622.546 507.968L622.428 509.143C620.171 512.311 594.104 520.499 588.84 522.521C592.289 515.234 596.619 505.6 597.191 497.622L597.398 497.428Z" fill="#EC7558"/>

     

       67
       67
       +
       <path d="M597.398 497.428C604.73 493.709 614.426 490.293 622.323 488.528C621.948 490.92 621.948 493.203 621.877 495.621C614.316 495.726 609.347 496.805 602.107 498.983C601.049 499.303 598.409 500.272 597.608 499.867C597.533 499.063 597.44 498.233 597.398 497.428Z" fill="#FCA78D"/>

     

       68
       68
       +
       <path d="M213.837 519.552C217.5 509.914 228.538 500.849 239.13 501.935C245.841 502.622 249.501 505.474 253.712 510.289C255.671 512.458 256.563 514.299 257.979 516.847C257.955 518.747 258.334 518.128 257.393 519.202C246.094 523.098 241.058 526.401 231.579 533.659C229.128 535.538 222.959 536.494 220.461 538.794C216.766 541.709 212.848 546.448 209.684 550.074C209.155 546.212 208.101 539.838 209.406 536.039C210.011 529.994 211.249 525.007 213.837 519.552Z" fill="#EC7558"/>

     

       69
       69
       +
       <path d="M257.979 516.847C257.955 518.747 258.334 518.128 257.393 519.202C246.094 523.098 241.058 526.401 231.579 533.659C229.128 535.538 222.959 536.494 220.461 538.794C216.766 541.709 212.848 546.448 209.684 550.074C209.155 546.212 208.101 539.838 209.406 536.039C210.635 536.515 213.987 532.711 215.049 531.755C217.796 529.257 220.743 526.991 223.859 524.969C235.714 517.344 244.444 516.645 257.979 516.847Z" fill="#D25742"/>

     

       70
       70
       +
       <path d="M213.837 519.552C217.5 509.914 228.538 500.849 239.13 501.935C245.841 502.622 249.501 505.474 253.712 510.289C247.997 511.06 241.529 505.31 231.773 508.776C225.464 511.017 217.326 519.653 213.837 519.552Z" fill="#FCA78D"/>

     

       71
       71
       +
       <path d="M557.479 539.316C561.817 539.64 566.147 540.015 570.472 540.445C576.857 541.283 582.248 542.197 588.482 543.916C585.095 550.407 583.823 552.745 581.819 559.826C581.381 562.109 581.023 565.129 580.673 567.484C564.883 565.361 549.371 561.086 535.135 553.849C544.014 548.899 549.354 545.373 557.479 539.316Z" fill="#D25742"/>

     

       72
       72
       +
       <path d="M570.472 540.445C576.857 541.283 582.248 542.197 588.482 543.916C585.095 550.407 583.823 552.745 581.819 559.826C573.205 557.918 567.195 556.688 559.105 552.943C561.438 550.454 568.13 541.389 570.472 540.445Z" fill="#EC7558"/>

     

       73
       73
       +
       <path d="M598.893 574.388C601.875 572.32 605.543 569.915 608.26 567.602C610.341 583.449 610.387 592.51 608.833 608.374C603.471 608.466 599.727 608.311 594.395 607.498C592.091 606.832 590.032 605.749 587.972 604.553C588.465 597.026 590.196 585.648 591.792 578.285C594.033 576.798 596.492 575.618 598.893 574.388Z" fill="#EC7558"/>

     

       74
       74
       +
       <path d="M598.893 574.388C597.145 581.575 594.947 600.109 594.395 607.498C592.091 606.832 590.032 605.749 587.972 604.553C588.465 597.026 590.196 585.648 591.792 578.285C594.033 576.798 596.492 575.618 598.893 574.388Z" fill="#D25742"/>

     

       75
       75
       +
       <path d="M586.224 404.268L586.936 409.857C587.357 411.888 587.736 413.96 588.321 415.94C592.689 425.721 596.838 428.775 606.302 433.152C594.803 439.176 583.634 442.878 576.036 428.758C575.332 427.065 574.882 425.11 574.406 423.324C573.159 412.524 577.068 408.53 586.224 404.268Z" fill="#D25742"/>

     

       76
       76
       +
       <path d="M586.224 404.268L586.936 409.857C587.357 411.888 587.736 413.96 588.321 415.94C587.879 425.7 586.283 428.771 576.036 428.758C575.332 427.065 574.882 425.11 574.406 423.324C573.159 412.524 577.068 408.53 586.224 404.268Z" fill="#EC7558"/>

     

       77
       77
       +
       <path d="M586.224 404.268L586.936 409.857C579.098 414.327 578.218 420.279 574.406 423.324C573.159 412.524 577.068 408.53 586.224 404.268Z" fill="#FCA78D"/>

     

       78
       78
       +
       <path d="M197.154 579.026C197.662 575.277 198.643 569.3 201.095 566.292L201.768 566.301C203.289 569.472 202.02 579.039 202.508 583.024C203.087 587.754 204.564 592.303 205.441 596.878C206.576 600.64 208.934 604.962 210.813 608.395C204.667 609.625 201.456 609.334 195.281 608.411C195.278 597.017 195.42 590.307 197.154 579.026Z" fill="#EC7558"/>

     

       79
       79
       +
       <path d="M197.154 579.026C197.662 575.277 198.643 569.3 201.095 566.292L201.768 566.301C203.289 569.472 202.02 579.039 202.508 583.024C203.087 587.754 204.564 592.303 205.441 596.878C199.377 591.933 200.904 582.236 197.154 579.026Z" fill="#D25742"/>

     

       80
       80
       +
       <path d="M467.402 263.636C474.954 265.476 481.339 266.926 489.253 266.998C488.697 268.859 484.994 280.866 484.961 282.05C481.486 280.473 476.55 280.347 471.344 277.661C469.942 276.847 467.739 275.235 466.218 275.965C466.821 271.899 467.082 267.739 467.402 263.636Z" fill="#D25742"/>

     

       81
       81
       +
       <path d="M252.921 497.626C259.809 496.641 266.365 495.971 272.284 500.179C274.044 501.594 275.387 502.782 276.552 504.762C278.355 508.313 279.456 512.176 279.793 516.144C275.03 516.009 272.218 515.988 267.543 516.94C266.041 512.942 264.829 509.855 262.506 506.232C260.922 504.139 259.601 502.904 257.729 501.072L252.921 497.626Z" fill="#D25742"/>

     

       82
       82
       +
       <path d="M252.921 497.626C259.809 496.641 266.365 495.971 272.284 500.179C274.044 501.594 275.387 502.782 276.552 504.762C274.329 506.038 265.462 506.203 262.506 506.232C260.922 504.139 259.601 502.904 257.729 501.072L252.921 497.626Z" fill="#EC7558"/>

     

       83
       83
       +
       <path d="M252.921 497.626C259.809 496.641 266.365 495.971 272.284 500.179C270.488 500.992 260.509 500.958 257.729 501.072L252.921 497.626Z" fill="#FCA78D"/>

     

       84
       84
       +
       <path d="M336.713 282.365C344.588 280.83 349.971 278.946 357.217 275.903C358.042 279.276 358.42 282.855 359.33 286.516C357.767 287.649 356.202 288.761 354.684 289.954C352.155 291.573 344.817 293.992 341.538 295.169C340.002 290.926 338.311 286.597 336.713 282.365Z" fill="#D25742"/>

     

       85
       85
       +
       <path d="M671.26 591.453C673.584 590.644 675.067 590.079 677.333 589.052C675.96 597.569 673.955 610.429 670.219 618.096C669.924 615.193 669.655 612.182 669.28 609.296C668.32 603.681 667.612 598.028 667.153 592.354L671.26 591.453Z" fill="#EC7558"/>

     

       86
       86
       +
       <path d="M667.153 592.354L671.26 591.453L671.217 592.042C670.834 597.662 672.544 605.829 669.343 609.166C669.322 609.208 669.301 609.254 669.28 609.296C668.32 603.681 667.612 598.028 667.153 592.354Z" fill="#D25742"/>

     

       87
       87
       +
       <path d="M157.009 589.068C159.236 590.269 160.694 590.854 163.033 591.794C164.483 592.211 165.564 592.295 166.574 593.222C166.867 596.587 165.239 605.951 164.652 609.768C164.326 612.161 164.155 615.775 163.958 618.268C160.692 609.696 158.265 598.192 157.009 589.068Z" fill="#EC7558"/>

     

       88
       88
       +
       <path d="M163.033 591.794C164.483 592.211 165.564 592.295 166.574 593.222C166.867 596.587 165.239 605.951 164.652 609.768C161.661 605.341 162.836 597.417 163.033 591.794Z" fill="#D25742"/>

     

       89
       89
       +
       <path d="M211.553 488.987C216.335 490.048 221.749 492.256 226.393 493.999C223.819 495.234 222.13 496.215 219.681 497.689C216.714 499.791 215.023 501.636 212.573 504.294C212.422 499.202 212.246 494.025 211.553 488.987Z" fill="#EC7558"/>

     

       90
       90
       +
       <path d="M196.844 491.59C198.239 491.371 198.782 491.131 200.01 491.796C202.048 494.454 200.981 506.072 199.49 507.778L198.925 507.268C196.032 501.957 194.299 497.706 192.086 492.146L196.844 491.59Z" fill="#FCA78D"/>

     

       91
       91
       +
       <path d="M597.048 551.692C599.495 553.032 601.525 554.321 603.876 555.824C601.226 558.419 599.104 560.344 596.265 562.728L592.474 565.391C593.472 559.599 594.458 556.966 597.048 551.692Z" fill="#EC7558"/>

     

       92
       92
       +
       <path d="M633.21 490.832L641.916 491.986L639.039 499.278C636.988 499.674 634.92 499.998 632.844 500.259C632.836 496.788 632.928 494.282 633.21 490.832Z" fill="#FCA78D"/>

     

       93
       93
       +
       <path d="M632.844 500.259C634.92 499.998 636.988 499.674 639.039 499.278C637.409 503.305 636.07 505.794 634.015 509.589C633.37 506.662 632.873 503.254 632.844 500.259Z" fill="#D25742"/>

     

       94
       94
       +
       <path d="M491.422 121.246C506.154 119.363 523.743 128.481 530.65 141.675C533.169 146.488 535.161 157.281 526.072 151.976C518.878 147.095 511.512 143.055 502.705 142.242C493.999 141.437 487.172 143.109 481.65 134.935C481.654 126.681 482.724 122.946 491.422 121.246Z" fill="black"/>

     

       95
       95
       +
       <path d="M492.184 126.622C500.287 127.02 508.892 129.327 515.601 134.01C517.711 135.482 523.262 140.138 523.696 142.613C522.429 142.66 521.199 141.918 519.944 141.364C514.687 138.908 514.03 138.809 508.239 137.06C502.376 134.908 493.789 136.808 488.57 133.84C485.138 131.887 490.579 127.564 492.184 126.622Z" fill="#EC7558"/>

     

       96
       96
       +
       <path d="M309.961 139.77C317.428 139.409 328.596 140.814 327.16 152.414C326.157 160.521 308.613 160.168 302.692 162.332C298.002 164.046 294.656 165.825 290.065 169.1C287.524 171.146 282.836 175.573 279.09 174.133C277.361 173.484 276.722 170.793 277.023 169.107C279.005 158.016 289.127 148.312 298.889 143.521C302.665 141.668 306.123 140.667 309.961 139.77Z" fill="black"/>

     

       97
       97
       +
       <path d="M312.587 145.641C316.353 145.327 321.957 146.525 320.6 151.582C320.284 151.999 319.685 152.874 319.158 152.987C312.082 154.509 304.967 155.399 298.16 158.044C295.422 159.108 293.108 160.245 290.498 161.628C287.819 163.388 286.43 164.538 283.982 166.644C292.022 154.04 298.117 149.15 312.587 145.641Z" fill="#EC7558"/>

     

       98
       98
       +
       <defs>

     

       99
       99
       +
       <linearGradient id="paint0_linear_43_123" x1="1473.5" y1="0" x2="1473.5" y2="825" gradientUnits="userSpaceOnUse">

     

       100
       100
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       101
       101
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       102
       102
       +
       </linearGradient>

     

       103
       103
       +
       <linearGradient id="paint1_linear_43_123" x1="1473.5" y1="0" x2="1473.5" y2="825" gradientUnits="userSpaceOnUse">

     

       104
       104
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       105
       105
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       106
       106
       +
       </linearGradient>

     

       107
       107
       +
       <linearGradient id="paint2_linear_43_123" x1="1473.5" y1="0" x2="1473.5" y2="825" gradientUnits="userSpaceOnUse">

     

       108
       108
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       109
       109
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       110
       110
       +
       </linearGradient>

     

       111
       111
       +
       <linearGradient id="paint3_linear_43_123" x1="1473.5" y1="0" x2="1473.5" y2="825" gradientUnits="userSpaceOnUse">

     

       112
       112
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       113
       113
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       114
       114
       +
       </linearGradient>

     

       115
       115
       +
       <linearGradient id="paint4_linear_43_123" x1="1478.64" y1="825" x2="1477.68" y2="-0.0108598" gradientUnits="userSpaceOnUse">

     

       116
       116
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       117
       117
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       118
       118
       +
       </linearGradient>

     

       119
       119
       +
       <linearGradient id="paint5_linear_43_123" x1="1478.64" y1="825" x2="1477.68" y2="-0.0108598" gradientUnits="userSpaceOnUse">

     

       120
       120
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       121
       121
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       122
       122
       +
       </linearGradient>

     

       123
       123
       +
       <linearGradient id="paint6_linear_43_123" x1="1478.64" y1="825" x2="1477.68" y2="-0.0108598" gradientUnits="userSpaceOnUse">

     

       124
       124
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       125
       125
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       126
       126
       +
       </linearGradient>

     

       127
       127
       +
       <linearGradient id="paint7_linear_43_123" x1="1478.64" y1="825" x2="1477.68" y2="-0.0108598" gradientUnits="userSpaceOnUse">

     

       128
       128
       +
       <stop stop-color="white" stop-opacity="0.98"/>

     

       129
       129
       +
       <stop offset="1" stop-color="#E9E9EE"/>

     

       130
       130
       +
       </linearGradient>

     

       131
       131
       +
       </defs>

     

       132
       132
       +
       </svg>

+180 -136

lib/screens/auth/login_screen.dart

···

       1
       1
        
       import 'package:flutter/material.dart';

     

       2
       2
       +
       import 'package:flutter_svg/flutter_svg.dart';

     

       2
       3
        
       import 'package:go_router/go_router.dart';

     

       3
       4
        
       import 'package:provider/provider.dart';

     

       4
       5
        
       

     
···

       24
       25
        
           super.dispose();

     

       25
       26
        
         }

     

       26
       27
        
       

     

       28
       28
       +
         void _showHandleHelpDialog() {

     

       29
       29
       +
           showDialog(

     

       30
       30
       +
             context: context,

     

       31
       31
       +
             builder: (context) => AlertDialog(

     

       32
       32
       +
               backgroundColor: const Color(0xFF1A2028),

     

       33
       33
       +
               title: const Text(

     

       34
       34
       +
                 'What is a handle?',

     

       35
       35
       +
                 style: TextStyle(color: Colors.white),

     

       36
       36
       +
               ),

     

       37
       37
       +
               content: const Text(

     

       38
       38
       +
                 'Your handle is your unique identifier '

     

       39
       39
       +
                 'on the atproto network, like '

     

       40
       40
       +
                 'alice.bsky.social. If you don\'t have one '

     

       41
       41
       +
                 'yet, you can create an account at bsky.app.',

     

       42
       42
       +
                 style: TextStyle(color: AppColors.textSecondary),

     

       43
       43
       +
               ),

     

       44
       44
       +
               actions: [

     

       45
       45
       +
                 TextButton(

     

       46
       46
       +
                   onPressed: () => Navigator.of(context).pop(),

     

       47
       47
       +
                   child: const Text('Got it'),

     

       48
       48
       +
                 ),

     

       49
       49
       +
               ],

     

       50
       50
       +
             ),

     

       51
       51
       +
           );

     

       52
       52
       +
         }

     

       53
       53
       +
       

     

       27
       54
        
         Future<void> _handleSignIn() async {

     

       28
       55
        
           if (!_formKey.currentState!.validate()) {

     

       29
       56
        
             return;

     
···

       41
       68
        
             }

     

       42
       69
        
           } on Exception catch (e) {

     

       43
       70
        
             if (mounted) {

     

       71
       71
       +
               final errorString = e.toString().toLowerCase();

     

       72
       72
       +
               String userMessage;

     

       73
       73
       +
               if (errorString.contains('timeout') ||

     

       74
       74
       +
                   errorString.contains('socketexception') ||

     

       75
       75
       +
                   errorString.contains('connection')) {

     

       76
       76
       +
                 userMessage =

     

       77
       77
       +
                     'Network error. Please check your connection and try again.';

     

       78
       78
       +
               } else if (errorString.contains('404') ||

     

       79
       79
       +
                   errorString.contains('not found')) {

     

       80
       80
       +
                 userMessage =

     

       81
       81
       +
                     'Handle not found. Please verify your handle is correct.';

     

       82
       82
       +
               } else if (errorString.contains('401') ||

     

       83
       83
       +
                   errorString.contains('403') ||

     

       84
       84
       +
                   errorString.contains('unauthorized')) {

     

       85
       85
       +
                 userMessage = 'Authorization failed. Please try again.';

     

       86
       86
       +
               } else {

     

       87
       87
       +
                 userMessage = 'Sign in failed. Please try again later.';

     

       88
       88
       +
                 debugPrint('Sign in error: $e');

     

       89
       89
       +
               }

     

       90
       90
       +
       

     

       44
       91
        
               ScaffoldMessenger.of(context).showSnackBar(

     

       45
       92
        
                 SnackBar(

     

       46
       46
       -
                   content: Text('Sign in failed: ${e.toString()}'),

     

       93
       93
       +
                   content: Text(userMessage),

     

       47
       94
        
                   backgroundColor: Colors.red[700],

     

       48
       95
        
                 ),

     

       49
       96
        
               );

     
···

       65
       112
        
               }

     

       66
       113
        
             },

     

       67
       114
        
             child: Scaffold(

     

       68
       68
       -
               backgroundColor: const Color(0xFF0B0F14),

     

       115
       115
       +
               backgroundColor: AppColors.background,

     

       116
       116
       +
               resizeToAvoidBottomInset: false,

     

       69
       117
        
               appBar: AppBar(

     

       70
       70
       -
                 backgroundColor: const Color(0xFF0B0F14),

     

       118
       118
       +
                 backgroundColor: AppColors.background,

     

       71
       119
        
                 foregroundColor: Colors.white,

     

       72
       72
       -
                 title: const Text('Sign In'),

     

       73
       120
        
                 elevation: 0,

     

       74
       121
        
                 leading: IconButton(

     

       75
       122
        
                   icon: const Icon(Icons.arrow_back),

     

       76
       123
        
                   onPressed: () => context.go('/'),

     

       77
       124
        
                 ),

     

       78
       125
        
               ),

     

       79
       79
       -
               body: SafeArea(

     

       80
       80
       -
                 child: Padding(

     

       81
       81
       -
                   padding: const EdgeInsets.all(24),

     

       82
       82
       -
                   child: Form(

     

       83
       83
       -
                     key: _formKey,

     

       84
       84
       -
                     child: Column(

     

       85
       85
       -
                       crossAxisAlignment: CrossAxisAlignment.stretch,

     

       86
       86
       -
                       children: [

     

       87
       87
       -
                         const SizedBox(height: 32),

     

       88
       88
       -
       

     

       89
       89
       -
                         // Title

     

       90
       90
       -
                         const Text(

     

       91
       91
       -
                           'Enter your handle',

     

       92
       92
       -
                           style: TextStyle(

     

       93
       93
       -
                             fontSize: 24,

     

       94
       94
       -
                             color: Colors.white,

     

       95
       95
       -
                             fontWeight: FontWeight.bold,

     

       96
       96
       -
                           ),

     

       97
       97
       -
                           textAlign: TextAlign.center,

     

       98
       98
       -
                         ),

     

       99
       99
       -
       

     

       100
       100
       -
                         const SizedBox(height: 8),

     

       101
       101
       -
       

     

       102
       102
       -
                         // Subtitle

     

       103
       103
       -
                         const Text(

     

       104
       104
       -
                           'Sign in with your atProto handle to continue',

     

       105
       105
       -
                           style: TextStyle(fontSize: 16, color: Color(0xFFB6C2D2)),

     

       106
       106
       -
                           textAlign: TextAlign.center,

     

       107
       107
       -
                         ),

     

       108
       108
       -
       

     

       109
       109
       -
                         const SizedBox(height: 48),

     

       110
       110
       -
       

     

       111
       111
       -
                         // Handle input field

     

       112
       112
       -
                         TextFormField(

     

       113
       113
       -
                           controller: _handleController,

     

       114
       114
       -
                           enabled: !_isLoading,

     

       115
       115
       -
                           style: const TextStyle(color: Colors.white),

     

       116
       116
       -
                           decoration: InputDecoration(

     

       117
       117
       -
                             hintText: 'alice.bsky.social',

     

       118
       118
       -
                             hintStyle: const TextStyle(color: Color(0xFF5A6B7F)),

     

       119
       119
       -
                             filled: true,

     

       120
       120
       -
                             fillColor: const Color(0xFF1A2028),

     

       121
       121
       -
                             border: OutlineInputBorder(

     

       122
       122
       -
                               borderRadius: BorderRadius.circular(12),

     

       123
       123
       -
                               borderSide: const BorderSide(color: Color(0xFF2A3441)),

     

       126
       126
       +
               body: GestureDetector(

     

       127
       127
       +
                 behavior: HitTestBehavior.opaque,

     

       128
       128
       +
                 onTap: () => FocusScope.of(context).unfocus(),

     

       129
       129
       +
                 child: SafeArea(

     

       130
       130
       +
                   child: Padding(

     

       131
       131
       +
                     padding: const EdgeInsets.all(24),

     

       132
       132
       +
                     child: Form(

     

       133
       133
       +
                       key: _formKey,

     

       134
       134
       +
                       child: Column(

     

       135
       135
       +
                         crossAxisAlignment: CrossAxisAlignment.stretch,

     

       136
       136
       +
                         children: [

     

       137
       137
       +
                           const SizedBox(height: 32),

     

       138
       138
       +
       

     

       139
       139
       +
                           // Title

     

       140
       140
       +
                           const Text(

     

       141
       141
       +
                             'Enter your atproto handle',

     

       142
       142
       +
                             style: TextStyle(

     

       143
       143
       +
                               fontSize: 24,

     

       144
       144
       +
                               color: Colors.white,

     

       145
       145
       +
                               fontWeight: FontWeight.bold,

     

       124
       146
        
                             ),

     

       125
       125
       -
                             enabledBorder: OutlineInputBorder(

     

       126
       126
       -
                               borderRadius: BorderRadius.circular(12),

     

       127
       127
       -
                               borderSide: const BorderSide(color: Color(0xFF2A3441)),

     

       147
       147
       +
                             textAlign: TextAlign.center,

     

       148
       148
       +
                           ),

     

       149
       149
       +
       

     

       150
       150
       +
                           const SizedBox(height: 12),

     

       151
       151
       +
       

     

       152
       152
       +
                           // Provider logos

     

       153
       153
       +
                           Center(

     

       154
       154
       +
                             child: SvgPicture.asset(

     

       155
       155
       +
                               'assets/icons/atproto/providers_stack.svg',

     

       156
       156
       +
                               height: 24,

     

       157
       157
       +
                               errorBuilder: (context, error, stackTrace) {

     

       158
       158
       +
                                 debugPrint(

     

       159
       159
       +
                                   'Failed to load providers_stack.svg: $error',

     

       160
       160
       +
                                 );

     

       161
       161
       +
                                 return const SizedBox(height: 24);

     

       162
       162
       +
                               },

     

       128
       163
        
                             ),

     

       129
       129
       -
                             focusedBorder: OutlineInputBorder(

     

       130
       130
       -
                               borderRadius: BorderRadius.circular(12),

     

       131
       131
       -
                               borderSide: const BorderSide(

     

       132
       132
       -
                                 color: AppColors.primary,

     

       133
       133
       -
                                 width: 2,

     

       164
       164
       +
                           ),

     

       165
       165
       +
       

     

       166
       166
       +
                           const SizedBox(height: 32),

     

       167
       167
       +
       

     

       168
       168
       +
                           // Handle input field

     

       169
       169
       +
                           TextFormField(

     

       170
       170
       +
                             controller: _handleController,

     

       171
       171
       +
                             enabled: !_isLoading,

     

       172
       172
       +
                             style: const TextStyle(color: Colors.white),

     

       173
       173
       +
                             decoration: InputDecoration(

     

       174
       174
       +
                               hintText: 'alice.bsky.social',

     

       175
       175
       +
                               hintStyle: const TextStyle(color: Color(0xFF5A6B7F)),

     

       176
       176
       +
                               filled: true,

     

       177
       177
       +
                               fillColor: const Color(0xFF1A2028),

     

       178
       178
       +
                               border: OutlineInputBorder(

     

       179
       179
       +
                                 borderRadius: BorderRadius.circular(12),

     

       180
       180
       +
                                 borderSide: const BorderSide(

     

       181
       181
       +
                                   color: Color(0xFF2A3441),

     

       182
       182
       +
                                 ),

     

       134
       183
        
                               ),

     

       184
       184
       +
                               enabledBorder: OutlineInputBorder(

     

       185
       185
       +
                                 borderRadius: BorderRadius.circular(12),

     

       186
       186
       +
                                 borderSide: const BorderSide(

     

       187
       187
       +
                                   color: Color(0xFF2A3441),

     

       188
       188
       +
                                 ),

     

       189
       189
       +
                               ),

     

       190
       190
       +
                               focusedBorder: OutlineInputBorder(

     

       191
       191
       +
                                 borderRadius: BorderRadius.circular(12),

     

       192
       192
       +
                                 borderSide: const BorderSide(

     

       193
       193
       +
                                   color: AppColors.primary,

     

       194
       194
       +
                                   width: 2,

     

       195
       195
       +
                                 ),

     

       196
       196
       +
                               ),

     

       197
       197
       +
                               prefixIcon: const Padding(

     

       198
       198
       +
                                 padding: EdgeInsets.only(left: 16, right: 8),

     

       199
       199
       +
                                 child: Text(

     

       200
       200
       +
                                   '@',

     

       201
       201
       +
                                   style: TextStyle(

     

       202
       202
       +
                                     color: Color(0xFF5A6B7F),

     

       203
       203
       +
                                     fontSize: 18,

     

       204
       204
       +
                                     fontWeight: FontWeight.w500,

     

       205
       205
       +
                                   ),

     

       206
       206
       +
                                 ),

     

       207
       207
       +
                               ),

     

       208
       208
       +
                               prefixIconConstraints: const BoxConstraints(),

     

       135
       209
        
                             ),

     

       136
       136
       -
                             prefixIcon: const Icon(

     

       137
       137
       -
                               Icons.person,

     

       138
       138
       -
                               color: Color(0xFF5A6B7F),

     

       139
       139
       -
                             ),

     

       140
       140
       -
                           ),

     

       141
       141
       -
                           keyboardType: TextInputType.emailAddress,

     

       142
       142
       -
                           autocorrect: false,

     

       143
       143
       -
                           textInputAction: TextInputAction.done,

     

       144
       144
       -
                           onFieldSubmitted: (_) => _handleSignIn(),

     

       145
       145
       -
                           validator: (value) {

     

       146
       146
       -
                             if (value == null || value.trim().isEmpty) {

     

       147
       147
       -
                               return 'Please enter your handle';

     

       148
       148
       -
                             }

     

       149
       149
       -
                             // Basic handle validation

     

       150
       150
       -
                             if (!value.contains('.')) {

     

       151
       151
       -
                               return 'Handle must contain a domain '

     

       152
       152
       -
                                   '(e.g., user.bsky.social)';

     

       153
       153
       -
                             }

     

       154
       154
       -
                             return null;

     

       155
       155
       -
                           },

     

       156
       156
       -
                         ),

     

       157
       157
       -
       

     

       158
       158
       -
                         const SizedBox(height: 32),

     

       159
       159
       -
       

     

       160
       160
       -
                         // Sign in button

     

       161
       161
       -
                         PrimaryButton(

     

       162
       162
       -
                           title: _isLoading ? 'Signing in...' : 'Sign In',

     

       163
       163
       -
                           onPressed: _isLoading ? () {} : _handleSignIn,

     

       164
       164
       -
                           disabled: _isLoading,

     

       165
       165
       -
                         ),

     

       166
       166
       -
       

     

       167
       167
       -
                         const SizedBox(height: 24),

     

       168
       168
       -
       

     

       169
       169
       -
                         // Info text

     

       170
       170
       -
                         const Text(

     

       171
       171
       -
                           'You\'ll be redirected to authorize this app with your '

     

       172
       172
       -
                           'atProto provider.',

     

       173
       173
       -
                           style: TextStyle(fontSize: 14, color: Color(0xFF5A6B7F)),

     

       174
       174
       -
                           textAlign: TextAlign.center,

     

       175
       175
       -
                         ),

     

       176
       176
       -
       

     

       177
       177
       -
                         const Spacer(),

     

       178
       178
       -
       

     

       179
       179
       -
                         // Help text

     

       180
       180
       -
                         Center(

     

       181
       181
       -
                           child: TextButton(

     

       182
       182
       -
                             onPressed: () {

     

       183
       183
       -
                               showDialog(

     

       184
       184
       -
                                 context: context,

     

       185
       185
       -
                                 builder:

     

       186
       186
       -
                                     (context) => AlertDialog(

     

       187
       187
       -
                                       backgroundColor: const Color(0xFF1A2028),

     

       188
       188
       -
                                       title: const Text(

     

       189
       189
       -
                                         'What is a handle?',

     

       190
       190
       -
                                         style: TextStyle(color: Colors.white),

     

       191
       191
       -
                                       ),

     

       192
       192
       -
                                       content: const Text(

     

       193
       193
       -
                                         'Your handle is your unique identifier '

     

       194
       194
       -
                                         'on the atProto network, like '

     

       195
       195
       -
                                         'alice.bsky.social. If you don\'t have one '

     

       196
       196
       -
                                         'yet, you can create an account at bsky.app.',

     

       197
       197
       -
                                         style: TextStyle(color: Color(0xFFB6C2D2)),

     

       198
       198
       -
                                       ),

     

       199
       199
       -
                                       actions: [

     

       200
       200
       -
                                         TextButton(

     

       201
       201
       -
                                           onPressed:

     

       202
       202
       -
                                               () => Navigator.of(context).pop(),

     

       203
       203
       -
                                           child: const Text('Got it'),

     

       204
       204
       -
                                         ),

     

       205
       205
       -
                                       ],

     

       206
       206
       -
                                     ),

     

       207
       207
       -
                               );

     

       210
       210
       +
                             keyboardType: TextInputType.emailAddress,

     

       211
       211
       +
                             autocorrect: false,

     

       212
       212
       +
                             textInputAction: TextInputAction.done,

     

       213
       213
       +
                             onFieldSubmitted: (_) => _handleSignIn(),

     

       214
       214
       +
                             validator: (value) {

     

       215
       215
       +
                               if (value == null || value.trim().isEmpty) {

     

       216
       216
       +
                                 return 'Please enter your handle';

     

       217
       217
       +
                               }

     

       218
       218
       +
                               // Basic handle validation

     

       219
       219
       +
                               if (!value.contains('.')) {

     

       220
       220
       +
                                 return 'Handle must contain a domain '

     

       221
       221
       +
                                     '(e.g., user.bsky.social)';

     

       222
       222
       +
                               }

     

       223
       223
       +
                               return null;

     

       208
       224
        
                             },

     

       209
       209
       -
                             child: const Text(

     

       210
       210
       -
                               'What is a handle?',

     

       211
       211
       -
                               style: TextStyle(

     

       212
       212
       -
                                 color: AppColors.primary,

     

       213
       213
       -
                                 decoration: TextDecoration.underline,

     

       225
       225
       +
                           ),

     

       226
       226
       +
       

     

       227
       227
       +
                           const SizedBox(height: 32),

     

       228
       228
       +
       

     

       229
       229
       +
                           // Sign in button

     

       230
       230
       +
                           PrimaryButton(

     

       231
       231
       +
                             title: _isLoading ? 'Signing in...' : 'Sign In',

     

       232
       232
       +
                             onPressed: _isLoading ? () {} : _handleSignIn,

     

       233
       233
       +
                             disabled: _isLoading,

     

       234
       234
       +
                           ),

     

       235
       235
       +
       

     

       236
       236
       +
                           const SizedBox(height: 24),

     

       237
       237
       +
       

     

       238
       238
       +
                           // Info text

     

       239
       239
       +
                           const Text(

     

       240
       240
       +
                             'You\'ll be redirected to authorize this app with your '

     

       241
       241
       +
                             'atproto provider.',

     

       242
       242
       +
                             style: TextStyle(fontSize: 14, color: Color(0xFF5A6B7F)),

     

       243
       243
       +
                             textAlign: TextAlign.center,

     

       244
       244
       +
                           ),

     

       245
       245
       +
       

     

       246
       246
       +
                           const Spacer(),

     

       247
       247
       +
       

     

       248
       248
       +
                           // Help text

     

       249
       249
       +
                           Center(

     

       250
       250
       +
                             child: TextButton(

     

       251
       251
       +
                               onPressed: _showHandleHelpDialog,

     

       252
       252
       +
                               child: const Text(

     

       253
       253
       +
                                 'What is a handle?',

     

       254
       254
       +
                                 style: TextStyle(

     

       255
       255
       +
                                   color: AppColors.primary,

     

       256
       256
       +
                                   decoration: TextDecoration.underline,

     

       257
       257
       +
                                 ),

     

       214
       258
        
                               ),

     

       215
       259
        
                             ),

     

       216
       260
        
                           ),

     

       217
       217
       -
                         ),

     

       218
       218
       -
                       ],

     

       261
       261
       +
                         ],

     

       262
       262
       +
                       ),

     

       219
       263
        
                     ),

     

       220
       264
        
                   ),

     

       221
       265
        
                 ),

+50 -11

lib/screens/landing_screen.dart

···

       1
       1
        
       import 'package:flutter/material.dart';

     

       2
       2
        
       import 'package:flutter_svg/flutter_svg.dart';

     

       3
       3
        
       import 'package:go_router/go_router.dart';

     

       4
       4
       +
       

     

       5
       5
       +
       import '../constants/app_colors.dart';

     

       4
       6
        
       import '../widgets/primary_button.dart';

     

       5
       7
        
       

     

       6
       8
        
       class LandingScreen extends StatelessWidget {

     
···

       9
       11
        
         @override

     

       10
       12
        
         Widget build(BuildContext context) {

     

       11
       13
        
           return Scaffold(

     

       12
       12
       -
             backgroundColor: const Color(0xFF0B0F14),

     

       14
       14
       +
             backgroundColor: AppColors.background,

     

       13
       15
        
             body: SafeArea(

     

       14
       16
        
               child: Center(

     

       15
       17
        
                 child: Padding(

     
···

       22
       24
        
                         'assets/logo/lil_dude.svg',

     

       23
       25
        
                         width: 120,

     

       24
       26
        
                         height: 120,

     

       27
       27
       +
                         errorBuilder: (context, error, stackTrace) {

     

       28
       28
       +
                           debugPrint('Failed to load lil_dude.svg: $error');

     

       29
       29
       +
                           return const SizedBox(width: 120, height: 120);

     

       30
       30
       +
                         },

     

       25
       31
        
                       ),

     

       26
       32
        
                       const SizedBox(height: 16),

     

       27
       33
        
       

     
···

       30
       36
        
                         'assets/logo/coves_bubble.svg',

     

       31
       37
        
                         width: 180,

     

       32
       38
        
                         height: 60,

     

       39
       39
       +
                         errorBuilder: (context, error, stackTrace) {

     

       40
       40
       +
                           debugPrint('Failed to load coves_bubble.svg: $error');

     

       41
       41
       +
                           return const SizedBox(width: 180, height: 60);

     

       42
       42
       +
                         },

     

       33
       43
        
                       ),

     

       34
       44
        
       

     

       35
       45
        
                       const SizedBox(height: 48),

     

       36
       46
        
       

     

       37
       37
       -
                       // Buttons

     

       47
       47
       +
                       // "Bring your @handle" with logos

     

       48
       48
       +
                       Row(

     

       49
       49
       +
                         mainAxisAlignment: MainAxisAlignment.center,

     

       50
       50
       +
                         children: [

     

       51
       51
       +
                           const Text(

     

       52
       52
       +
                             'Bring your atproto handle',

     

       53
       53
       +
                             style: TextStyle(

     

       54
       54
       +
                               fontSize: 14,

     

       55
       55
       +
                               color: Color(0xFF8A96A6),

     

       56
       56
       +
                               fontWeight: FontWeight.w500,

     

       57
       57
       +
                             ),

     

       58
       58
       +
                           ),

     

       59
       59
       +
                           const SizedBox(width: 8),

     

       60
       60
       +
                           SvgPicture.asset(

     

       61
       61
       +
                             'assets/icons/atproto/providers_landing.svg',

     

       62
       62
       +
                             height: 18,

     

       63
       63
       +
                             errorBuilder: (context, error, stackTrace) {

     

       64
       64
       +
                               debugPrint(

     

       65
       65
       +
                                 'Failed to load providers_landing.svg: $error',

     

       66
       66
       +
                               );

     

       67
       67
       +
                               return const SizedBox(height: 18);

     

       68
       68
       +
                             },

     

       69
       69
       +
                           ),

     

       70
       70
       +
                         ],

     

       71
       71
       +
                       ),

     

       72
       72
       +
       

     

       73
       73
       +
                       const SizedBox(height: 16),

     

       74
       74
       +
       

     

       75
       75
       +
                       // Sign in button

     

       38
       76
        
                       PrimaryButton(

     

       39
       39
       -
                         title: 'Create account',

     

       77
       77
       +
                         title: 'Sign in',

     

       40
       78
        
                         onPressed: () {

     

       41
       41
       -
                           ScaffoldMessenger.of(context).showSnackBar(

     

       42
       42
       -
                             const SnackBar(

     

       43
       43
       -
                               content: Text('Account registration coming soon!'),

     

       44
       44
       -
                               duration: Duration(seconds: 2),

     

       45
       45
       -
                             ),

     

       46
       46
       -
                           );

     

       79
       79
       +
                           context.go('/login');

     

       47
       80
        
                         },

     

       48
       81
        
                       ),

     

       49
       82
        
       

     

       50
       83
        
                       const SizedBox(height: 12),

     

       51
       84
        
       

     

       85
       85
       +
                       // Create account button

     

       52
       86
        
                       PrimaryButton(

     

       53
       53
       -
                         title: 'Sign in',

     

       87
       87
       +
                         title: 'Create account',

     

       54
       88
        
                         onPressed: () {

     

       55
       55
       -
                           context.go('/login');

     

       89
       89
       +
                           ScaffoldMessenger.of(context).showSnackBar(

     

       90
       90
       +
                             const SnackBar(

     

       91
       91
       +
                               content: Text('Account registration coming soon!'),

     

       92
       92
       +
                               duration: Duration(seconds: 2),

     

       93
       93
       +
                             ),

     

       94
       94
       +
                           );

     

       56
       95
        
                         },

     

       57
       96
        
                         variant: ButtonVariant.outline,

     

       58
       97
        
                       ),

pubspec.yaml

···

       93
       93
        
           - assets/logo/coves_bubble.svg

     

       94
       94
        
           - assets/logo/lil_dude.svg

     

       95
       95
        
           - assets/icons/

     

       96
       96
       +
           - assets/icons/atproto/

     

       96
       97
        
       

     

       97
       98
        
         # An image asset can refer to one or more resolution-specific "variants", see

     

       98
       99
        
         # https://flutter.dev/to/resolution-aware-images

.gitignore

···

       50
       50
        
       

     

       51
       51
        
       # macOS (not targeting this platform)

     

       52
       52
        
       macos/

     

       53
       53
       +
       

     

       54
       54
       +
       # Claude Code local settings

     

       55
       55
       +
       .claude/settings.local.json

Compare changes