refactor: add three new test units and fix the fatal

Author: piquark6046

builder/source/utils/discard-resolved-dup-wildcard.ts

@@ -1,39 +1,97 @@
 import * as TLDTS from 'tldts'
+import { PublicSuffixList } from './wildcard-suffix-converter.js'
 
-export function DiscardResolvedDupWildcard(OriginSet: Set<string>): Set<string> {
-  // Step 1: Remove subdomains whose registered domain already exists in the set
-  const WithoutCoveredSubdomains = new Set<string>()
-  for (const Entry of OriginSet) {
-    const Parsed = TLDTS.parse(Entry)
-    if (Parsed.subdomain && Parsed.domain && OriginSet.has(Parsed.domain)) {
-      continue
+type ParsedEntry = {
+  Entry: string
+  RootLabel: string
+  Stem: string
+  PublicSuffix: string | null
+  WildcardSuffix: boolean
+}
+
+function ParseEntry(Entry: string): ParsedEntry {
+  if (Entry.endsWith('.*')) {
+    const Stem = Entry.slice(0, -2)
+    const RootLabel = Stem.split('.').at(-1) ?? Stem
+    return {
+      Entry,
+      RootLabel,
+      Stem,
+      PublicSuffix: null,
+      WildcardSuffix: true
     }
-    WithoutCoveredSubdomains.add(Entry)
   }
 
-  // Step 2: Group by domainWithoutSuffix
-  const Groups = new Map<string, string[]>()
-  for (const Entry of WithoutCoveredSubdomains) {
-    const Parsed = TLDTS.parse(Entry)
-    const Key = Parsed.domainWithoutSuffix ?? Entry
-    const Group = Groups.get(Key)
-    if (typeof Group === 'undefined') {
-      Groups.set(Key, [Entry])
-    } else {
-      Group.push(Entry)
+  const Parsed = TLDTS.parse(Entry)
+  if (Parsed.publicSuffix) {
+    PublicSuffixList.add(Parsed.publicSuffix)
+  }
+
+  if (Parsed.hostname && Parsed.publicSuffix && Parsed.hostname.endsWith(`.${Parsed.publicSuffix}`)) {
+    return {
+      Entry,
+      RootLabel: Parsed.domainWithoutSuffix ?? Parsed.hostname,
+      Stem: Parsed.hostname.slice(0, -(Parsed.publicSuffix.length + 1)),
+      PublicSuffix: Parsed.publicSuffix,
+      WildcardSuffix: false
     }
   }
 
-  // Step 3: Consolidate groups with 2+ top-level entries into wildcards
+  const Stem = Parsed.hostname ?? Entry
+  return {
+    Entry,
+    RootLabel: Stem.split('.').at(-1) ?? Stem,
+    Stem,
+    PublicSuffix: Parsed.publicSuffix,
+    WildcardSuffix: false
+  }
+}
+
+function IsCoveredByParent(Child: ParsedEntry, Parent: ParsedEntry): boolean {
+  if (Child.Stem === Parent.Stem || !Child.Stem.endsWith(`.${Parent.Stem}`)) {
+    return false
+  }
+
+  if (Parent.WildcardSuffix) {
+    return true
+  }
+
+  return !Child.WildcardSuffix && Child.PublicSuffix === Parent.PublicSuffix
+}
+
+export function DiscardResolvedDupWildcard(OriginSet: Set<string>): Set<string> {
+  const ParsedEntries = [...OriginSet].map(ParseEntry)
+  const RootsWithWildcard = new Set(
+    ParsedEntries
+      .filter(Entry => Entry.WildcardSuffix)
+      .map(Entry => Entry.RootLabel)
+  )
+
+  const ConcreteStemCounts = new Map<string, number>()
+  ParsedEntries
+    .filter(Entry => !Entry.WildcardSuffix)
+    .forEach(Entry => ConcreteStemCounts.set(Entry.Stem, (ConcreteStemCounts.get(Entry.Stem) ?? 0) + 1))
+
+  const NormalizedEntries = ParsedEntries.map(Entry => {
+    if (Entry.WildcardSuffix) {
+      return Entry
+    }
+
+    if (RootsWithWildcard.has(Entry.RootLabel) || (ConcreteStemCounts.get(Entry.Stem) ?? 0) >= 2) {
+      return ParseEntry(`${Entry.Stem}.*`)
+    }
+
+    return Entry
+  })
+
   const Result = new Set<string>()
-  for (const [Key, Entries] of Groups) {
-    if (Entries.length >= 2 && Entries.every(E => !TLDTS.parse(E).subdomain)) {
-      Result.add(`${Key}.*`)
-    } else {
-      for (const Entry of Entries) {
-        Result.add(Entry)
-      }
+  const UniqueNormalizedEntries = [...new Map(NormalizedEntries.map(Entry => [Entry.Entry, Entry])).values()]
+  for (const Entry of UniqueNormalizedEntries) {
+    if (UniqueNormalizedEntries.some(Parent => Parent.Entry !== Entry.Entry && IsCoveredByParent(Entry, Parent))) {
+      continue
     }
+
+    Result.add(Entry.Entry)
   }
 
   return Result

builder/source/utils/wildcard-suffix-converter.ts

@@ -1,7 +1,7 @@
-const PublicSuffixList = [
+export const PublicSuffixList = new Set([
   'com', 'org', 'co', 'de', 'ru', 'fr', 'me', 'it', 'nl', 'io', 'cc', 'in', 'pl', 'xyz', 'es', 'se', 'uk', 'tv', 'info',
   'site', 'us', 'online', 'ch', 'at', 'eu', 'top', 'be', 'cz', 'app', 'ca', 'to', 'jp', 'dev', 'kr'
-]
+])
 
 export function ConvertWildcardSuffixToRegexPattern(Domain: string): string[] {
   const Result: string[] = []

builder/test/utils/discard-resolved-dup-wildcard.test.ts

@@ -19,4 +19,25 @@ Test('DiscardResolvedDupWildcard does not remove non-duplicate wildcards with mu
   const Input = new Set(['access.chatgpt.com', 'info.chatgpt.com', 'access.claude.ai', 'info.claude.ai', 'access.huggingface.co', 'info.huggingface.co'])
 
   return T.deepEqual(DiscardResolvedDupWildcard(Input), Input)
+})
+
+Test('DiscardResolvedDupWildcard removes resolved duplicate wildcards with multiple subdomains', T => {
+  const Input = new Set(['google.*', 'access.google.*', 'google.com', 'google.co.kr'])
+  const Expected = new Set(['google.*'])
+  
+  return T.deepEqual(DiscardResolvedDupWildcard(Input), Expected)
+})
+
+Test('DiscardResolvedDupWildcard handles nested wildcard scenarios', T => {
+  const Input = new Set(['token.google.*', 'access.google.*', 'tools.google.com', 'google.google.co.kr'])
+  const Expected = new Set(['token.google.*', 'access.google.*', 'tools.google.*', 'google.google.*'])
+
+  return T.deepEqual(DiscardResolvedDupWildcard(Input), Expected)
+})
+
+Test('DiscardResolvedDupWildcard handles complex wildcard scenarios', T => {
+  const Input = new Set(['token.google.*', 'access.google.*', 'tools.google.com', 'google.google.co.kr', 'example.*', 'example.com', 'rust-lang.org'])
+  const Expected = new Set(['token.google.*', 'access.google.*', 'tools.google.*', 'google.google.*','example.*', 'rust-lang.org'])
+
+  return T.deepEqual(DiscardResolvedDupWildcard(Input), Expected)
 })