feat: signup identity helper in the autofill picker (v2.10.9)

@@ -0,0 +1,99 @@1+package com.peachpasswords.autofill2+3+import com.peachpasswords.shared.extractDomain4+import com.peachpasswords.vault.VaultEntry5+6+/**7+ * Signup identities for the autofill picker (parity gap A4). Ports the8+ * browser's `getIdentities()` (background/vault.ts) and `identity-helper.ts`:9+ * identities are DERIVED from active login entries — deduplicated10+ * usernames/emails with usage tallies — not separate vault objects.11+ */12+13+enum class IdentityType { EMAIL, USERNAME }14+15+enum class IdentityFilterMode(val label: String) {16+    BOTH("Both"),17+    EMAIL("Emails"),18+    USERNAME("Usernames"),19+}20+21+data class SavedIdentity(22+    val value: String,23+    val type: IdentityType,24+    val lastUsed: Long,25+    val useCount: Int,26+    val exampleDomain: String? = null,27+)28+29+private val EMAIL_RE = Regex("^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$")30+31+private class Tally(var lastUsed: Long, var count: Int, var domain: String)32+33+/** Dedupe active login entries' usernames/emails into usage-ordered identities. */34+internal fun deriveIdentities(entries: List<VaultEntry>): List<SavedIdentity> {35+    val active = entries.filter { it.deletedAt == null && it.type == "login" }36+    val emailMap = HashMap<String, Tally>()37+    val usernameMap = HashMap<String, Tally>()38+39+    fun tally(map: HashMap<String, Tally>, value: String, modifiedAt: Long, domain: String) {40+        val existing = map[value]41+        if (existing == null) {42+            map[value] = Tally(modifiedAt, 1, domain)43+        } else {44+            existing.count++45+            if (modifiedAt > existing.lastUsed) {46+                existing.lastUsed = modifiedAt47+                existing.domain = domain48+            }49+        }50+    }51+52+    for (entry in active) {53+        val domain = entry.url?.let(::extractDomain) ?: ""54+        entry.username?.trim()?.takeIf { it.isNotEmpty() }?.let { value ->55+            tally(if (EMAIL_RE.matches(value)) emailMap else usernameMap, value, entry.modifiedAt, domain)56+        }57+        // Count the dedicated email field too — entries created via the58+        // new-entry editor store email here rather than in username.59+        entry.email?.trim()?.takeIf { it.isNotEmpty() }?.let { value ->60+            tally(emailMap, value, entry.modifiedAt, domain)61+        }62+    }63+64+    fun toIdentities(map: HashMap<String, Tally>, type: IdentityType) =65+        map.entries66+            .map { (value, t) ->67+                SavedIdentity(value, type, t.lastUsed, t.count, t.domain.takeIf { it.isNotEmpty() })68+            }69+            .sortedByDescending { it.useCount }70+71+    return toIdentities(emailMap, IdentityType.EMAIL) + toIdentities(usernameMap, IdentityType.USERNAME)72+}73+74+/** Browser `filterSavedIdentities`: type filter, usage order, then substring. */75+internal fun filterIdentities(76+    identities: List<SavedIdentity>,77+    query: String,78+    mode: IdentityFilterMode,79+): List<SavedIdentity> {80+    val typeFiltered = when (mode) {81+        IdentityFilterMode.EMAIL -> identities.filter { it.type == IdentityType.EMAIL }82+        IdentityFilterMode.USERNAME -> identities.filter { it.type == IdentityType.USERNAME }83+        IdentityFilterMode.BOTH -> identities84+    }85+    val sorted = typeFiltered.sortedWith(86+        compareByDescending<SavedIdentity> { it.lastUsed }87+            .thenByDescending { it.useCount }88+            .thenBy { it.value }89+            .thenBy { it.type.name },90+    )91+    val trimmed = query.trim().lowercase()92+    if (trimmed.isEmpty()) return sorted93+    return sorted.filter { identity ->94+        listOf(identity.value, identity.exampleDomain ?: "", identity.type.name.lowercase())95+            .joinToString(" ")96+            .lowercase()97+            .contains(trimmed)98+    }99+}

@@ -0,0 +1,124 @@1+package com.peachpasswords.autofill2+3+import com.peachpasswords.vault.VaultEntry4+import org.junit.Assert.assertEquals5+import org.junit.Assert.assertTrue6+import org.junit.Test7+8+class IdentitiesTest {9+    private fun login(10+        id: String,11+        username: String? = null,12+        email: String? = null,13+        url: String? = null,14+        modifiedAt: Long = 100,15+        deleted: Boolean = false,16+        type: String? = "login",17+    ) = VaultEntry(18+        id = id,19+        title = id,20+        username = username,21+        email = email,22+        url = url,23+        createdAt = 0,24+        modifiedAt = modifiedAt,25+        deletedAt = if (deleted) 1L else null,26+        type = type,27+    )28+29+    @Test fun usernames_and_emails_are_derived_from_login_entries() {30+        val identities = deriveIdentities(31+            listOf(32+                login("a", username = "june", url = "https://github.com"),33+                login("b", email = "[email protected]", url = "https://fastmail.com"),34+            ),35+        )36+        assertEquals(37+            listOf(38+                SavedIdentity("[email protected]", IdentityType.EMAIL, 100, 1, "fastmail.com"),39+                SavedIdentity("june", IdentityType.USERNAME, 100, 1, "github.com"),40+            ),41+            identities,42+        )43+    }44+45+    @Test fun username_shaped_like_an_email_counts_as_email() {46+        val identities = deriveIdentities(listOf(login("a", username = "[email protected]")))47+        assertEquals(listOf(SavedIdentity("[email protected]", IdentityType.EMAIL, 100, 1, null)), identities)48+    }49+50+    @Test fun same_email_across_entries_appears_once_with_use_count() {51+        val identities = deriveIdentities(52+            listOf(53+                login("a", email = "[email protected]", url = "https://one.com", modifiedAt = 10),54+                login("b", username = "[email protected]", url = "https://two.com", modifiedAt = 30),55+                login("c", email = "[email protected]", url = "https://three.com", modifiedAt = 20),56+            ),57+        )58+        val identity = identities.single()59+        assertEquals("[email protected]", identity.value)60+        assertEquals(3, identity.useCount)61+        assertEquals(30L, identity.lastUsed)62+        assertEquals("two.com", identity.exampleDomain)63+    }64+65+    @Test fun emails_come_first_and_sort_by_use_count() {66+        val identities = deriveIdentities(67+            listOf(68+                login("a", username = "u1"),69+                login("b", username = "u2"),70+                login("c", email = "[email protected]"),71+                login("d", email = "[email protected]"),72+                login("e", email = "[email protected]"),73+            ),74+        )75+        assertEquals(76+            listOf("[email protected]", "[email protected]", "u1", "u2"),77+            identities.map { it.value },78+        )79+    }80+81+    @Test fun deleted_and_non_login_entries_are_ignored() {82+        val identities = deriveIdentities(83+            listOf(84+                login("a", username = "gone", deleted = true),85+                login("b", username = "cardholder", type = "card"),86+                login("c", username = "note-taker", type = "note"),87+            ),88+        )89+        assertTrue(identities.isEmpty())90+    }91+92+    @Test fun filter_modes_restrict_the_type() {93+        val identities = listOf(94+            SavedIdentity("[email protected]", IdentityType.EMAIL, 2, 1),95+            SavedIdentity("june", IdentityType.USERNAME, 1, 1),96+        )97+        assertEquals(listOf("[email protected]"), filterIdentities(identities, "", IdentityFilterMode.EMAIL).map { it.value })98+        assertEquals(listOf("june"), filterIdentities(identities, "", IdentityFilterMode.USERNAME).map { it.value })99+        assertEquals(2, filterIdentities(identities, "", IdentityFilterMode.BOTH).size)100+    }101+102+    @Test fun filter_orders_by_last_used_then_use_count() {103+        val identities = listOf(104+            SavedIdentity("[email protected]", IdentityType.EMAIL, lastUsed = 1, useCount = 9),105+            SavedIdentity("[email protected]", IdentityType.EMAIL, lastUsed = 5, useCount = 1),106+            SavedIdentity("[email protected]", IdentityType.EMAIL, lastUsed = 3, useCount = 2),107+        )108+        assertEquals(109+            listOf("[email protected]", "[email protected]", "[email protected]"),110+            filterIdentities(identities, "", IdentityFilterMode.BOTH).map { it.value },111+        )112+    }113+114+    @Test fun filter_query_matches_value_domain_or_type() {115+        val identities = listOf(116+            SavedIdentity("[email protected]", IdentityType.EMAIL, 2, 1, "fastmail.com"),117+            SavedIdentity("june", IdentityType.USERNAME, 1, 1, "github.com"),118+        )119+        assertEquals(listOf("[email protected]"), filterIdentities(identities, "fastmail", IdentityFilterMode.BOTH).map { it.value })120+        assertEquals(listOf("june"), filterIdentities(identities, "github", IdentityFilterMode.BOTH).map { it.value })121+        assertEquals(listOf("[email protected]"), filterIdentities(identities, "email", IdentityFilterMode.BOTH).map { it.value })122+        assertTrue(filterIdentities(identities, "zzz", IdentityFilterMode.BOTH).isEmpty())123+    }124+}