diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb index 63e896cb..22e097ac 100644 --- a/lib/l10n/app_en.arb +++ b/lib/l10n/app_en.arb @@ -3297,5 +3297,47 @@ "setRegionScope_save": "Save", "setRegionScope_searchRepeaters": "Search repeaters", "setRegionScope_pathNote": "You can only discover regions from a repeater you have a stored path to.", - "setRegionScope_noPath": "No stored path" + "setRegionScope_noPath": "No stored path", + "storage_title": "Storage", + "storage_databaseSize": "Message database: {size}", + "@storage_databaseSize": { + "description": "Current size of the message database on this device (#962).", + "placeholders": { + "size": { + "type": "String" + } + } + }, + "storage_staleHint": "When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.", + "@storage_staleHint": { + "description": "Explains what the Clear Stale History action does (#962)." + }, + "storage_clearStaleNow": "Clear Stale History Now", + "storage_working": "Clearing...", + "storage_resultNothing": "Nothing to clear.", + "storage_resultCleared": "Cleared {count} old copies, {size} returned.", + "@storage_resultCleared": { + "description": "Result of a successful stale-history clear (#962).", + "placeholders": { + "count": { + "type": "int" + }, + "size": { + "type": "String" + } + } + }, + "storage_resultRefused": "Kept {count} that could not be verified. Your messages are intact; nothing was deleted for those.", + "@storage_resultRefused": { + "description": "Reported when the clear kept a copy back because its messages could not be verified against the new format (#962, owner decision: the button reports refusals rather than only logging them).", + "placeholders": { + "count": { + "type": "int" + } + } + }, + "storage_resultFailed": "Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.", + "@storage_resultFailed": { + "description": "Shown when the clear threw. It must not claim nothing happened, because the sweep deletes per key and may have cleared some before failing (#962)." + } } diff --git a/lib/l10n/app_localizations.dart b/lib/l10n/app_localizations.dart index 687451e3..1106cb50 100644 --- a/lib/l10n/app_localizations.dart +++ b/lib/l10n/app_localizations.dart @@ -9177,6 +9177,60 @@ abstract class AppLocalizations { /// In en, this message translates to: /// **'No stored path'** String get setRegionScope_noPath; + + /// No description provided for @storage_title. + /// + /// In en, this message translates to: + /// **'Storage'** + String get storage_title; + + /// Current size of the message database on this device (#962). + /// + /// In en, this message translates to: + /// **'Message database: {size}'** + String storage_databaseSize(String size); + + /// Explains what the Clear Stale History action does (#962). + /// + /// In en, this message translates to: + /// **'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'** + String get storage_staleHint; + + /// No description provided for @storage_clearStaleNow. + /// + /// In en, this message translates to: + /// **'Clear Stale History Now'** + String get storage_clearStaleNow; + + /// No description provided for @storage_working. + /// + /// In en, this message translates to: + /// **'Clearing...'** + String get storage_working; + + /// No description provided for @storage_resultNothing. + /// + /// In en, this message translates to: + /// **'Nothing to clear.'** + String get storage_resultNothing; + + /// Result of a successful stale-history clear (#962). + /// + /// In en, this message translates to: + /// **'Cleared {count} old copies, {size} returned.'** + String storage_resultCleared(int count, String size); + + /// Reported when the clear kept a copy back because its messages could not be verified against the new format (#962, owner decision: the button reports refusals rather than only logging them). + /// + /// In en, this message translates to: + /// **'Kept {count} that could not be verified. Your messages are intact; nothing was deleted for those.'** + String storage_resultRefused(int count); + + /// Shown when the clear threw. It must not claim nothing happened, because the sweep deletes per key and may have cleared some before failing (#962). + /// + /// In en, this message translates to: + /// **'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'** + String get storage_resultFailed; } class _AppLocalizationsDelegate diff --git a/lib/l10n/app_localizations_bg.dart b/lib/l10n/app_localizations_bg.dart index 756d6fad..177cc3ea 100644 --- a/lib/l10n/app_localizations_bg.dart +++ b/lib/l10n/app_localizations_bg.dart @@ -5424,4 +5424,39 @@ class AppLocalizationsBg extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_de.dart b/lib/l10n/app_localizations_de.dart index 5a7b6e50..37c45011 100644 --- a/lib/l10n/app_localizations_de.dart +++ b/lib/l10n/app_localizations_de.dart @@ -5441,4 +5441,39 @@ class AppLocalizationsDe extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_en.dart b/lib/l10n/app_localizations_en.dart index ed3d5d5b..9a421213 100644 --- a/lib/l10n/app_localizations_en.dart +++ b/lib/l10n/app_localizations_en.dart @@ -5347,4 +5347,39 @@ class AppLocalizationsEn extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_es.dart b/lib/l10n/app_localizations_es.dart index c4afa3e5..9231b7a8 100644 --- a/lib/l10n/app_localizations_es.dart +++ b/lib/l10n/app_localizations_es.dart @@ -5429,4 +5429,39 @@ class AppLocalizationsEs extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_fr.dart b/lib/l10n/app_localizations_fr.dart index 6b54ae04..f1081257 100644 --- a/lib/l10n/app_localizations_fr.dart +++ b/lib/l10n/app_localizations_fr.dart @@ -5457,4 +5457,39 @@ class AppLocalizationsFr extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_hu.dart b/lib/l10n/app_localizations_hu.dart index a65b1356..be57d319 100644 --- a/lib/l10n/app_localizations_hu.dart +++ b/lib/l10n/app_localizations_hu.dart @@ -5446,4 +5446,39 @@ class AppLocalizationsHu extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_it.dart b/lib/l10n/app_localizations_it.dart index 68693e6a..d9765386 100644 --- a/lib/l10n/app_localizations_it.dart +++ b/lib/l10n/app_localizations_it.dart @@ -5434,4 +5434,39 @@ class AppLocalizationsIt extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_ja.dart b/lib/l10n/app_localizations_ja.dart index b962df0d..9271f9cd 100644 --- a/lib/l10n/app_localizations_ja.dart +++ b/lib/l10n/app_localizations_ja.dart @@ -5200,4 +5200,39 @@ class AppLocalizationsJa extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_ko.dart b/lib/l10n/app_localizations_ko.dart index 3784b076..2a466483 100644 --- a/lib/l10n/app_localizations_ko.dart +++ b/lib/l10n/app_localizations_ko.dart @@ -5201,4 +5201,39 @@ class AppLocalizationsKo extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_nl.dart b/lib/l10n/app_localizations_nl.dart index 95f297c7..9ba517a1 100644 --- a/lib/l10n/app_localizations_nl.dart +++ b/lib/l10n/app_localizations_nl.dart @@ -5409,4 +5409,39 @@ class AppLocalizationsNl extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_pl.dart b/lib/l10n/app_localizations_pl.dart index ed78bfb6..87f72c30 100644 --- a/lib/l10n/app_localizations_pl.dart +++ b/lib/l10n/app_localizations_pl.dart @@ -5446,4 +5446,39 @@ class AppLocalizationsPl extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_pt.dart b/lib/l10n/app_localizations_pt.dart index 83faa2b7..0e4a7910 100644 --- a/lib/l10n/app_localizations_pt.dart +++ b/lib/l10n/app_localizations_pt.dart @@ -5422,4 +5422,39 @@ class AppLocalizationsPt extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_ru.dart b/lib/l10n/app_localizations_ru.dart index f85d1072..7da39ce6 100644 --- a/lib/l10n/app_localizations_ru.dart +++ b/lib/l10n/app_localizations_ru.dart @@ -5440,4 +5440,39 @@ class AppLocalizationsRu extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_sk.dart b/lib/l10n/app_localizations_sk.dart index b7b7a602..3fb0c77b 100644 --- a/lib/l10n/app_localizations_sk.dart +++ b/lib/l10n/app_localizations_sk.dart @@ -5406,4 +5406,39 @@ class AppLocalizationsSk extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_sl.dart b/lib/l10n/app_localizations_sl.dart index 757f3134..970574ec 100644 --- a/lib/l10n/app_localizations_sl.dart +++ b/lib/l10n/app_localizations_sl.dart @@ -5404,4 +5404,39 @@ class AppLocalizationsSl extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_sv.dart b/lib/l10n/app_localizations_sv.dart index 27115785..38bc2f4d 100644 --- a/lib/l10n/app_localizations_sv.dart +++ b/lib/l10n/app_localizations_sv.dart @@ -5379,4 +5379,39 @@ class AppLocalizationsSv extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_uk.dart b/lib/l10n/app_localizations_uk.dart index 2b9611db..e0de749f 100644 --- a/lib/l10n/app_localizations_uk.dart +++ b/lib/l10n/app_localizations_uk.dart @@ -5441,4 +5441,39 @@ class AppLocalizationsUk extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/l10n/app_localizations_zh.dart b/lib/l10n/app_localizations_zh.dart index 7bb28f30..d68664b8 100644 --- a/lib/l10n/app_localizations_zh.dart +++ b/lib/l10n/app_localizations_zh.dart @@ -5074,4 +5074,39 @@ class AppLocalizationsZh extends AppLocalizations { @override String get setRegionScope_noPath => 'No stored path'; + + @override + String get storage_title => 'Storage'; + + @override + String storage_databaseSize(String size) { + return 'Message database: $size'; + } + + @override + String get storage_staleHint => + 'When your history moves to the new format, the old copy is kept for 30 days and then cleared on its own. You can clear it now instead.'; + + @override + String get storage_clearStaleNow => 'Clear Stale History Now'; + + @override + String get storage_working => 'Clearing...'; + + @override + String get storage_resultNothing => 'Nothing to clear.'; + + @override + String storage_resultCleared(int count, String size) { + return 'Cleared $count old copies, $size returned.'; + } + + @override + String storage_resultRefused(int count) { + return 'Kept $count that could not be verified. Your messages are intact; nothing was deleted for those.'; + } + + @override + String get storage_resultFailed => + 'Could not finish, and some old copies may already have been cleared. Nothing was deleted that was not verified first, so your messages are intact.'; } diff --git a/lib/screens/settings/app_settings_view.dart b/lib/screens/settings/app_settings_view.dart index 5486422f..7fcfe8f7 100644 --- a/lib/screens/settings/app_settings_view.dart +++ b/lib/screens/settings/app_settings_view.dart @@ -11,11 +11,12 @@ import '../../services/app_settings_service.dart'; import '../../services/translation_service.dart'; import '../../helpers/settings_persist.dart'; import '../../helpers/snack_bar_builder.dart'; +import '../../widgets/storage_reclaim_card.dart'; import '../map_cache_screen.dart'; /// Embeddable view (no Scaffold) for the App Settings shell pane. /// -/// Renders appearance, translation, battery, map, and Cyr2Lat cards. +/// Renders appearance, translation, battery, map, Cyr2Lat and storage cards. /// Notifications and message-handling settings live in [MessageSettingsView]; /// app debug logging lives in the Debug category on the settings screen. class AppSettingsView extends StatelessWidget { @@ -44,6 +45,10 @@ class AppSettingsView extends StatelessWidget { _buildMapSettingsCard(context, settingsService), const SizedBox(height: 16), _buildCyr2LatCard(context, settingsService), + const SizedBox(height: 16), + // #962. Its own widget rather than another card in this file, + // which is already past a thousand lines. + const StorageReclaimCard(), ], ); }, diff --git a/lib/services/stale_history_sweep.dart b/lib/services/stale_history_sweep.dart index f4652cc4..2b42e21d 100644 --- a/lib/services/stale_history_sweep.dart +++ b/lib/services/stale_history_sweep.dart @@ -167,7 +167,24 @@ class StaleHistorySweep { } } - final bytesAfter = await _blobs.databaseSizeBytes(); + // A sweep that deleted blobs correctly must not be reported as a failure + // because the closing size read threw. The deletes are the work; the byte + // count is reporting. Falling back to `bytesBefore` makes the reclaimed + // figure read as 0, which understates rather than invents, and keeps the + // manual action from telling the user nothing happened when something did + // (Gemini review). + int bytesAfter; + try { + bytesAfter = await _blobs.databaseSizeBytes(); + } catch (e) { + appLogger.warn( + 'Cleared ${cleared.length} stale blob(s) but could not read the ' + 'database size afterwards, so the reclaimed figure reads as 0: $e', + tag: 'Storage', + ); + bytesAfter = bytesBefore; + } + if (cleared.isNotEmpty || refused.isNotEmpty) { appLogger.info( 'Stale history sweep: cleared ${cleared.length}, kept ' diff --git a/lib/widgets/storage_reclaim_card.dart b/lib/widgets/storage_reclaim_card.dart new file mode 100644 index 00000000..d34cfd50 --- /dev/null +++ b/lib/widgets/storage_reclaim_card.dart @@ -0,0 +1,185 @@ +import 'package:flutter/material.dart'; + +import '../l10n/app_localizations.dart'; +import '../l10n/l10n.dart'; +import '../services/stale_history_sweep.dart'; +import '../storage/drift/blob_store.dart'; +import '../utils/app_logger.dart'; + +/// "Clear Stale History Now": the manual trigger for the #962 sweep. +/// +/// A migrated message key keeps a frozen copy of its history, which the sweep +/// reclaims 30 days later on its own. This is for not waiting. +/// +/// Its own widget rather than another card inside `app_settings_view.dart`, +/// which is already past a thousand lines, and so that B2's tests can drive it +/// without standing up the whole settings screen. +/// +/// Stateful, against the repo's usual StatelessWidget-plus-Consumer habit, +/// because the running flag and the last result are local to this card and +/// belong to no service. +class StorageReclaimCard extends StatefulWidget { + const StorageReclaimCard({ + super.key, + BlobStore? blobs, + Future Function()? runSweep, + Future Function()? readSize, + }) : _blobs = blobs, + _runSweep = runSweep, + _readSize = readSize; + + /// Injectable for tests; production reads the singleton. + final BlobStore? _blobs; + + /// The sweep, injectable. + /// + /// Not only for convenience: the real sweep uses `compute`, and an isolate + /// deadlocks `pumpAndSettle` inside `flutter_test`'s fake-async zone. The + /// sweep's own behaviour is covered by Epic A's unit tests, which run under + /// plain `test()` where isolates work. What is left to prove here is that + /// this card reports each outcome correctly, and that is testable without + /// re-running the engine. + final Future Function()? _runSweep; + + /// The size read, injectable for the same reason. + final Future Function()? _readSize; + + @override + State createState() => _StorageReclaimCardState(); +} + +class _StorageReclaimCardState extends State { + BlobStore get _blobs => widget._blobs ?? BlobStore.instance; + + bool _running = false; + int? _sizeBytes; + StaleHistoryOutcome? _result; + Object? _error; + + @override + void initState() { + super.initState(); + _refreshSize(); + } + + Future _refreshSize() async { + try { + final size = await (widget._readSize ?? _blobs.databaseSizeBytes)(); + if (mounted) setState(() => _sizeBytes = size); + } catch (e) { + // A size we cannot read is not worth an error state: the action below + // still works, and the row simply shows nothing. + appLogger.warn('Could not read the database size: $e', tag: 'Storage'); + } + } + + Future _clear() async { + // The disabled button is not enough on its own. `setState` only schedules + // a rebuild, so two taps inside one frame both see an `onPressed` that is + // still non-null and both reach here, which would run two sweeps and two + // VACUUMs concurrently (Gemini review). + if (_running) return; + setState(() { + _running = true; + _result = null; + _error = null; + }); + try { + // `olderThan: Duration.zero` is the whole point of the button: every + // migrated key is eligible immediately. The per-key verification is + // unchanged, so this skips the wait and not the safety. + final outcome = + await (widget._runSweep ?? + () => StaleHistorySweep(_blobs).run(olderThan: Duration.zero))(); + if (!mounted) return; + setState(() { + _result = outcome; + _sizeBytes = outcome.bytesAfter; + }); + } catch (e, s) { + appLogger.error('Clear stale history failed: $e\n$s', tag: 'Storage'); + if (!mounted) return; + setState(() => _error = e); + } finally { + if (mounted) setState(() => _running = false); + } + } + + static String _mb(int bytes) => + '${(bytes / (1024 * 1024)).toStringAsFixed(1)} MB'; + + @override + Widget build(BuildContext context) { + final l10n = context.l10n; + return Card( + child: Padding( + padding: const EdgeInsets.all(16), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + l10n.storage_title, + style: const TextStyle(fontSize: 16, fontWeight: FontWeight.bold), + ), + const SizedBox(height: 8), + if (_sizeBytes != null) + Text(l10n.storage_databaseSize(_mb(_sizeBytes!))), + const SizedBox(height: 8), + Text( + l10n.storage_staleHint, + style: TextStyle(fontSize: 12, color: Colors.grey[600]), + ), + const SizedBox(height: 12), + Align( + alignment: Alignment.centerLeft, + child: FilledButton.tonal( + onPressed: _running ? null : _clear, + child: Text( + _running ? l10n.storage_working : l10n.storage_clearStaleNow, + ), + ), + ), + ?_resultLine(l10n), + ], + ), + ), + ); + } + + Widget? _resultLine(AppLocalizations l10n) { + if (_error != null) { + return Padding( + padding: const EdgeInsets.only(top: 12), + child: Text( + l10n.storage_resultFailed, + style: TextStyle(color: Theme.of(context).colorScheme.error), + ), + ); + } + final r = _result; + if (r == null) return null; + + final lines = [ + if (r.cleared.isEmpty) + l10n.storage_resultNothing + else + l10n.storage_resultCleared( + r.cleared.length, + _mb(r.bytesReclaimed < 0 ? 0 : r.bytesReclaimed), + ), + // Owner decision 2026-10-22: the button reports what it refused, it does + // not just log it. A key kept back because its rows could not be + // verified is the single most useful thing this action can tell you, and + // staying quiet about it is how #952 went unnoticed for days. + if (r.refused.isNotEmpty) l10n.storage_resultRefused(r.refused.length), + ]; + + return Padding( + padding: const EdgeInsets.only(top: 12), + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [for (final line in lines) Text(line)], + ), + ); + } +} diff --git a/test/storage/stale_history_sweep_test.dart b/test/storage/stale_history_sweep_test.dart index 1551716b..977620c1 100644 --- a/test/storage/stale_history_sweep_test.dart +++ b/test/storage/stale_history_sweep_test.dart @@ -369,6 +369,50 @@ void main() { }); }); + group('what the manual action relies on (#966)', () { + test('olderThan zero makes a key migrated seconds ago eligible', () async { + // The button passes Duration.zero, which is the whole point of it: no + // waiting 30 days. Proven here under plain `test()` rather than in the + // widget test, because the sweep uses `compute` and an isolate + // deadlocks pumpAndSettle in flutter_test's fake-async zone. The widget + // test injects the sweep for that reason, so this is what keeps the + // semantic it injects honest. + await blobs.write(key, bigBlobWith(20)); + expect(await blobs.ensureMessageRowsMigrated(key, toRows), isTrue); + + // The default window leaves it alone. + expect((await StaleHistorySweep(blobs).run()).cleared, isEmpty); + expect(await blobs.read(key), isNotNull); + + // Duration.zero does not. + final outcome = await StaleHistorySweep( + blobs, + ).run(olderThan: Duration.zero); + + expect(outcome.cleared, [key]); + expect(await blobs.read(key), isNull); + expect(await blobs.messageRowCount(key), 20); + }); + + test('olderThan zero still refuses an unverifiable key', () async { + // Skipping the wait must not skip the safety. + await blobs.write(key, bigBlobWith(20)); + await blobs.ensureMessageRowsMigrated(key, toRows); + await blobs.deleteMessageRow( + key, + (await blobs.messageMergeKeys(key)).first, + ); + + final outcome = await StaleHistorySweep( + blobs, + ).run(olderThan: Duration.zero); + + expect(outcome.cleared, isEmpty); + expect(outcome.refused, [key]); + expect(await blobs.read(key), isNotNull); + }); + }); + group('a direct-message key sweeps too', () { test('messages_ uses the DM converter and is cleared', () async { const dmKey = 'messages_aaaaaaaaaacafebabe'; diff --git a/test/widgets/storage_reclaim_card_test.dart b/test/widgets/storage_reclaim_card_test.dart new file mode 100644 index 00000000..c5d6f6b8 --- /dev/null +++ b/test/widgets/storage_reclaim_card_test.dart @@ -0,0 +1,225 @@ +import 'dart:async'; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:meshcore_open/l10n/app_localizations.dart'; +import 'package:meshcore_open/services/stale_history_sweep.dart'; +import 'package:meshcore_open/widgets/storage_reclaim_card.dart'; + +/// Epic B of #962, task B2. +/// +/// Tests the CARD, not the sweep. The sweep's behaviour is pinned by Epic A's +/// 18 unit tests, which run under plain `test()`. It cannot be re-run here: +/// it uses `compute`, and an isolate deadlocks `pumpAndSettle` inside +/// `flutter_test`'s fake-async zone, which is what made the first version of +/// this file hang past ten minutes rather than fail. So the sweep is injected +/// and each outcome is fed in directly. +/// +/// The case this task exists for is the third one: a key held back because its +/// rows could not be verified must be REPORTED, not merely logged. Owner +/// decision 2026-10-22. +void main() { + StaleHistoryOutcome outcome({ + List cleared = const [], + List refused = const [], + int before = 70 * 1024 * 1024, + int after = 70 * 1024 * 1024, + }) => StaleHistoryOutcome( + cleared: cleared, + refused: refused, + bytesBefore: before, + bytesAfter: after, + ); + + Future pump( + WidgetTester tester, { + required Future Function() runSweep, + Future Function()? readSize, + }) async { + await tester.pumpWidget( + MaterialApp( + localizationsDelegates: AppLocalizations.localizationsDelegates, + supportedLocales: AppLocalizations.supportedLocales, + home: Scaffold( + body: StorageReclaimCard( + runSweep: runSweep, + readSize: readSize ?? () async => 70 * 1024 * 1024, + ), + ), + ), + ); + await tester.pumpAndSettle(); + } + + Future tapClear(WidgetTester tester) async { + await tester.tap(find.text('Clear Stale History Now')); + await tester.pumpAndSettle(); + } + + testWidgets('it shows the database size before anything is clicked', ( + tester, + ) async { + await pump(tester, runSweep: () async => outcome()); + + expect(find.textContaining('Message database:'), findsOneWidget); + expect(find.textContaining('70.0 MB'), findsOneWidget); + }); + + testWidgets('nothing eligible reports nothing to clear', (tester) async { + await pump(tester, runSweep: () async => outcome()); + + await tapClear(tester); + + expect(find.text('Nothing to clear.'), findsOneWidget); + expect(find.textContaining('Kept'), findsNothing); + }); + + testWidgets('cleared keys report the count and the size returned', ( + tester, + ) async { + await pump( + tester, + runSweep: () async => outcome( + cleared: const ['a', 'b', 'c'], + before: 70 * 1024 * 1024, + after: 54 * 1024 * 1024, + ), + ); + + await tapClear(tester); + + expect(find.textContaining('Cleared 3 old copies'), findsOneWidget); + expect(find.textContaining('16.0 MB returned'), findsOneWidget); + // And the size row updates to what the sweep actually left behind, rather + // than still showing the pre-sweep number. + expect(find.textContaining('Message database: 54.0 MB'), findsOneWidget); + }); + + testWidgets('a refused key is REPORTED, not just logged', (tester) async { + await pump( + tester, + runSweep: () async => outcome(cleared: const ['a'], refused: const ['b']), + ); + + await tapClear(tester); + + expect( + find.textContaining('Kept 1 that could not be verified'), + findsOneWidget, + reason: 'silence here is how #952 went unnoticed for days', + ); + expect( + find.textContaining('messages are intact'), + findsOneWidget, + reason: + 'it has to say the history is safe, not only that something was ' + 'held back', + ); + // Both halves are shown: what went and what did not. + expect(find.textContaining('Cleared 1 old copies'), findsOneWidget); + }); + + testWidgets('refusals show even when nothing at all was cleared', ( + tester, + ) async { + await pump(tester, runSweep: () async => outcome(refused: const ['b'])); + + await tapClear(tester); + + expect(find.text('Nothing to clear.'), findsOneWidget); + expect( + find.textContaining('Kept 1 that could not be verified'), + findsOneWidget, + reason: + 'a run that cleared nothing BECAUSE of a refusal is the most ' + 'important case to surface, not the least', + ); + }); + + testWidgets('a failure says the messages are intact', (tester) async { + // "Could not finish" on a delete action otherwise reads as "something was + // half-deleted". + await pump(tester, runSweep: () async => throw StateError('boom')); + + await tapClear(tester); + + expect(find.textContaining('Could not finish'), findsOneWidget); + expect(find.textContaining('messages are intact'), findsOneWidget); + expect( + find.textContaining('may already have been cleared'), + findsOneWidget, + reason: + 'the sweep deletes per key, so a throw can follow real deletes and ' + 'the message must not claim nothing happened (Gemini review)', + ); + }); + + testWidgets('a second tap in the same frame cannot start a second sweep', ( + tester, + ) async { + // The disabled button is not enough: setState only SCHEDULES a rebuild, + // so two taps inside one frame both see a live onPressed. _clear guards + // on _running for that, and two concurrent sweeps would mean two + // concurrent VACUUMs. + var runs = 0; + final gate = Completer(); + await pump( + tester, + runSweep: () { + runs++; + return gate.future; + }, + ); + + final button = find.text('Clear Stale History Now'); + await tester.tap(button, warnIfMissed: false); + await tester.tap(button, warnIfMissed: false); + + expect(runs, 1, reason: 'the second tap in the same frame must be ignored'); + + gate.complete(outcome()); + await tester.pumpAndSettle(); + }); + + testWidgets('the button is disabled while it runs', (tester) async { + final gate = Completer(); + await pump(tester, runSweep: () => gate.future); + + await tester.tap(find.text('Clear Stale History Now')); + await tester.pump(); + + expect( + tester.widget(find.byType(FilledButton)).onPressed, + isNull, + reason: 'a second tap mid-sweep would run two VACUUMs at once', + ); + expect(find.text('Clearing...'), findsOneWidget); + + gate.complete(outcome(cleared: const ['a'])); + await tester.pumpAndSettle(); + + expect( + tester.widget(find.byType(FilledButton)).onPressed, + isNotNull, + reason: 'and it must come back, or the action works exactly once', + ); + }); + + testWidgets('an unreadable size leaves the row out rather than erroring', ( + tester, + ) async { + await pump( + tester, + runSweep: () async => outcome(), + readSize: () async => throw StateError('no size'), + ); + + expect(find.textContaining('Message database:'), findsNothing); + // The action is still usable: a size we cannot read is not a reason to + // block clearing. + expect( + tester.widget(find.byType(FilledButton)).onPressed, + isNotNull, + ); + }); +} diff --git a/untranslated.json b/untranslated.json index 7f449ec0..873a1bcb 100644 --- a/untranslated.json +++ b/untranslated.json @@ -168,6 +168,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -262,7 +264,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "de": [ @@ -434,6 +445,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -528,7 +541,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "es": [ @@ -700,6 +722,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -794,7 +818,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "fr": [ @@ -966,6 +999,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -1060,7 +1095,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "hu": [ @@ -1232,6 +1276,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -1326,7 +1372,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "it": [ @@ -1498,6 +1553,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -1592,7 +1649,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "ja": [ @@ -1764,6 +1830,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -1858,7 +1926,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "ko": [ @@ -2030,6 +2107,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -2124,7 +2203,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "nl": [ @@ -2296,6 +2384,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -2390,7 +2480,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "pl": [ @@ -2562,6 +2661,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -2656,7 +2757,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "pt": [ @@ -2828,6 +2938,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -2922,7 +3034,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "ru": [ @@ -3094,6 +3215,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -3188,7 +3311,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "sk": [ @@ -3360,6 +3492,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -3454,7 +3588,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "sl": [ @@ -3626,6 +3769,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -3720,7 +3865,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "sv": [ @@ -3892,6 +4046,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -3986,7 +4142,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "uk": [ @@ -4158,6 +4323,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -4252,7 +4419,16 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ], "zh": [ @@ -4424,6 +4600,8 @@ "block_settingsTitle", "block_settingsSubtitle", "block_none", + "block_noRadio", + "block_noRadioHint", "block_keysSection", "block_namesSection", "block_namesHint", @@ -4518,6 +4696,15 @@ "setRegionScope_save", "setRegionScope_searchRepeaters", "setRegionScope_pathNote", - "setRegionScope_noPath" + "setRegionScope_noPath", + "storage_title", + "storage_databaseSize", + "storage_staleHint", + "storage_clearStaleNow", + "storage_working", + "storage_resultNothing", + "storage_resultCleared", + "storage_resultRefused", + "storage_resultFailed" ] }