-153

lib/dpop_client.dart

··· 1 1 - import 'dart:convert'; 2 2 - 3 3 - import 'package:crypto/crypto.dart'; 4 4 - import 'package:http/http.dart' as http; 5 5 - import 'package:jose/jose.dart'; 6 6 - import 'package:uuid/uuid.dart'; 7 7 - 8 8 - class DpopHttpClient { 9 9 - final JsonWebKey dpopKey; 10 10 - final Map<String, String> _nonces = {}; // origin -> nonce 11 11 - 12 12 - DpopHttpClient({required this.dpopKey}); 13 13 - 14 14 - /// Extract origin (scheme + host + port) from a URL 15 15 - String _extractOrigin(String url) { 16 16 - final uri = Uri.parse(url); 17 17 - final portPart = (uri.hasPort && uri.port != 80 && uri.port != 443) ? ':${uri.port}' : ''; 18 18 - return '${uri.scheme}://${uri.host}$portPart'; 19 19 - } 20 20 - 21 21 - /// Strip query and fragment from URL per spec 22 22 - String _buildHtu(String url) { 23 23 - final uri = Uri.parse(url); 24 24 - return '${uri.scheme}://${uri.host}${uri.path}'; 25 25 - } 26 26 - 27 27 - /// Calculate ath claim: base64url(sha256(access_token)) 28 28 - String _calculateAth(String accessToken) { 29 29 - final hash = sha256.convert(utf8.encode(accessToken)); 30 30 - return base64Url.encode(hash.bytes).replaceAll('=', ''); 31 31 - } 32 32 - 33 33 - /// Calculate the JWK Thumbprint for EC or RSA keys per RFC 7638. 34 34 - /// The input [jwk] is the public part of your key as a Map`<String, dynamic>`. 35 35 - /// 36 36 - /// For EC keys, required fields are: crv, kty, x, y 37 37 - /// For RSA keys, required fields are: e, kty, n 38 38 - String calculateJwkThumbprint(Map<String, dynamic> jwk) { 39 39 - late Map<String, String> ordered; 40 40 - 41 41 - if (jwk['kty'] == 'EC') { 42 42 - ordered = {'crv': jwk['crv'], 'kty': jwk['kty'], 'x': jwk['x'], 'y': jwk['y']}; 43 43 - } else if (jwk['kty'] == 'RSA') { 44 44 - ordered = {'e': jwk['e'], 'kty': jwk['kty'], 'n': jwk['n']}; 45 45 - } else { 46 46 - throw ArgumentError('Unsupported key type for thumbprint calculation'); 47 47 - } 48 48 - 49 49 - final jsonString = jsonEncode(ordered); 50 50 - 51 51 - final digest = sha256.convert(utf8.encode(jsonString)); 52 52 - return base64Url.encode(digest.bytes).replaceAll('=', ''); 53 53 - } 54 54 - 55 55 - /// Build the DPoP JWT proof 56 56 - Future<String> _buildProof({ 57 57 - required String htm, 58 58 - required String htu, 59 59 - String? nonce, 60 60 - String? ath, 61 61 - }) async { 62 62 - final now = (DateTime.now().millisecondsSinceEpoch / 1000).floor(); 63 63 - final jti = Uuid().v4(); 64 64 - 65 65 - final publicJwk = Map<String, String>.from(dpopKey.toJson())..remove('d'); 66 66 - 67 67 - final payload = { 68 68 - 'htu': htu, 69 69 - 'htm': htm, 70 70 - 'iat': now, 71 71 - 'jti': jti, 72 72 - if (nonce != null) 'nonce': nonce, 73 73 - if (ath != null) 'ath': ath, 74 74 - }; 75 75 - 76 76 - final builder = JsonWebSignatureBuilder() 77 77 - ..jsonContent = payload 78 78 - ..addRecipient(dpopKey, algorithm: dpopKey.algorithm) 79 79 - ..setProtectedHeader('typ', 'dpop+jwt') 80 80 - ..setProtectedHeader('jwk', publicJwk); 81 81 - 82 82 - final jws = builder.build(); 83 83 - return jws.toCompactSerialization(); 84 84 - } 85 85 - 86 86 - /// Public method to send requests with DPoP proof, retries once on use_dpop_nonce error 87 87 - Future<http.Response> send({ 88 88 - required String method, 89 89 - required Uri url, 90 90 - required String accessToken, 91 91 - Map<String, String>? headers, 92 92 - Object? body, 93 93 - }) async { 94 94 - final origin = _extractOrigin(url.toString()); 95 95 - final nonce = _nonces[origin]; 96 96 - 97 97 - final htu = _buildHtu(url.toString()); 98 98 - final ath = _calculateAth(accessToken); 99 99 - 100 100 - final proof = await _buildProof(htm: method.toUpperCase(), htu: htu, nonce: nonce, ath: ath); 101 101 - 102 102 - // Compose headers, allowing override of Content-Type for raw uploads 103 103 - final requestHeaders = <String, String>{ 104 104 - 'Authorization': 'DPoP $accessToken', 105 105 - 'DPoP': proof, 106 106 - if (headers != null) ...headers, 107 107 - }; 108 108 - 109 109 - http.Response response; 110 110 - switch (method.toUpperCase()) { 111 111 - case 'GET': 112 112 - response = await http.get(url, headers: requestHeaders); 113 113 - break; 114 114 - case 'POST': 115 115 - response = await http.post(url, headers: requestHeaders, body: body); 116 116 - break; 117 117 - case 'PUT': 118 118 - response = await http.put(url, headers: requestHeaders, body: body); 119 119 - break; 120 120 - case 'DELETE': 121 121 - response = await http.delete(url, headers: requestHeaders, body: body); 122 122 - break; 123 123 - default: 124 124 - throw UnsupportedError('Unsupported HTTP method: $method'); 125 125 - } 126 126 - 127 127 - final newNonce = response.headers['dpop-nonce']; 128 128 - if (newNonce != null && newNonce != nonce) { 129 129 - // Save new nonce for origin 130 130 - _nonces[origin] = newNonce; 131 131 - } 132 132 - 133 133 - if (response.statusCode == 401) { 134 134 - final wwwAuth = response.headers['www-authenticate']; 135 135 - if (wwwAuth != null && 136 136 - wwwAuth.contains('DPoP') && 137 137 - wwwAuth.contains('error="use_dpop_nonce"') && 138 138 - newNonce != null && 139 139 - newNonce != nonce) { 140 140 - // Retry once with updated nonce 141 141 - return send( 142 142 - method: method, 143 143 - url: url, 144 144 - accessToken: accessToken, 145 145 - headers: headers, 146 146 - body: body, 147 147 - ); 148 148 - } 149 149 - } 150 150 - 151 151 - return response; 152 152 - } 153 153 - }

+1

lib/models/photo_exif.dart

··· 20 20 String? lensModel, 21 21 String? make, 22 22 String? model, 23 23 + Map<String, dynamic>? record, 23 24 }) = _PhotoExif; 24 25 25 26 factory PhotoExif.fromJson(Map<String, dynamic> json) => _$PhotoExifFromJson(json);

+31 -3

lib/models/photo_exif.freezed.dart

··· 36 36 String? get lensModel => throw _privateConstructorUsedError; 37 37 String? get make => throw _privateConstructorUsedError; 38 38 String? get model => throw _privateConstructorUsedError; 39 39 + Map<String, dynamic>? get record => throw _privateConstructorUsedError; 39 40 40 41 /// Serializes this PhotoExif to a JSON map. 41 42 Map<String, dynamic> toJson() => throw _privateConstructorUsedError; ··· 67 68 String? lensModel, 68 69 String? make, 69 70 String? model, 71 71 + Map<String, dynamic>? record, 70 72 }); 71 73 } 72 74 ··· 99 101 Object? lensModel = freezed, 100 102 Object? make = freezed, 101 103 Object? model = freezed, 104 104 + Object? record = freezed, 102 105 }) { 103 106 return _then( 104 107 _value.copyWith( ··· 158 161 ? _value.model 159 162 : model // ignore: cast_nullable_to_non_nullable 160 163 as String?, 164 164 + record: freezed == record 165 165 + ? _value.record 166 166 + : record // ignore: cast_nullable_to_non_nullable 167 167 + as Map<String, dynamic>?, 161 168 ) 162 169 as $Val, 163 170 ); ··· 188 195 String? lensModel, 189 196 String? make, 190 197 String? model, 198 198 + Map<String, dynamic>? record, 191 199 }); 192 200 } 193 201 ··· 219 227 Object? lensModel = freezed, 220 228 Object? make = freezed, 221 229 Object? model = freezed, 230 230 + Object? record = freezed, 222 231 }) { 223 232 return _then( 224 233 _$PhotoExifImpl( ··· 278 287 ? _value.model 279 288 : model // ignore: cast_nullable_to_non_nullable 280 289 as String?, 290 290 + record: freezed == record 291 291 + ? _value._record 292 292 + : record // ignore: cast_nullable_to_non_nullable 293 293 + as Map<String, dynamic>?, 281 294 ), 282 295 ); 283 296 } ··· 301 314 this.lensModel, 302 315 this.make, 303 316 this.model, 304 304 - }); 317 317 + final Map<String, dynamic>? record, 318 318 + }) : _record = record; 305 319 306 320 factory _$PhotoExifImpl.fromJson(Map<String, dynamic> json) => 307 321 _$$PhotoExifImplFromJson(json); ··· 339 353 final String? make; 340 354 @override 341 355 final String? model; 356 356 + final Map<String, dynamic>? _record; 357 357 + @override 358 358 + Map<String, dynamic>? get record { 359 359 + final value = _record; 360 360 + if (value == null) return null; 361 361 + if (_record is EqualUnmodifiableMapView) return _record; 362 362 + // ignore: implicit_dynamic_type 363 363 + return EqualUnmodifiableMapView(value); 364 364 + } 342 365 343 366 @override 344 367 String toString() { 345 345 - return 'PhotoExif(photo: $photo, createdAt: $createdAt, uri: $uri, cid: $cid, dateTimeOriginal: $dateTimeOriginal, exposureTime: $exposureTime, fNumber: $fNumber, flash: $flash, focalLengthIn35mmFormat: $focalLengthIn35mmFormat, iSO: $iSO, lensMake: $lensMake, lensModel: $lensModel, make: $make, model: $model)'; 368 368 + return 'PhotoExif(photo: $photo, createdAt: $createdAt, uri: $uri, cid: $cid, dateTimeOriginal: $dateTimeOriginal, exposureTime: $exposureTime, fNumber: $fNumber, flash: $flash, focalLengthIn35mmFormat: $focalLengthIn35mmFormat, iSO: $iSO, lensMake: $lensMake, lensModel: $lensModel, make: $make, model: $model, record: $record)'; 346 369 } 347 370 348 371 @override ··· 372 395 (identical(other.lensModel, lensModel) || 373 396 other.lensModel == lensModel) && 374 397 (identical(other.make, make) || other.make == make) && 375 375 - (identical(other.model, model) || other.model == model)); 398 398 + (identical(other.model, model) || other.model == model) && 399 399 + const DeepCollectionEquality().equals(other._record, _record)); 376 400 } 377 401 378 402 @JsonKey(includeFromJson: false, includeToJson: false) ··· 393 417 lensModel, 394 418 make, 395 419 model, 420 420 + const DeepCollectionEquality().hash(_record), 396 421 ); 397 422 398 423 /// Create a copy of PhotoExif ··· 425 450 final String? lensModel, 426 451 final String? make, 427 452 final String? model, 453 453 + final Map<String, dynamic>? record, 428 454 }) = _$PhotoExifImpl; 429 455 430 456 factory _PhotoExif.fromJson(Map<String, dynamic> json) = ··· 458 484 String? get make; 459 485 @override 460 486 String? get model; 487 487 + @override 488 488 + Map<String, dynamic>? get record; 461 489 462 490 /// Create a copy of PhotoExif 463 491 /// with the given fields replaced by the non-null parameter values.

+2

lib/models/photo_exif.g.dart

··· 22 22 lensModel: json['lensModel'] as String?, 23 23 make: json['make'] as String?, 24 24 model: json['model'] as String?, 25 25 + record: json['record'] as Map<String, dynamic>?, 25 26 ); 26 27 27 28 Map<String, dynamic> _$$PhotoExifImplToJson(_$PhotoExifImpl instance) => ··· 40 41 'lensModel': instance.lensModel, 41 42 'make': instance.make, 42 43 'model': instance.model, 44 44 + 'record': instance.record, 43 45 };

+22

lib/providers/actor_search_provider.dart

··· 1 1 + import 'package:flutter_riverpod/flutter_riverpod.dart'; 2 2 + 3 3 + import '../api.dart'; 4 4 + import '../models/profile.dart'; 5 5 + 6 6 + final actorSearchProvider = StateNotifierProvider<ActorSearchNotifier, Map<String, List<Profile>>>( 7 7 + (ref) => ActorSearchNotifier(), 8 8 + ); 9 9 + 10 10 + class ActorSearchNotifier extends StateNotifier<Map<String, List<Profile>>> { 11 11 + ActorSearchNotifier() : super({}); 12 12 + 13 13 + Future<List<Profile>> search(String query) async { 14 14 + if (query.isEmpty) return []; 15 15 + if (state.containsKey(query)) { 16 16 + return state[query]!; 17 17 + } 18 18 + final results = await apiService.searchActors(query); 19 19 + state = {...state, query: results}; 20 20 + return results; 21 21 + } 22 22 + }

+1 -1

lib/providers/gallery_cache_provider.g.dart

··· 6 6 // RiverpodGenerator 7 7 // ************************************************************************** 8 8 9 9 - String _$galleryCacheHash() => r'd74ced0d6fcf6369bed80f7f0219bd591c13db5a'; 9 9 + String _$galleryCacheHash() => r'd604bfc71f008251a36d7943b99294728c31de1f'; 10 10 11 11 /// Holds a cache of galleries by URI. 12 12 ///

+5 -31

lib/providers/profile_provider.dart

··· 22 22 return _fetchProfile(did); 23 23 } 24 24 25 25 - // @TODO: Facets don't always render correctly. 26 26 - List<Map<String, dynamic>>? _filterValidFacets( 27 27 - List<Map<String, dynamic>>? computedFacets, 28 28 - String desc, 29 29 - ) { 30 30 - if (computedFacets == null) return null; 31 31 - return computedFacets.where((facet) { 32 32 - final index = facet['index']; 33 33 - if (index is Map) { 34 34 - final start = index['byteStart'] ?? 0; 35 35 - final end = index['byteEnd'] ?? 0; 36 36 - return start is int && end is int && start >= 0 && end > start && end <= desc.length; 37 37 - } 38 38 - final start = facet['index'] ?? facet['offset'] ?? 0; 39 39 - final end = facet['end']; 40 40 - final length = facet['length']; 41 41 - if (end is int && start is int) { 42 42 - return start >= 0 && end > start && end <= desc.length; 43 43 - } else if (length is int && start is int) { 44 44 - return start >= 0 && length > 0 && start + length <= desc.length; 45 45 - } 46 46 - return false; 47 47 - }).toList(); 48 48 - } 49 49 - 50 50 - // Extract facet computation and filtering for reuse 51 51 - Future<List<Map<String, dynamic>>?> computeAndFilterFacets(String? description) async { 25 25 + // Extract facets 26 26 + Future<List<Map<String, dynamic>>?> _extractFacets(String? description) async { 52 27 final desc = description ?? ''; 53 28 if (desc.isEmpty) return null; 54 29 try { 55 30 final blueskyText = BlueskyText(desc); 56 31 final entities = blueskyText.entities; 57 57 - final computedFacets = await entities.toFacets(); 58 58 - return _filterValidFacets(computedFacets, desc); 32 32 + return entities.toFacets(); 59 33 } catch (_) { 60 34 return null; 61 35 } ··· 66 40 final galleries = await apiService.fetchActorGalleries(did: did); 67 41 final favs = await apiService.getActorFavs(did: did); 68 42 if (profile != null) { 69 69 - final facets = await computeAndFilterFacets(profile.description); 43 43 + final facets = await _extractFacets(profile.description); 70 44 return ProfileWithGalleries( 71 45 profile: profile.copyWith(descriptionFacets: facets), 72 46 galleries: galleries, ··· 108 82 final updated = await apiService.fetchProfile(did: did); 109 83 if (updated != null) { 110 84 final galleries = await apiService.fetchActorGalleries(did: did); 111 111 - final facets = await computeAndFilterFacets(updated.description); 85 85 + final facets = await _extractFacets(updated.description); 112 86 ref.read(galleryCacheProvider.notifier).setGalleriesForActor(did, galleries); 113 87 state = AsyncValue.data( 114 88 ProfileWithGalleries(

+1 -1

lib/providers/profile_provider.g.dart

··· 6 6 // RiverpodGenerator 7 7 // ************************************************************************** 8 8 9 9 - String _$profileNotifierHash() => r'48159a8319bba2f2ec5462c50d80ba6a5b72d91e'; 9 9 + String _$profileNotifierHash() => r'4b8e3a8d4363beb885ead4ae7ce9c52101a6bf96'; 10 10 11 11 /// Copied from Dart SDK 12 12 class _SystemHash {

+68 -11

lib/screens/create_gallery_page.dart

··· 11 11 import 'package:grain/models/gallery.dart'; 12 12 import 'package:grain/providers/profile_provider.dart'; 13 13 import 'package:grain/widgets/app_button.dart'; 14 14 + import 'package:grain/widgets/faceted_text_field.dart'; 14 15 import 'package:grain/widgets/plain_text_field.dart'; 15 16 import 'package:grain/widgets/upload_progress_overlay.dart'; 16 17 import 'package:image_picker/image_picker.dart'; ··· 65 66 }); 66 67 } 67 68 69 69 + @override 70 70 + void dispose() { 71 71 + _titleController.dispose(); 72 72 + _descController.dispose(); 73 73 + super.dispose(); 74 74 + } 75 75 + 68 76 Future<String> _computeMd5(XFile xfile) async { 69 77 final bytes = await xfile.readAsBytes(); 70 78 return md5.convert(bytes).toString(); ··· 72 80 73 81 Future<void> _pickImages() async { 74 82 if (widget.gallery != null) return; // Only allow picking on create 83 83 + 84 84 + final remainingSlots = 10 - _images.length; 85 85 + if (remainingSlots <= 0) { 86 86 + if (mounted) { 87 87 + ScaffoldMessenger.of(context).showSnackBar( 88 88 + const SnackBar( 89 89 + content: Text('You\'ve already added the maximum of 10 photos.'), 90 90 + duration: Duration(seconds: 2), 91 91 + ), 92 92 + ); 93 93 + } 94 94 + return; 95 95 + } 96 96 + 75 97 final picker = ImagePicker(); 76 98 final picked = await picker.pickMultiImage(imageQuality: 85); 77 99 if (picked.isNotEmpty) { ··· 81 103 final hash = await _computeMd5(img.file); 82 104 existingHashes.add(hash); 83 105 } 106 106 + 84 107 final newImages = <GalleryImage>[]; 85 108 int skipped = 0; 109 109 + int limitReached = 0; 110 110 + 86 111 for (final xfile in picked) { 112 112 + // Check if we've reached the limit 113 113 + if (_images.length + newImages.length >= 10) { 114 114 + limitReached = picked.length - picked.indexOf(xfile); 115 115 + break; 116 116 + } 117 117 + 87 118 final hash = await _computeMd5(xfile); 88 119 if (!existingHashes.contains(hash)) { 89 120 newImages.add(GalleryImage(file: xfile, isExisting: false)); ··· 92 123 skipped++; 93 124 } 94 125 } 126 126 + 95 127 if (newImages.isNotEmpty) { 96 128 setState(() { 97 129 _images.addAll(newImages); 98 130 }); 99 131 } 100 100 - if (skipped > 0 && mounted) { 101 101 - ScaffoldMessenger.of(context).showSnackBar( 102 102 - SnackBar( 103 103 - content: Text('Some images were skipped (duplicates).'), 104 104 - duration: const Duration(seconds: 2), 105 105 - ), 106 106 - ); 132 132 + 133 133 + // Show appropriate feedback messages 134 134 + if (mounted) { 135 135 + String message = ''; 136 136 + if (limitReached > 0 && skipped > 0) { 137 137 + message = 138 138 + 'Added ${newImages.length} photos. $skipped duplicates and $limitReached photos skipped (10 photo limit).'; 139 139 + } else if (limitReached > 0) { 140 140 + message = 141 141 + 'Added ${newImages.length} photos. $limitReached photos skipped (10 photo limit).'; 142 142 + } else if (skipped > 0) { 143 143 + message = 'Added ${newImages.length} photos. $skipped duplicates skipped.'; 144 144 + } 145 145 + 146 146 + if (message.isNotEmpty) { 147 147 + ScaffoldMessenger.of( 148 148 + context, 149 149 + ).showSnackBar(SnackBar(content: Text(message), duration: const Duration(seconds: 3))); 150 150 + } 107 151 } 108 152 } 109 153 } ··· 115 159 } 116 160 117 161 Future<void> _submit() async { 162 162 + FocusScope.of(context).unfocus(); 163 163 + 118 164 final titleGraphemes = _titleController.text.characters.length; 119 165 final descGraphemes = _descController.text.characters.length; 120 166 if (titleGraphemes > 100 || descGraphemes > 1000) { ··· 260 306 ), 261 307 leading: CupertinoButton( 262 308 padding: EdgeInsets.zero, 263 263 - onPressed: _submitting ? null : () => Navigator.of(context).pop(), 309 309 + onPressed: _submitting 310 310 + ? null 311 311 + : () { 312 312 + FocusScope.of(context).unfocus(); // Force keyboard to close 313 313 + Navigator.of(context).pop(); 314 314 + }, 264 315 child: Text( 265 316 'Cancel', 266 317 style: TextStyle(color: theme.colorScheme.primary, fontWeight: FontWeight.w600), ··· 331 382 ), 332 383 ), 333 384 const SizedBox(height: 16), 334 334 - PlainTextField( 385 385 + FacetedTextField( 335 386 label: 'Description', 336 387 controller: _descController, 337 388 maxLines: 6, ··· 387 438 children: [ 388 439 Expanded( 389 440 child: AppButton( 390 390 - label: 'Add photos (${_images.length}/10)', 391 391 - onPressed: _pickImages, 441 441 + label: _images.length >= 10 442 442 + ? 'Photos limit reached (10/10)' 443 443 + : 'Add photos (${_images.length}/10)', 444 444 + onPressed: _images.length >= 10 ? null : _pickImages, 392 445 icon: AppIcons.photoLibrary, 393 446 variant: AppButtonVariant.primary, 394 447 height: 40, ··· 492 545 493 546 Future<String?> showCreateGallerySheet(BuildContext context, {Gallery? gallery}) async { 494 547 final theme = Theme.of(context); 548 548 + 549 549 + FocusScope.of(context).unfocus(); 550 550 + 495 551 final result = await showCupertinoSheet( 496 552 context: context, 497 553 useNestedNavigation: false, ··· 500 556 child: CreateGalleryPage(gallery: gallery), 501 557 ), 502 558 ); 559 559 + 503 560 // Restore status bar style or any other cleanup 504 561 SystemChrome.setSystemUIOverlayStyle( 505 562 theme.brightness == Brightness.dark ? SystemUiOverlayStyle.light : SystemUiOverlayStyle.dark,

+601

lib/screens/photo_library_page.dart

··· 1 1 + import 'package:flutter/material.dart'; 2 2 + import 'package:grain/api.dart'; 3 3 + import 'package:grain/app_icons.dart'; 4 4 + import 'package:grain/models/gallery_photo.dart'; 5 5 + import 'package:grain/widgets/app_image.dart'; 6 6 + import 'package:grain/widgets/gallery_photo_view.dart'; 7 7 + 8 8 + class PhotoGroup { 9 9 + final String title; 10 10 + final List<GalleryPhoto> photos; 11 11 + final DateTime? sortDate; 12 12 + 13 13 + PhotoGroup({required this.title, required this.photos, this.sortDate}); 14 14 + } 15 15 + 16 16 + class PhotoLibraryPage extends StatefulWidget { 17 17 + const PhotoLibraryPage({super.key}); 18 18 + 19 19 + @override 20 20 + State<PhotoLibraryPage> createState() => _PhotoLibraryPageState(); 21 21 + } 22 22 + 23 23 + class _PhotoLibraryPageState extends State<PhotoLibraryPage> { 24 24 + List<GalleryPhoto> _photos = []; 25 25 + List<PhotoGroup> _photoGroups = []; 26 26 + bool _isLoading = true; 27 27 + String? _error; 28 28 + final ScrollController _scrollController = ScrollController(); 29 29 + double _scrollPosition = 0.0; 30 30 + 31 31 + @override 32 32 + void initState() { 33 33 + super.initState(); 34 34 + _loadPhotos(); 35 35 + _scrollController.addListener(_onScroll); 36 36 + } 37 37 + 38 38 + @override 39 39 + void dispose() { 40 40 + _scrollController.removeListener(_onScroll); 41 41 + _scrollController.dispose(); 42 42 + super.dispose(); 43 43 + } 44 44 + 45 45 + void _onScroll() { 46 46 + if (_scrollController.hasClients) { 47 47 + setState(() { 48 48 + _scrollPosition = _scrollController.offset; 49 49 + }); 50 50 + } 51 51 + } 52 52 + 53 53 + // Calculate which group is currently in view based on scroll position 54 54 + int _getCurrentGroupIndex() { 55 55 + if (!_scrollController.hasClients || _photoGroups.isEmpty) return 0; 56 56 + 57 57 + final scrollOffset = _scrollController.offset; 58 58 + final padding = 16.0; // ListView padding 59 59 + double currentOffset = padding; 60 60 + 61 61 + for (int i = 0; i < _photoGroups.length; i++) { 62 62 + final group = _photoGroups[i]; 63 63 + 64 64 + // Add space for group title 65 65 + final titleHeight = 24.0 + 12.0 + (i == 0 ? 0 : 24.0); // title + padding + top margin 66 66 + currentOffset += titleHeight; 67 67 + 68 68 + // Calculate grid height for this group 69 69 + final photos = group.photos; 70 70 + final crossAxisCount = photos.length == 1 ? 1 : (photos.length == 2 ? 2 : 3); 71 71 + final aspectRatio = photos.length <= 2 ? 1.5 : 1.0; 72 72 + final rows = (photos.length / crossAxisCount).ceil(); 73 73 + 74 74 + // Estimate grid item size based on screen width 75 75 + final screenWidth = MediaQuery.of(context).size.width; 76 76 + final gridPadding = 30.0 + 32.0; // right padding + left/right margins 77 77 + final availableWidth = screenWidth - gridPadding; 78 78 + final itemWidth = (availableWidth - (crossAxisCount - 1) * 4) / crossAxisCount; 79 79 + final itemHeight = itemWidth / aspectRatio; 80 80 + final gridHeight = rows * itemHeight + (rows - 1) * 4; // include spacing 81 81 + 82 82 + currentOffset += gridHeight; 83 83 + 84 84 + // Check if we're currently viewing this group 85 85 + if (scrollOffset < currentOffset) { 86 86 + return i; 87 87 + } 88 88 + } 89 89 + 90 90 + return _photoGroups.length - 1; // Return last group if we're at the bottom 91 91 + } 92 92 + 93 93 + Future<void> _loadPhotos() async { 94 94 + setState(() { 95 95 + _isLoading = true; 96 96 + _error = null; 97 97 + }); 98 98 + 99 99 + try { 100 100 + final currentUser = apiService.currentUser; 101 101 + if (currentUser == null || currentUser.did.isEmpty) { 102 102 + setState(() { 103 103 + _error = 'No current user found'; 104 104 + _isLoading = false; 105 105 + }); 106 106 + return; 107 107 + } 108 108 + 109 109 + final photos = await apiService.fetchActorPhotos(did: currentUser.did); 110 110 + 111 111 + if (mounted) { 112 112 + setState(() { 113 113 + _photos = photos; 114 114 + _photoGroups = _groupPhotosByDate(photos); 115 115 + _isLoading = false; 116 116 + }); 117 117 + 118 118 + // Force update scroll indicator after layout is complete 119 119 + WidgetsBinding.instance.addPostFrameCallback((_) { 120 120 + if (_scrollController.hasClients && mounted) { 121 121 + setState(() { 122 122 + _scrollPosition = _scrollController.offset; 123 123 + }); 124 124 + } 125 125 + }); 126 126 + } 127 127 + } catch (e) { 128 128 + if (mounted) { 129 129 + setState(() { 130 130 + _error = 'Failed to load photos: $e'; 131 131 + _isLoading = false; 132 132 + }); 133 133 + } 134 134 + } 135 135 + } 136 136 + 137 137 + List<PhotoGroup> _groupPhotosByDate(List<GalleryPhoto> photos) { 138 138 + final now = DateTime.now(); 139 139 + final today = DateTime(now.year, now.month, now.day); 140 140 + final yesterday = today.subtract(const Duration(days: 1)); 141 141 + 142 142 + final Map<String, List<GalleryPhoto>> groupedPhotos = {}; 143 143 + final List<GalleryPhoto> noExifPhotos = []; 144 144 + 145 145 + for (final photo in photos) { 146 146 + DateTime? photoDate; 147 147 + // Try to parse the dateTimeOriginal from EXIF record data 148 148 + if (photo.exif?.record?['dateTimeOriginal'] != null) { 149 149 + try { 150 150 + final dateTimeOriginal = photo.exif!.record!['dateTimeOriginal'] as String; 151 151 + photoDate = DateTime.parse(dateTimeOriginal); 152 152 + } catch (e) { 153 153 + // If parsing fails, add to no EXIF group 154 154 + noExifPhotos.add(photo); 155 155 + continue; 156 156 + } 157 157 + } else { 158 158 + noExifPhotos.add(photo); 159 159 + continue; 160 160 + } 161 161 + 162 162 + final photoDay = DateTime(photoDate.year, photoDate.month, photoDate.day); 163 163 + String groupKey; 164 164 + 165 165 + if (photoDay.isAtSameMomentAs(today)) { 166 166 + groupKey = 'Today'; 167 167 + } else if (photoDay.isAtSameMomentAs(yesterday)) { 168 168 + groupKey = 'Yesterday'; 169 169 + } else { 170 170 + final daysDifference = today.difference(photoDay).inDays; 171 171 + 172 172 + if (daysDifference <= 30) { 173 173 + // Group by week for last 30 days 174 174 + final weekStart = photoDay.subtract(Duration(days: photoDay.weekday - 1)); 175 175 + groupKey = 'Week of ${_formatDate(weekStart)}'; 176 176 + } else { 177 177 + // Group by month for older photos 178 178 + groupKey = '${_getMonthName(photoDate.month)} ${photoDate.year}'; 179 179 + } 180 180 + } 181 181 + 182 182 + groupedPhotos.putIfAbsent(groupKey, () => []).add(photo); 183 183 + } 184 184 + 185 185 + final List<PhotoGroup> groups = []; 186 186 + 187 187 + // Sort and create PhotoGroup objects 188 188 + final sortedEntries = groupedPhotos.entries.toList() 189 189 + ..sort((a, b) { 190 190 + final aDate = _getGroupSortDate(a.key, a.value); 191 191 + final bDate = _getGroupSortDate(b.key, b.value); 192 192 + return bDate.compareTo(aDate); // Most recent first 193 193 + }); 194 194 + 195 195 + for (final entry in sortedEntries) { 196 196 + final sortedPhotos = entry.value 197 197 + ..sort((a, b) { 198 198 + final aDate = _getPhotoDate(a); 199 199 + final bDate = _getPhotoDate(b); 200 200 + return bDate.compareTo(aDate); // Most recent first within group 201 201 + }); 202 202 + 203 203 + groups.add( 204 204 + PhotoGroup( 205 205 + title: entry.key, 206 206 + photos: sortedPhotos, 207 207 + sortDate: _getGroupSortDate(entry.key, entry.value), 208 208 + ), 209 209 + ); 210 210 + } 211 211 + 212 212 + // Add photos without EXIF data at the end 213 213 + if (noExifPhotos.isNotEmpty) { 214 214 + groups.add( 215 215 + PhotoGroup( 216 216 + title: 'Photos without date info', 217 217 + photos: noExifPhotos, 218 218 + sortDate: DateTime(1970), // Very old date to sort at bottom 219 219 + ), 220 220 + ); 221 221 + } 222 222 + 223 223 + return groups; 224 224 + } 225 225 + 226 226 + DateTime _getGroupSortDate(String groupKey, List<GalleryPhoto> photos) { 227 227 + if (groupKey == 'Today') return DateTime.now(); 228 228 + if (groupKey == 'Yesterday') return DateTime.now().subtract(const Duration(days: 1)); 229 229 + 230 230 + // For other groups, use the most recent photo date in the group 231 231 + DateTime? latestDate; 232 232 + for (final photo in photos) { 233 233 + final photoDate = _getPhotoDate(photo); 234 234 + if (latestDate == null || photoDate.isAfter(latestDate)) { 235 235 + latestDate = photoDate; 236 236 + } 237 237 + } 238 238 + return latestDate ?? DateTime(1970); 239 239 + } 240 240 + 241 241 + DateTime _getPhotoDate(GalleryPhoto photo) { 242 242 + if (photo.exif?.record?['dateTimeOriginal'] != null) { 243 243 + try { 244 244 + final dateTimeOriginal = photo.exif!.record!['dateTimeOriginal'] as String; 245 245 + return DateTime.parse(dateTimeOriginal); 246 246 + } catch (e) { 247 247 + // Fall back to a very old date if parsing fails 248 248 + return DateTime(1970); 249 249 + } 250 250 + } 251 251 + return DateTime(1970); 252 252 + } 253 253 + 254 254 + String _formatDate(DateTime date) { 255 255 + const months = [ 256 256 + 'Jan', 257 257 + 'Feb', 258 258 + 'Mar', 259 259 + 'Apr', 260 260 + 'May', 261 261 + 'Jun', 262 262 + 'Jul', 263 263 + 'Aug', 264 264 + 'Sep', 265 265 + 'Oct', 266 266 + 'Nov', 267 267 + 'Dec', 268 268 + ]; 269 269 + return '${months[date.month - 1]} ${date.day}'; 270 270 + } 271 271 + 272 272 + String _getMonthName(int month) { 273 273 + const months = [ 274 274 + 'January', 275 275 + 'February', 276 276 + 'March', 277 277 + 'April', 278 278 + 'May', 279 279 + 'June', 280 280 + 'July', 281 281 + 'August', 282 282 + 'September', 283 283 + 'October', 284 284 + 'November', 285 285 + 'December', 286 286 + ]; 287 287 + return months[month - 1]; 288 288 + } 289 289 + 290 290 + Future<void> _onRefresh() async { 291 291 + await _loadPhotos(); 292 292 + } 293 293 + 294 294 + void _showPhotoDetail(GalleryPhoto photo) { 295 295 + // Create a flattened list of photos in the same order they appear on the page 296 296 + final List<GalleryPhoto> orderedPhotos = []; 297 297 + for (final group in _photoGroups) { 298 298 + orderedPhotos.addAll(group.photos); 299 299 + } 300 300 + 301 301 + // Find the index of the photo in the ordered list 302 302 + final photoIndex = orderedPhotos.indexOf(photo); 303 303 + if (photoIndex == -1) return; // Photo not found, shouldn't happen 304 304 + 305 305 + Navigator.of(context).push( 306 306 + PageRouteBuilder( 307 307 + pageBuilder: (context, animation, secondaryAnimation) => GalleryPhotoView( 308 308 + photos: orderedPhotos, 309 309 + initialIndex: photoIndex, 310 310 + showAddCommentButton: false, 311 311 + onClose: () => Navigator.of(context).pop(), 312 312 + ), 313 313 + transitionDuration: const Duration(milliseconds: 200), 314 314 + reverseTransitionDuration: const Duration(milliseconds: 200), 315 315 + transitionsBuilder: (context, animation, secondaryAnimation, child) { 316 316 + return FadeTransition(opacity: animation, child: child); 317 317 + }, 318 318 + ), 319 319 + ); 320 320 + } 321 321 + 322 322 + @override 323 323 + Widget build(BuildContext context) { 324 324 + final theme = Theme.of(context); 325 325 + 326 326 + return Scaffold( 327 327 + backgroundColor: theme.scaffoldBackgroundColor, 328 328 + appBar: AppBar( 329 329 + title: const Text('Photo Library'), 330 330 + backgroundColor: theme.appBarTheme.backgroundColor, 331 331 + surfaceTintColor: theme.appBarTheme.backgroundColor, 332 332 + elevation: 0, 333 333 + ), 334 334 + body: RefreshIndicator(onRefresh: _onRefresh, child: _buildBodyWithScrollbar(theme)), 335 335 + ); 336 336 + } 337 337 + 338 338 + Widget _buildBodyWithScrollbar(ThemeData theme) { 339 339 + return Stack( 340 340 + children: [ 341 341 + Padding( 342 342 + padding: const EdgeInsets.only(right: 30), // Make room for scroll indicator 343 343 + child: _buildBody(theme), 344 344 + ), 345 345 + if (!_isLoading && _error == null && _photos.isNotEmpty) _buildScrollIndicator(theme), 346 346 + ], 347 347 + ); 348 348 + } 349 349 + 350 350 + Widget _buildScrollIndicator(ThemeData theme) { 351 351 + return Positioned( 352 352 + right: 4, 353 353 + top: 0, 354 354 + bottom: 0, 355 355 + child: GestureDetector( 356 356 + onPanUpdate: (details) { 357 357 + if (_scrollController.hasClients) { 358 358 + final RenderBox renderBox = context.findRenderObject() as RenderBox; 359 359 + final localPosition = renderBox.globalToLocal(details.globalPosition); 360 360 + final screenHeight = renderBox.size.height; 361 361 + final maxScrollExtent = _scrollController.position.maxScrollExtent; 362 362 + final relativePosition = (localPosition.dy / screenHeight).clamp(0.0, 1.0); 363 363 + final newPosition = relativePosition * maxScrollExtent; 364 364 + _scrollController.jumpTo(newPosition.clamp(0.0, maxScrollExtent)); 365 365 + } 366 366 + }, 367 367 + onTapDown: (details) { 368 368 + if (_scrollController.hasClients) { 369 369 + final RenderBox renderBox = context.findRenderObject() as RenderBox; 370 370 + final localPosition = renderBox.globalToLocal(details.globalPosition); 371 371 + final screenHeight = renderBox.size.height; 372 372 + final maxScrollExtent = _scrollController.position.maxScrollExtent; 373 373 + final relativePosition = (localPosition.dy / screenHeight).clamp(0.0, 1.0); 374 374 + final newPosition = relativePosition * maxScrollExtent; 375 375 + _scrollController.animateTo( 376 376 + newPosition.clamp(0.0, maxScrollExtent), 377 377 + duration: const Duration(milliseconds: 200), 378 378 + curve: Curves.easeInOut, 379 379 + ); 380 380 + } 381 381 + }, 382 382 + child: Container( 383 383 + width: 24, 384 384 + decoration: BoxDecoration( 385 385 + color: theme.scaffoldBackgroundColor.withValues(alpha: 0.8), 386 386 + borderRadius: BorderRadius.circular(12), 387 387 + ), 388 388 + child: CustomPaint( 389 389 + painter: ScrollIndicatorPainter( 390 390 + scrollPosition: _scrollPosition, 391 391 + maxScrollExtent: _scrollController.hasClients 392 392 + ? _scrollController.position.maxScrollExtent 393 393 + : 0, 394 394 + viewportHeight: _scrollController.hasClients 395 395 + ? _scrollController.position.viewportDimension 396 396 + : 0, 397 397 + color: theme.colorScheme.onSurface.withValues(alpha: 0.4), 398 398 + activeColor: theme.colorScheme.primary, 399 399 + currentGroupIndex: _getCurrentGroupIndex(), 400 400 + totalGroups: _photoGroups.length, 401 401 + ), 402 402 + ), 403 403 + ), 404 404 + ), 405 405 + ); 406 406 + } 407 407 + 408 408 + Widget _buildBody(ThemeData theme) { 409 409 + if (_isLoading) { 410 410 + return const Center(child: CircularProgressIndicator()); 411 411 + } 412 412 + 413 413 + if (_error != null) { 414 414 + return Center( 415 415 + child: Column( 416 416 + mainAxisAlignment: MainAxisAlignment.center, 417 417 + children: [ 418 418 + Icon(AppIcons.brokenImage, size: 64, color: theme.hintColor), 419 419 + const SizedBox(height: 16), 420 420 + Text( 421 421 + _error!, 422 422 + style: theme.textTheme.bodyLarge?.copyWith(color: theme.hintColor), 423 423 + textAlign: TextAlign.center, 424 424 + ), 425 425 + const SizedBox(height: 16), 426 426 + ElevatedButton(onPressed: _loadPhotos, child: const Text('Retry')), 427 427 + ], 428 428 + ), 429 429 + ); 430 430 + } 431 431 + 432 432 + if (_photos.isEmpty) { 433 433 + return Center( 434 434 + child: Column( 435 435 + mainAxisAlignment: MainAxisAlignment.center, 436 436 + children: [ 437 437 + Icon(AppIcons.photoLibrary, size: 64, color: theme.hintColor), 438 438 + const SizedBox(height: 16), 439 439 + Text( 440 440 + 'No photos yet', 441 441 + style: theme.textTheme.headlineSmall?.copyWith(color: theme.hintColor), 442 442 + ), 443 443 + const SizedBox(height: 8), 444 444 + Text( 445 445 + 'Upload some photos to see them here', 446 446 + style: theme.textTheme.bodyLarge?.copyWith(color: theme.hintColor), 447 447 + textAlign: TextAlign.center, 448 448 + ), 449 449 + ], 450 450 + ), 451 451 + ); 452 452 + } 453 453 + 454 454 + return ListView.builder( 455 455 + controller: _scrollController, 456 456 + padding: const EdgeInsets.all(16), 457 457 + itemCount: _photoGroups.length, 458 458 + itemBuilder: (context, index) { 459 459 + final group = _photoGroups[index]; 460 460 + return _buildPhotoGroup(group, theme, index); 461 461 + }, 462 462 + ); 463 463 + } 464 464 + 465 465 + Widget _buildPhotoGroup(PhotoGroup group, ThemeData theme, int index) { 466 466 + return Column( 467 467 + crossAxisAlignment: CrossAxisAlignment.start, 468 468 + children: [ 469 469 + Padding( 470 470 + padding: EdgeInsets.only(bottom: 12, top: index == 0 ? 0 : 24), 471 471 + child: Text( 472 472 + group.title, 473 473 + style: theme.textTheme.headlineSmall?.copyWith( 474 474 + fontWeight: FontWeight.bold, 475 475 + color: theme.colorScheme.onSurface, 476 476 + ), 477 477 + ), 478 478 + ), 479 479 + _buildPhotoGrid(group.photos, theme), 480 480 + ], 481 481 + ); 482 482 + } 483 483 + 484 484 + Widget _buildPhotoGrid(List<GalleryPhoto> photos, ThemeData theme) { 485 485 + final crossAxisCount = photos.length == 1 ? 1 : (photos.length == 2 ? 2 : 3); 486 486 + final aspectRatio = photos.length <= 2 ? 1.5 : 1.0; 487 487 + 488 488 + return GridView.builder( 489 489 + shrinkWrap: true, 490 490 + physics: const NeverScrollableScrollPhysics(), 491 491 + gridDelegate: SliverGridDelegateWithFixedCrossAxisCount( 492 492 + crossAxisCount: crossAxisCount, 493 493 + crossAxisSpacing: 4, 494 494 + mainAxisSpacing: 4, 495 495 + childAspectRatio: aspectRatio, 496 496 + ), 497 497 + itemCount: photos.length, 498 498 + itemBuilder: (context, index) { 499 499 + final photo = photos[index]; 500 500 + return _buildPhotoTile(photo, theme); 501 501 + }, 502 502 + ); 503 503 + } 504 504 + 505 505 + Widget _buildPhotoTile(GalleryPhoto photo, ThemeData theme) { 506 506 + return GestureDetector( 507 507 + onTap: () => _showPhotoDetail(photo), 508 508 + child: Hero( 509 509 + tag: 'photo-${photo.uri}', 510 510 + child: Container( 511 511 + decoration: BoxDecoration(borderRadius: BorderRadius.circular(8), color: theme.cardColor), 512 512 + clipBehavior: Clip.antiAlias, 513 513 + child: AppImage( 514 514 + url: photo.thumb ?? photo.fullsize, 515 515 + fit: BoxFit.cover, 516 516 + width: double.infinity, 517 517 + height: double.infinity, 518 518 + placeholder: Container( 519 519 + color: theme.hintColor.withValues(alpha: 0.1), 520 520 + child: Icon(AppIcons.photo, color: theme.hintColor, size: 32), 521 521 + ), 522 522 + errorWidget: Container( 523 523 + color: theme.hintColor.withValues(alpha: 0.1), 524 524 + child: Icon(AppIcons.brokenImage, color: theme.hintColor, size: 32), 525 525 + ), 526 526 + ), 527 527 + ), 528 528 + ), 529 529 + ); 530 530 + } 531 531 + } 532 532 + 533 533 + class ScrollIndicatorPainter extends CustomPainter { 534 534 + final double scrollPosition; 535 535 + final double maxScrollExtent; 536 536 + final double viewportHeight; 537 537 + final Color color; 538 538 + final Color activeColor; 539 539 + final int currentGroupIndex; 540 540 + final int totalGroups; 541 541 + 542 542 + ScrollIndicatorPainter({ 543 543 + required this.scrollPosition, 544 544 + required this.maxScrollExtent, 545 545 + required this.viewportHeight, 546 546 + required this.color, 547 547 + required this.activeColor, 548 548 + required this.currentGroupIndex, 549 549 + required this.totalGroups, 550 550 + }); 551 551 + 552 552 + @override 553 553 + void paint(Canvas canvas, Size size) { 554 554 + const dashCount = 60; // Number of dashes to show (doubled from 30) 555 555 + const dashHeight = 2.0; // Height when vertical (now width) 556 556 + const dashWidth = 12.0; // Width when vertical (now height) 557 557 + 558 558 + // Calculate spacing to fill the full height 559 559 + final availableHeight = size.height; 560 560 + final totalDashHeight = dashCount * dashHeight; 561 561 + final totalSpacing = availableHeight - totalDashHeight; 562 562 + final dashSpacing = totalSpacing / (dashCount - 1); 563 563 + 564 564 + // Calculate which dash should be active based on current group and total groups 565 565 + int activeDashIndex; 566 566 + if (totalGroups > 0) { 567 567 + // Map current group to dash index (more accurate than scroll position) 568 568 + final groupProgress = currentGroupIndex / (totalGroups - 1).clamp(1, totalGroups); 569 569 + activeDashIndex = (groupProgress * (dashCount - 1)).round().clamp(0, dashCount - 1); 570 570 + } else { 571 571 + // Fallback to scroll position if no groups 572 572 + final scrollProgress = maxScrollExtent > 0 573 573 + ? (scrollPosition / maxScrollExtent).clamp(0.0, 1.0) 574 574 + : 0.0; 575 575 + activeDashIndex = (scrollProgress * (dashCount - 1)).round(); 576 576 + } 577 577 + 578 578 + for (int i = 0; i < dashCount; i++) { 579 579 + final y = i * (dashHeight + dashSpacing); 580 580 + final isActive = i == activeDashIndex; 581 581 + 582 582 + final paint = Paint() 583 583 + ..color = isActive ? activeColor : color 584 584 + ..style = PaintingStyle.fill; 585 585 + 586 586 + // Create vertical dashes (rotated 90 degrees) 587 587 + final rect = Rect.fromLTWH((size.width - dashWidth) / 2, y, dashWidth, dashHeight); 588 588 + 589 589 + canvas.drawRRect(RRect.fromRectAndRadius(rect, const Radius.circular(1)), paint); 590 590 + } 591 591 + } 592 592 + 593 593 + @override 594 594 + bool shouldRepaint(ScrollIndicatorPainter oldDelegate) { 595 595 + return scrollPosition != oldDelegate.scrollPosition || 596 596 + maxScrollExtent != oldDelegate.maxScrollExtent || 597 597 + viewportHeight != oldDelegate.viewportHeight || 598 598 + currentGroupIndex != oldDelegate.currentGroupIndex || 599 599 + totalGroups != oldDelegate.totalGroups; 600 600 + } 601 601 + }

+4 -2

lib/screens/profile_page.dart

··· 47 47 if (!mounted) return; 48 48 if (success) { 49 49 Navigator.of(context).pop(); 50 50 - if (mounted) setState(() {}); // Force widget rebuild after modal closes 50 50 + if (mounted) { 51 51 + setState(() {}); // Force widget rebuild after modal closes 52 52 + } 51 53 } else { 52 54 if (!mounted) return; 53 55 ScaffoldMessenger.of( ··· 194 196 onPressed: () async { 195 197 await ref 196 198 .read(profileNotifierProvider(profile.did).notifier) 197 197 - .toggleFollow(apiService.currentUser?.did); 199 199 + .toggleFollow(profile.did); 198 200 }, 199 201 label: (profile.viewer?.following?.isNotEmpty == true) 200 202 ? 'Following'

+310

lib/utils/facet_utils.dart

··· 1 1 + import 'package:flutter/gestures.dart'; 2 2 + import 'package:flutter/material.dart'; 3 3 + 4 4 + class FacetRange { 5 5 + final int start; 6 6 + final int end; 7 7 + final String? type; 8 8 + final Map<String, dynamic> data; 9 9 + 10 10 + FacetRange({required this.start, required this.end, required this.type, required this.data}); 11 11 + } 12 12 + 13 13 + class ProcessedSpan { 14 14 + final int start; 15 15 + final int end; 16 16 + final TextSpan span; 17 17 + 18 18 + ProcessedSpan({required this.start, required this.end, required this.span}); 19 19 + } 20 20 + 21 21 + class FacetUtils { 22 22 + /// Processes facets and returns a list of TextSpans with proper highlighting 23 23 + static List<TextSpan> processFacets({ 24 24 + required String text, 25 25 + required List<Map<String, dynamic>>? facets, 26 26 + required TextStyle? defaultStyle, 27 27 + required TextStyle? linkStyle, 28 28 + void Function(String did)? onMentionTap, 29 29 + void Function(String url)? onLinkTap, 30 30 + void Function(String tag)? onTagTap, 31 31 + }) { 32 32 + if (facets == null || facets.isEmpty) { 33 33 + return [TextSpan(text: text, style: defaultStyle)]; 34 34 + } 35 35 + 36 36 + // Build a list of all ranges (start, end, type, data) 37 37 + final List<FacetRange> ranges = facets.map((facet) { 38 38 + final feature = facet['features']?[0] ?? {}; 39 39 + final type = feature['\$type'] ?? feature['type']; 40 40 + return FacetRange( 41 41 + start: facet['index']?['byteStart'] ?? facet['byteStart'] ?? 0, 42 42 + end: facet['index']?['byteEnd'] ?? facet['byteEnd'] ?? 0, 43 43 + type: type, 44 44 + data: feature, 45 45 + ); 46 46 + }).toList(); 47 47 + 48 48 + // Sort ranges by the length of their display text (longest first) to avoid overlap issues 49 49 + ranges.sort((a, b) { 50 50 + int aLength = a.end - a.start; 51 51 + int bLength = b.end - b.start; 52 52 + 53 53 + // For links, use the length of the text that will actually be found 54 54 + if (a.type?.contains('link') == true && a.data['uri'] != null) { 55 55 + final uri = a.data['uri'] as String; 56 56 + final possibleTexts = [_extractDisplayTextFromUri(uri), _extractDomainOnly(uri), uri]; 57 57 + // Use the longest text that exists in the original text 58 58 + for (final testText in possibleTexts) { 59 59 + if (text.contains(testText)) { 60 60 + aLength = testText.length; 61 61 + break; 62 62 + } 63 63 + } 64 64 + } 65 65 + 66 66 + if (b.type?.contains('link') == true && b.data['uri'] != null) { 67 67 + final uri = b.data['uri'] as String; 68 68 + final possibleTexts = [_extractDisplayTextFromUri(uri), _extractDomainOnly(uri), uri]; 69 69 + // Use the longest text that exists in the original text 70 70 + for (final testText in possibleTexts) { 71 71 + if (text.contains(testText)) { 72 72 + bLength = testText.length; 73 73 + break; 74 74 + } 75 75 + } 76 76 + } 77 77 + 78 78 + // Sort by length descending, then by start position ascending 79 79 + final lengthComparison = bLength.compareTo(aLength); 80 80 + return lengthComparison != 0 ? lengthComparison : a.start.compareTo(b.start); 81 81 + }); 82 82 + 83 83 + final List<ProcessedSpan> processedSpans = <ProcessedSpan>[]; 84 84 + final Set<int> usedPositions = <int>{}; // Track which character positions are already used 85 85 + 86 86 + for (final range in ranges) { 87 87 + // For links, we need to find the actual text in the original text 88 88 + // since the facet positions might be based on the full URL with protocol 89 89 + String? actualContent; 90 90 + int actualStart = range.start; 91 91 + int actualEnd = range.end; 92 92 + 93 93 + if (range.type?.contains('link') == true && range.data['uri'] != null) { 94 94 + final uri = range.data['uri'] as String; 95 95 + 96 96 + // First, try to use the exact facet positions if they seem valid 97 97 + if (range.start >= 0 && range.end <= text.length && range.start < range.end) { 98 98 + final facetText = text.substring(range.start, range.end); 99 99 + 100 100 + // Check if the facet text matches any of our expected URL formats 101 101 + final possibleTexts = [ 102 102 + _extractDisplayTextFromUri(uri), // Full URL with protocol 103 103 + _extractDomainOnly(uri), // Just the domain 104 104 + uri, // Original URI as-is 105 105 + ]; 106 106 + 107 107 + bool facetTextMatches = possibleTexts.any( 108 108 + (possible) => 109 109 + facetText == possible || 110 110 + facetText.contains(possible) || 111 111 + possible.contains(facetText), 112 112 + ); 113 113 + 114 114 + if (facetTextMatches) { 115 115 + // Check if this range overlaps with used positions 116 116 + bool overlaps = false; 117 117 + for (int i = range.start; i < range.end; i++) { 118 118 + if (usedPositions.contains(i)) { 119 119 + overlaps = true; 120 120 + break; 121 121 + } 122 122 + } 123 123 + 124 124 + if (!overlaps) { 125 125 + actualStart = range.start; 126 126 + actualEnd = range.end; 127 127 + actualContent = 128 128 + facetText; // Use exactly what's in the original text at facet position 129 129 + 130 130 + // Mark these positions as used 131 131 + for (int i = actualStart; i < actualEnd; i++) { 132 132 + usedPositions.add(i); 133 133 + } 134 134 + } 135 135 + } 136 136 + } 137 137 + 138 138 + // If facet positions didn't work, fall back to searching 139 139 + if (actualContent == null) { 140 140 + final possibleTexts = [ 141 141 + _extractDisplayTextFromUri(uri), // Full URL with protocol 142 142 + _extractDomainOnly(uri), // Just the domain 143 143 + uri, // Original URI as-is 144 144 + ]; 145 145 + 146 146 + int searchIndex = 0; 147 147 + bool foundValidMatch = false; 148 148 + 149 149 + // Try each possible text representation 150 150 + for (final searchText in possibleTexts) { 151 151 + searchIndex = 0; 152 152 + while (!foundValidMatch) { 153 153 + final globalIndex = text.indexOf(searchText, searchIndex); 154 154 + if (globalIndex == -1) break; 155 155 + 156 156 + // Check if this range overlaps with any used positions 157 157 + bool overlaps = false; 158 158 + for (int i = globalIndex; i < globalIndex + searchText.length; i++) { 159 159 + if (usedPositions.contains(i)) { 160 160 + overlaps = true; 161 161 + break; 162 162 + } 163 163 + } 164 164 + 165 165 + if (!overlaps) { 166 166 + actualStart = globalIndex; 167 167 + actualEnd = globalIndex + searchText.length; 168 168 + actualContent = searchText; // Use exactly what we found in the text 169 169 + foundValidMatch = true; 170 170 + 171 171 + // Mark these positions as used 172 172 + for (int i = actualStart; i < actualEnd; i++) { 173 173 + usedPositions.add(i); 174 174 + } 175 175 + break; 176 176 + } else { 177 177 + searchIndex = globalIndex + 1; 178 178 + } 179 179 + } 180 180 + if (foundValidMatch) break; 181 181 + } 182 182 + } 183 183 + } 184 184 + 185 185 + // Handle other facet types that might have similar issues 186 186 + if (actualContent == null) { 187 187 + // Verify the range is within bounds 188 188 + if (range.start >= 0 && range.end <= text.length && range.start < range.end) { 189 189 + actualContent = text.substring(range.start, range.end); 190 190 + actualStart = range.start; 191 191 + actualEnd = range.end; 192 192 + 193 193 + // Check if this overlaps with used positions 194 194 + bool overlaps = false; 195 195 + for (int i = actualStart; i < actualEnd; i++) { 196 196 + if (usedPositions.contains(i)) { 197 197 + overlaps = true; 198 198 + break; 199 199 + } 200 200 + } 201 201 + 202 202 + if (!overlaps) { 203 203 + // Mark these positions as used 204 204 + for (int i = actualStart; i < actualEnd; i++) { 205 205 + usedPositions.add(i); 206 206 + } 207 207 + } else { 208 208 + // Skip overlapping ranges 209 209 + actualContent = null; 210 210 + } 211 211 + } else { 212 212 + // Skip invalid ranges 213 213 + continue; 214 214 + } 215 215 + } 216 216 + 217 217 + if (actualContent != null) { 218 218 + TextSpan span; 219 219 + if (range.type?.contains('mention') == true && range.data['did'] != null) { 220 220 + span = TextSpan( 221 221 + text: actualContent, 222 222 + style: linkStyle, 223 223 + recognizer: TapGestureRecognizer() 224 224 + ..onTap = onMentionTap != null ? () => onMentionTap(range.data['did']) : null, 225 225 + ); 226 226 + } else if (range.type?.contains('link') == true && range.data['uri'] != null) { 227 227 + span = TextSpan( 228 228 + text: actualContent, 229 229 + style: linkStyle, 230 230 + recognizer: TapGestureRecognizer() 231 231 + ..onTap = onLinkTap != null ? () => onLinkTap(range.data['uri']) : null, 232 232 + ); 233 233 + } else if (range.type?.contains('tag') == true && range.data['tag'] != null) { 234 234 + span = TextSpan( 235 235 + text: '#${range.data['tag']}', 236 236 + style: linkStyle, 237 237 + recognizer: TapGestureRecognizer() 238 238 + ..onTap = onTagTap != null ? () => onTagTap(range.data['tag']) : null, 239 239 + ); 240 240 + } else { 241 241 + span = TextSpan(text: actualContent, style: defaultStyle); 242 242 + } 243 243 + 244 244 + processedSpans.add(ProcessedSpan(start: actualStart, end: actualEnd, span: span)); 245 245 + } 246 246 + } 247 247 + 248 248 + // Sort processed spans by position and build final spans list 249 249 + processedSpans.sort((a, b) => a.start.compareTo(b.start)); 250 250 + int pos = 0; 251 251 + final spans = <TextSpan>[]; 252 252 + 253 253 + for (final processedSpan in processedSpans) { 254 254 + if (processedSpan.start > pos) { 255 255 + spans.add(TextSpan(text: text.substring(pos, processedSpan.start), style: defaultStyle)); 256 256 + } 257 257 + spans.add(processedSpan.span); 258 258 + pos = processedSpan.end; 259 259 + } 260 260 + 261 261 + if (pos < text.length) { 262 262 + spans.add(TextSpan(text: text.substring(pos), style: defaultStyle)); 263 263 + } 264 264 + 265 265 + return spans; 266 266 + } 267 267 + 268 268 + /// Extracts the display text from a URI (keeps protocol and domain, removes path) 269 269 + static String _extractDisplayTextFromUri(String uri) { 270 270 + // Find the first slash after the protocol to remove the path 271 271 + String protocolAndDomain = uri; 272 272 + if (uri.startsWith('https://')) { 273 273 + final pathIndex = uri.indexOf('/', 8); // Start search after "https://" 274 274 + if (pathIndex != -1) { 275 275 + protocolAndDomain = uri.substring(0, pathIndex); 276 276 + } 277 277 + } else if (uri.startsWith('http://')) { 278 278 + final pathIndex = uri.indexOf('/', 7); // Start search after "http://" 279 279 + if (pathIndex != -1) { 280 280 + protocolAndDomain = uri.substring(0, pathIndex); 281 281 + } 282 282 + } else { 283 283 + // For URIs without protocol, just remove the path 284 284 + final slashIndex = uri.indexOf('/'); 285 285 + if (slashIndex != -1) { 286 286 + protocolAndDomain = uri.substring(0, slashIndex); 287 287 + } 288 288 + } 289 289 + 290 290 + return protocolAndDomain; 291 291 + } 292 292 + 293 293 + /// Extracts just the domain part from a URI (removes protocol and path) 294 294 + static String _extractDomainOnly(String uri) { 295 295 + String domain = uri; 296 296 + if (uri.startsWith('https://')) { 297 297 + domain = uri.substring(8); 298 298 + } else if (uri.startsWith('http://')) { 299 299 + domain = uri.substring(7); 300 300 + } 301 301 + 302 302 + // Remove path 303 303 + final slashIndex = domain.indexOf('/'); 304 304 + if (slashIndex != -1) { 305 305 + domain = domain.substring(0, slashIndex); 306 306 + } 307 307 + 308 308 + return domain; 309 309 + } 310 310 + }

+12 -14

lib/widgets/add_comment_sheet.dart

··· 5 5 import 'package:grain/app_icons.dart'; 6 6 import 'package:grain/widgets/app_image.dart'; 7 7 import 'package:grain/widgets/gallery_preview.dart'; 8 8 + import 'package:grain/widgets/faceted_text_field.dart'; 8 9 9 10 Future<void> showAddCommentSheet( 10 11 BuildContext context, { ··· 185 186 child: Column( 186 187 crossAxisAlignment: CrossAxisAlignment.start, 187 188 children: [ 188 188 - Row( 189 189 + Column( 190 190 + crossAxisAlignment: CrossAxisAlignment.start, 189 191 children: [ 190 192 Text( 191 193 creator is Map ··· 199 201 ? (creator['handle'] ?? '') 200 202 : (creator.handle ?? '')) 201 203 .isNotEmpty) ...[ 202 202 - const SizedBox(width: 8), 204 204 + const SizedBox(height: 1), 203 205 Text( 204 206 '@${creator is Map ? creator['handle'] : creator.handle}', 205 207 style: theme.textTheme.bodySmall?.copyWith( ··· 315 317 ), 316 318 // Text input 317 319 Expanded( 318 318 - child: TextField( 319 319 - controller: widget.controller, 320 320 - focusNode: _focusNode, 321 321 - maxLines: 6, 322 322 - minLines: 2, 323 323 - style: theme.textTheme.bodyMedium, 324 324 - decoration: InputDecoration( 320 320 + child: Padding( 321 321 + padding: const EdgeInsets.only(left: 10), 322 322 + child: FacetedTextField( 323 323 + controller: widget.controller, 324 324 + maxLines: 6, 325 325 + enabled: true, 326 326 + keyboardType: TextInputType.multiline, 325 327 hintText: 'Add a comment', 326 326 - hintStyle: theme.textTheme.bodyMedium?.copyWith(color: theme.hintColor), 327 327 - border: InputBorder.none, 328 328 - contentPadding: const EdgeInsets.symmetric(horizontal: 12, vertical: 12), 329 329 - isDense: true, 330 330 - filled: false, 328 328 + // The FacetedTextField handles its own style and padding internally 331 329 ), 332 330 ), 333 331 ),

+15

lib/widgets/app_drawer.dart

··· 2 2 import 'package:grain/api.dart'; 3 3 import 'package:grain/app_icons.dart'; 4 4 import 'package:grain/screens/log_page.dart'; 5 5 + import 'package:grain/screens/photo_library_page.dart'; 5 6 import 'package:grain/widgets/app_version_text.dart'; 6 7 7 8 class AppDrawer extends StatelessWidget { ··· 176 177 onTap: () { 177 178 Navigator.pop(context); 178 179 onProfile(); 180 180 + }, 181 181 + ), 182 182 + ListTile( 183 183 + leading: Icon( 184 184 + AppIcons.photoLibrary, 185 185 + size: 18, 186 186 + color: activeIndex == 4 ? theme.colorScheme.primary : theme.iconTheme.color, 187 187 + ), 188 188 + title: const Text('Photo Library'), 189 189 + onTap: () { 190 190 + Navigator.pop(context); 191 191 + Navigator.of( 192 192 + context, 193 193 + ).push(MaterialPageRoute(builder: (context) => const PhotoLibraryPage())); 179 194 }, 180 195 ), 181 196 ListTile(

+7 -4

lib/widgets/edit_profile_sheet.dart

··· 4 4 import 'package:flutter/material.dart'; 5 5 import 'package:flutter/services.dart'; 6 6 import 'package:grain/app_icons.dart'; 7 7 + import 'package:grain/widgets/faceted_text_field.dart'; 7 8 import 'package:grain/widgets/plain_text_field.dart'; 8 9 import 'package:image_picker/image_picker.dart'; 9 10 ··· 69 70 super.initState(); 70 71 _displayNameController = TextEditingController(text: widget.initialDisplayName ?? ''); 71 72 _descriptionController = TextEditingController(text: widget.initialDescription ?? ''); 72 72 - // No need to track changes 73 73 _displayNameController.addListener(_onInputChanged); 74 74 - _descriptionController.addListener(_onInputChanged); 74 74 + _descriptionController.addListener(_onDescriptionChanged); 75 75 + } 76 76 + 77 77 + void _onDescriptionChanged() { 78 78 + setState(() {}); // For character count 75 79 } 76 80 77 81 void _onInputChanged() { ··· 260 264 ), 261 265 ), 262 266 const SizedBox(height: 12), 263 263 - PlainTextField( 267 267 + FacetedTextField( 264 268 label: 'Description', 265 269 controller: _descriptionController, 266 270 maxLines: 6, ··· 286 290 ), 287 291 ), 288 292 ), 289 289 - const SizedBox(height: 24), 290 293 ], 291 294 ), 292 295 ),

+14 -63

lib/widgets/faceted_text.dart

··· 1 1 - import 'package:flutter/gestures.dart'; 2 1 import 'package:flutter/material.dart'; 2 2 + 3 3 + import '../utils/facet_utils.dart'; 3 4 4 5 class FacetedText extends StatelessWidget { 5 6 final String text; ··· 32 33 fontWeight: FontWeight.w600, 33 34 decoration: TextDecoration.underline, 34 35 ); 36 36 + 35 37 if (facets == null || facets!.isEmpty) { 36 38 return Text(text, style: defaultStyle); 37 39 } 38 38 - // Build a list of all ranges (start, end, type, data) 39 39 - final List<_FacetRange> ranges = facets!.map((facet) { 40 40 - final feature = facet['features']?[0] ?? {}; 41 41 - final type = feature['\$type'] ?? feature['type']; 42 42 - return _FacetRange( 43 43 - start: facet['index']?['byteStart'] ?? facet['byteStart'] ?? 0, 44 44 - end: facet['index']?['byteEnd'] ?? facet['byteEnd'] ?? 0, 45 45 - type: type, 46 46 - data: feature, 47 47 - ); 48 48 - }).toList(); 49 49 - ranges.sort((a, b) => a.start.compareTo(b.start)); 50 50 - int pos = 0; 51 51 - final spans = <TextSpan>[]; 52 52 - for (final range in ranges) { 53 53 - if (range.start > pos) { 54 54 - spans.add(TextSpan(text: text.substring(pos, range.start), style: defaultStyle)); 55 55 - } 56 56 - final content = text.substring(range.start, range.end); 57 57 - if (range.type?.contains('mention') == true && range.data['did'] != null) { 58 58 - spans.add( 59 59 - TextSpan( 60 60 - text: content, 61 61 - style: defaultLinkStyle, 62 62 - recognizer: TapGestureRecognizer() 63 63 - ..onTap = onMentionTap != null ? () => onMentionTap!(range.data['did']) : null, 64 64 - ), 65 65 - ); 66 66 - } else if (range.type?.contains('link') == true && range.data['uri'] != null) { 67 67 - spans.add( 68 68 - TextSpan( 69 69 - text: content, 70 70 - style: defaultLinkStyle, 71 71 - recognizer: TapGestureRecognizer() 72 72 - ..onTap = onLinkTap != null ? () => onLinkTap!(range.data['uri']) : null, 73 73 - ), 74 74 - ); 75 75 - } else if (range.type?.contains('tag') == true && range.data['tag'] != null) { 76 76 - spans.add( 77 77 - TextSpan( 78 78 - text: '#${range.data['tag']}', 79 79 - style: defaultLinkStyle, 80 80 - recognizer: TapGestureRecognizer() 81 81 - ..onTap = onTagTap != null ? () => onTagTap!(range.data['tag']) : null, 82 82 - ), 83 83 - ); 84 84 - } else { 85 85 - spans.add(TextSpan(text: content, style: defaultStyle)); 86 86 - } 87 87 - pos = range.end; 88 88 - } 89 89 - if (pos < text.length) { 90 90 - spans.add(TextSpan(text: text.substring(pos), style: defaultStyle)); 91 91 - } 40 40 + 41 41 + final spans = FacetUtils.processFacets( 42 42 + text: text, 43 43 + facets: facets, 44 44 + defaultStyle: defaultStyle, 45 45 + linkStyle: defaultLinkStyle, 46 46 + onMentionTap: onMentionTap, 47 47 + onLinkTap: onLinkTap, 48 48 + onTagTap: onTagTap, 49 49 + ); 50 50 + 92 51 return RichText(text: TextSpan(children: spans)); 93 52 } 94 53 } 95 95 - 96 96 - class _FacetRange { 97 97 - final int start; 98 98 - final int end; 99 99 - final String? type; 100 100 - final Map<String, dynamic> data; 101 101 - _FacetRange({required this.start, required this.end, required this.type, required this.data}); 102 102 - }

+473

lib/widgets/faceted_text_field.dart

··· 1 1 + import 'dart:async'; 2 2 + 3 3 + import 'package:bluesky_text/bluesky_text.dart'; 4 4 + import 'package:flutter/material.dart'; 5 5 + import 'package:flutter_riverpod/flutter_riverpod.dart'; 6 6 + 7 7 + import '../models/profile.dart'; 8 8 + import '../providers/actor_search_provider.dart'; 9 9 + import '../utils/facet_utils.dart'; 10 10 + 11 11 + class FacetedTextField extends ConsumerStatefulWidget { 12 12 + final String? label; 13 13 + final TextEditingController controller; 14 14 + final int maxLines; 15 15 + final bool enabled; 16 16 + final TextInputType? keyboardType; 17 17 + final String? hintText; 18 18 + final void Function(String)? onChanged; 19 19 + final Widget? prefixIcon; 20 20 + final Widget? suffixIcon; 21 21 + final List<Map<String, dynamic>>? facets; 22 22 + 23 23 + const FacetedTextField({ 24 24 + super.key, 25 25 + this.label, 26 26 + required this.controller, 27 27 + this.maxLines = 1, 28 28 + this.enabled = true, 29 29 + this.keyboardType, 30 30 + this.hintText, 31 31 + this.onChanged, 32 32 + this.prefixIcon, 33 33 + this.suffixIcon, 34 34 + this.facets, 35 35 + }); 36 36 + 37 37 + @override 38 38 + ConsumerState<FacetedTextField> createState() => _FacetedTextFieldState(); 39 39 + } 40 40 + 41 41 + class _FacetedTextFieldState extends ConsumerState<FacetedTextField> { 42 42 + // Track which handles have been inserted via overlay selection 43 43 + final Set<String> _insertedHandles = {}; 44 44 + OverlayEntry? _overlayEntry; 45 45 + final GlobalKey _fieldKey = GlobalKey(); 46 46 + List<Profile> _actorResults = []; 47 47 + Timer? _debounceTimer; 48 48 + 49 49 + @override 50 50 + void initState() { 51 51 + super.initState(); 52 52 + widget.controller.addListener(_onTextChanged); 53 53 + } 54 54 + 55 55 + @override 56 56 + void dispose() { 57 57 + widget.controller.removeListener(_onTextChanged); 58 58 + _debounceTimer?.cancel(); 59 59 + _removeOverlay(); 60 60 + super.dispose(); 61 61 + } 62 62 + 63 63 + void _onTextChanged() async { 64 64 + final text = widget.controller.text; 65 65 + final selection = widget.controller.selection; 66 66 + final cursorPos = selection.baseOffset; 67 67 + if (cursorPos < 0) { 68 68 + _removeOverlay(); 69 69 + return; 70 70 + } 71 71 + // If the last character typed is a space, always close overlay 72 72 + if (cursorPos > 0 && text[cursorPos - 1] == ' ') { 73 73 + _removeOverlay(); 74 74 + return; 75 75 + } 76 76 + // Find the @mention match that contains the cursor 77 77 + final regex = RegExp(r'@([\w.]+)'); 78 78 + final matches = regex.allMatches(text); 79 79 + String? query; 80 80 + for (final match in matches) { 81 81 + final start = match.start; 82 82 + final end = match.end; 83 83 + if (cursorPos > start && cursorPos <= end) { 84 84 + query = match.group(1); 85 85 + break; 86 86 + } 87 87 + } 88 88 + if (query != null && query.isNotEmpty) { 89 89 + _debounceTimer?.cancel(); 90 90 + _debounceTimer = Timer(const Duration(milliseconds: 500), () async { 91 91 + final results = await ref.read(actorSearchProvider.notifier).search(query!); 92 92 + if (mounted) { 93 93 + setState(() { 94 94 + _actorResults = results; 95 95 + }); 96 96 + _showOverlay(); 97 97 + } 98 98 + }); 99 99 + return; 100 100 + } 101 101 + _debounceTimer?.cancel(); 102 102 + _removeOverlay(); 103 103 + } 104 104 + 105 105 + void _showOverlay() { 106 106 + WidgetsBinding.instance.addPostFrameCallback((_) { 107 107 + _removeOverlay(); 108 108 + final overlay = Overlay.of(context); 109 109 + final caretOffset = _getCaretPosition(); 110 110 + if (caretOffset == null) return; 111 111 + 112 112 + // Show only the first 5 results, no scroll, use simple rows 113 113 + final double rowHeight = 44.0; 114 114 + final int maxItems = 5; 115 115 + final resultsToShow = _actorResults.take(maxItems).toList(); 116 116 + final double overlayHeight = resultsToShow.length * rowHeight; 117 117 + final double overlayWidth = 300.0; 118 118 + 119 119 + // Get screen size 120 120 + final mediaQuery = MediaQuery.of(context); 121 121 + final screenWidth = mediaQuery.size.width; 122 122 + 123 123 + // Default to left of caret, but if it would overflow, switch to right 124 124 + double left = caretOffset.dx; 125 125 + if (left + overlayWidth > screenWidth - 8) { 126 126 + // Try to align right edge of overlay with caret, but don't go off left edge 127 127 + left = (caretOffset.dx - overlayWidth).clamp(8.0, screenWidth - overlayWidth - 8.0); 128 128 + } 129 129 + 130 130 + _overlayEntry = OverlayEntry( 131 131 + builder: (context) => Positioned( 132 132 + left: left, 133 133 + top: caretOffset.dy, 134 134 + width: overlayWidth, 135 135 + height: overlayHeight, 136 136 + child: Material( 137 137 + elevation: 4, 138 138 + child: Column( 139 139 + mainAxisSize: MainAxisSize.min, 140 140 + children: resultsToShow.map((actor) { 141 141 + return Material( 142 142 + color: Colors.transparent, 143 143 + child: InkWell( 144 144 + onTap: () => _insertActor(actor.handle), 145 145 + child: Container( 146 146 + height: rowHeight, 147 147 + width: double.infinity, 148 148 + alignment: Alignment.centerLeft, 149 149 + padding: const EdgeInsets.symmetric(horizontal: 12.0), 150 150 + child: Row( 151 151 + children: [ 152 152 + if (actor.avatar != null && actor.avatar!.isNotEmpty) 153 153 + CircleAvatar(radius: 16, backgroundImage: NetworkImage(actor.avatar!)) 154 154 + else 155 155 + CircleAvatar(radius: 16, child: Icon(Icons.person, size: 16)), 156 156 + const SizedBox(width: 12), 157 157 + Expanded( 158 158 + child: Text( 159 159 + actor.displayName ?? actor.handle, 160 160 + style: Theme.of(context).textTheme.bodyMedium, 161 161 + overflow: TextOverflow.ellipsis, 162 162 + ), 163 163 + ), 164 164 + const SizedBox(width: 8), 165 165 + Text( 166 166 + '@${actor.handle}', 167 167 + style: Theme.of( 168 168 + context, 169 169 + ).textTheme.bodySmall?.copyWith(color: Colors.grey[600]), 170 170 + overflow: TextOverflow.ellipsis, 171 171 + ), 172 172 + ], 173 173 + ), 174 174 + ), 175 175 + ), 176 176 + ); 177 177 + }).toList(), 178 178 + ), 179 179 + ), 180 180 + ), 181 181 + ); 182 182 + overlay.insert(_overlayEntry!); 183 183 + }); 184 184 + } 185 185 + 186 186 + void _removeOverlay() { 187 187 + if (_overlayEntry != null) { 188 188 + _overlayEntry?.remove(); 189 189 + _overlayEntry = null; 190 190 + } 191 191 + } 192 192 + 193 193 + Offset? _getCaretPosition() { 194 194 + final renderBox = _fieldKey.currentContext?.findRenderObject() as RenderBox?; 195 195 + if (renderBox == null) return null; 196 196 + 197 197 + final controller = widget.controller; 198 198 + final selection = controller.selection; 199 199 + if (!selection.isValid) return null; 200 200 + 201 201 + // Get the text up to the caret 202 202 + final text = controller.text.substring(0, selection.baseOffset); 203 203 + final textStyle = 204 204 + Theme.of(context).textTheme.bodyMedium?.copyWith(fontSize: 15) ?? 205 205 + const TextStyle(fontSize: 15); 206 206 + final textPainter = TextPainter( 207 207 + text: TextSpan(text: text, style: textStyle), 208 208 + textDirection: TextDirection.ltr, 209 209 + maxLines: widget.maxLines, 210 210 + ); 211 211 + textPainter.layout(minWidth: 0, maxWidth: renderBox.size.width); 212 212 + 213 213 + final caretOffset = textPainter.getOffsetForCaret(TextPosition(offset: text.length), Rect.zero); 214 214 + 215 215 + // Convert caret offset to global coordinates 216 216 + final fieldOffset = renderBox.localToGlobal(Offset.zero); 217 217 + // Add vertical padding to position below the caret 218 218 + return fieldOffset + Offset(caretOffset.dx, caretOffset.dy + textPainter.preferredLineHeight); 219 219 + } 220 220 + 221 221 + void _insertActor(String actorName) { 222 222 + final text = widget.controller.text; 223 223 + final selection = widget.controller.selection; 224 224 + final cursorPos = selection.baseOffset; 225 225 + // Find the @mention match that contains the cursor (not just before it) 226 226 + final regex = RegExp(r'@([\w.]+)'); 227 227 + final matches = regex.allMatches(text); 228 228 + Match? matchToReplace; 229 229 + for (final match in matches) { 230 230 + if (cursorPos > match.start && cursorPos <= match.end) { 231 231 + matchToReplace = match; 232 232 + break; 233 233 + } 234 234 + } 235 235 + if (matchToReplace != null) { 236 236 + final start = matchToReplace.start; 237 237 + final end = matchToReplace.end; 238 238 + final newText = text.replaceRange(start, end, '@$actorName '); 239 239 + setState(() { 240 240 + _insertedHandles.add(actorName); 241 241 + }); 242 242 + widget.controller.value = TextEditingValue( 243 243 + text: newText, 244 244 + selection: TextSelection.collapsed(offset: start + actorName.length + 2), 245 245 + ); 246 246 + } 247 247 + _removeOverlay(); 248 248 + } 249 249 + 250 250 + @override 251 251 + Widget build(BuildContext context) { 252 252 + final theme = Theme.of(context); 253 253 + return Column( 254 254 + crossAxisAlignment: CrossAxisAlignment.start, 255 255 + children: [ 256 256 + if (widget.label != null && widget.label!.isNotEmpty) ...[ 257 257 + Text( 258 258 + widget.label!, 259 259 + style: theme.textTheme.bodyMedium?.copyWith( 260 260 + fontWeight: FontWeight.w500, 261 261 + color: theme.colorScheme.onSurface, 262 262 + ), 263 263 + ), 264 264 + const SizedBox(height: 6), 265 265 + ], 266 266 + Container( 267 267 + decoration: BoxDecoration( 268 268 + color: theme.brightness == Brightness.dark ? Colors.grey[850] : Colors.grey[300], 269 269 + borderRadius: BorderRadius.circular(8), 270 270 + ), 271 271 + child: Focus( 272 272 + child: Builder( 273 273 + builder: (context) { 274 274 + final isFocused = Focus.of(context).hasFocus; 275 275 + return Stack( 276 276 + children: [ 277 277 + _MentionHighlightTextField( 278 278 + key: _fieldKey, 279 279 + controller: widget.controller, 280 280 + maxLines: widget.maxLines, 281 281 + enabled: widget.enabled, 282 282 + keyboardType: widget.keyboardType, 283 283 + onChanged: widget.onChanged, 284 284 + hintText: widget.hintText, 285 285 + prefixIcon: widget.prefixIcon, 286 286 + suffixIcon: widget.suffixIcon, 287 287 + insertedHandles: _insertedHandles, 288 288 + facets: widget.facets, 289 289 + ), 290 290 + // Border overlay 291 291 + Positioned.fill( 292 292 + child: IgnorePointer( 293 293 + child: AnimatedContainer( 294 294 + duration: const Duration(milliseconds: 150), 295 295 + decoration: BoxDecoration( 296 296 + border: Border.all( 297 297 + color: isFocused ? theme.colorScheme.primary : theme.dividerColor, 298 298 + width: isFocused ? 2 : 0, 299 299 + ), 300 300 + borderRadius: BorderRadius.circular(8), 301 301 + ), 302 302 + ), 303 303 + ), 304 304 + ), 305 305 + ], 306 306 + ); 307 307 + }, 308 308 + ), 309 309 + ), 310 310 + ), 311 311 + ], 312 312 + ); 313 313 + } 314 314 + } 315 315 + 316 316 + class _MentionHighlightTextField extends StatefulWidget { 317 317 + final Set<String>? insertedHandles; 318 318 + final TextEditingController controller; 319 319 + final int maxLines; 320 320 + final bool enabled; 321 321 + final TextInputType? keyboardType; 322 322 + final String? hintText; 323 323 + final void Function(String)? onChanged; 324 324 + final Widget? prefixIcon; 325 325 + final Widget? suffixIcon; 326 326 + final List<Map<String, dynamic>>? facets; 327 327 + 328 328 + const _MentionHighlightTextField({ 329 329 + super.key, 330 330 + required this.controller, 331 331 + required this.maxLines, 332 332 + required this.enabled, 333 333 + this.keyboardType, 334 334 + this.hintText, 335 335 + this.onChanged, 336 336 + this.prefixIcon, 337 337 + this.suffixIcon, 338 338 + this.insertedHandles, 339 339 + this.facets, 340 340 + }); 341 341 + 342 342 + @override 343 343 + State<_MentionHighlightTextField> createState() => _MentionHighlightTextFieldState(); 344 344 + } 345 345 + 346 346 + class _MentionHighlightTextFieldState extends State<_MentionHighlightTextField> { 347 347 + final ScrollController _richTextScrollController = ScrollController(); 348 348 + final ScrollController _textFieldScrollController = ScrollController(); 349 349 + 350 350 + void _onMentionTap(String did) { 351 351 + // Show overlay for this mention (simulate as if user is typing @mention) 352 352 + final parent = context.findAncestorStateOfType<_FacetedTextFieldState>(); 353 353 + if (parent != null) { 354 354 + parent._showOverlay(); 355 355 + } 356 356 + } 357 357 + 358 358 + List<Map<String, dynamic>> _parsedFacets = []; 359 359 + Timer? _facetDebounce; 360 360 + 361 361 + @override 362 362 + void initState() { 363 363 + super.initState(); 364 364 + _parseFacets(); 365 365 + widget.controller.addListener(_parseFacets); 366 366 + 367 367 + // Sync scroll controllers 368 368 + _textFieldScrollController.addListener(() { 369 369 + if (_richTextScrollController.hasClients && _textFieldScrollController.hasClients) { 370 370 + _richTextScrollController.jumpTo(_textFieldScrollController.offset); 371 371 + } 372 372 + }); 373 373 + } 374 374 + 375 375 + @override 376 376 + void dispose() { 377 377 + widget.controller.removeListener(_parseFacets); 378 378 + _facetDebounce?.cancel(); 379 379 + _richTextScrollController.dispose(); 380 380 + _textFieldScrollController.dispose(); 381 381 + super.dispose(); 382 382 + } 383 383 + 384 384 + void _parseFacets() { 385 385 + _facetDebounce?.cancel(); 386 386 + _facetDebounce = Timer(const Duration(milliseconds: 100), () async { 387 387 + final text = widget.controller.text; 388 388 + if (widget.facets != null && widget.facets!.isNotEmpty) { 389 389 + setState(() => _parsedFacets = widget.facets!); 390 390 + } else { 391 391 + try { 392 392 + final blueskyText = BlueskyText(text); 393 393 + final entities = blueskyText.entities; 394 394 + final facets = await entities.toFacets(); 395 395 + if (mounted) setState(() => _parsedFacets = List<Map<String, dynamic>>.from(facets)); 396 396 + } catch (_) { 397 397 + if (mounted) setState(() => _parsedFacets = []); 398 398 + } 399 399 + } 400 400 + }); 401 401 + } 402 402 + 403 403 + @override 404 404 + Widget build(BuildContext context) { 405 405 + final theme = Theme.of(context); 406 406 + final text = widget.controller.text; 407 407 + final baseStyle = theme.textTheme.bodyMedium?.copyWith(fontSize: 15); 408 408 + final linkStyle = baseStyle?.copyWith(color: theme.colorScheme.primary); 409 409 + 410 410 + // Use the same facet processing logic as FacetedText 411 411 + final spans = FacetUtils.processFacets( 412 412 + text: text, 413 413 + facets: _parsedFacets, 414 414 + defaultStyle: baseStyle, 415 415 + linkStyle: linkStyle, 416 416 + onMentionTap: _onMentionTap, 417 417 + onLinkTap: null, // No link tap in text field 418 418 + onTagTap: null, // No tag tap in text field 419 419 + ); 420 420 + return LayoutBuilder( 421 421 + builder: (context, constraints) { 422 422 + return SizedBox( 423 423 + width: double.infinity, // Make it full width 424 424 + height: widget.maxLines == 1 425 425 + ? null 426 426 + : (baseStyle?.fontSize ?? 15) * 1.4 * widget.maxLines + 427 427 + 24, // Line height * maxLines + padding 428 428 + child: Stack( 429 429 + children: [ 430 430 + // RichText for highlight wrapped in SingleChildScrollView 431 431 + SingleChildScrollView( 432 432 + controller: _richTextScrollController, 433 433 + physics: const NeverScrollableScrollPhysics(), // Disable direct interaction 434 434 + child: Padding( 435 435 + padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 12), 436 436 + child: RichText( 437 437 + text: TextSpan(children: spans), 438 438 + maxLines: null, // Allow unlimited lines for scrolling 439 439 + overflow: TextOverflow.visible, 440 440 + ), 441 441 + ), 442 442 + ), 443 443 + // Editable TextField for input, but with transparent text so only RichText is visible 444 444 + Positioned.fill( 445 445 + child: TextField( 446 446 + controller: widget.controller, 447 447 + scrollController: _textFieldScrollController, 448 448 + maxLines: null, // Allow unlimited lines for scrolling 449 449 + enabled: widget.enabled, 450 450 + keyboardType: widget.keyboardType, 451 451 + onChanged: widget.onChanged, 452 452 + style: baseStyle?.copyWith(color: const Color(0x01000000)), 453 453 + cursorColor: theme.colorScheme.primary, 454 454 + showCursor: true, 455 455 + enableInteractiveSelection: true, 456 456 + decoration: InputDecoration( 457 457 + hintText: widget.hintText, 458 458 + hintStyle: baseStyle?.copyWith(color: theme.hintColor), 459 459 + border: InputBorder.none, 460 460 + contentPadding: const EdgeInsets.symmetric(horizontal: 12, vertical: 12), 461 461 + isDense: true, 462 462 + prefixIcon: widget.prefixIcon, 463 463 + suffixIcon: widget.suffixIcon, 464 464 + ), 465 465 + ), 466 466 + ), 467 467 + ], 468 468 + ), 469 469 + ); 470 470 + }, 471 471 + ); 472 472 + } 473 473 + }

+20 -1

lib/widgets/gallery_photo_view.dart

··· 128 128 final gallery = widget.gallery; 129 129 final subject = gallery?.uri; 130 130 final focus = photo.uri; 131 131 - if (subject == null || focus == null) { 131 131 + if (subject == null) { 132 132 return; 133 133 } 134 134 // Use the provider's createComment method ··· 165 165 }, 166 166 ), 167 167 ], 168 168 + ), 169 169 + ), 170 170 + ), 171 171 + if (!widget.showAddCommentButton && photo.exif != null) 172 172 + SafeArea( 173 173 + top: false, 174 174 + child: Padding( 175 175 + padding: const EdgeInsets.all(16), 176 176 + child: Align( 177 177 + alignment: Alignment.centerRight, 178 178 + child: IconButton( 179 179 + icon: Icon(Icons.camera_alt, color: Colors.white), 180 180 + onPressed: () { 181 181 + showDialog( 182 182 + context: context, 183 183 + builder: (context) => PhotoExifDialog(exif: photo.exif!), 184 184 + ); 185 185 + }, 186 186 + ), 168 187 ), 169 188 ), 170 189 ),

+1 -1

pubspec.yaml

··· 16 16 # https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html 17 17 # In Windows, build-name is used as the major, minor, and patch parts 18 18 # of the product and file versions while build-number is used as the build suffix. 19 19 - version: 1.0.0+20 19 19 + version: 1.0.0+24 20 20 21 21 environment: 22 22 sdk: ^3.8.1