chore: add RegroupDomainTldLevel func

Author: piquark6046

builder/source/utils/regroup-domain-tldlevel.ts

@@ -0,0 +1,91 @@
+import * as TLDTS from 'tldts'
+import { PublicSuffixList } from './wildcard-suffix-converter.js'
+
+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
+    }
+  }
+
+  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
+    }
+  }
+
+  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 RegroupDomainTldLevel(OriginSet: Set<string>): Set<Set<string>> {
+  const ParsedEntries = [...OriginSet].map(ParseEntry)
+  const WithoutCoveredSubdomains = ParsedEntries.filter(
+    Entry => !ParsedEntries.some(Parent => Parent.Entry !== Entry.Entry && IsCoveredByParent(Entry, Parent))
+  )
+
+  const RootLevelDomains = new Map<string, string>()
+  const Groups = new Map<string, Set<string>>()
+
+  for (const Entry of WithoutCoveredSubdomains) {
+    if (Entry.Stem === Entry.RootLabel) {
+      const Existing = RootLevelDomains.get(Entry.RootLabel)
+      if (Existing && Existing !== Entry.Entry) {
+        throw new Error('RegroupDomainTldLevel: Found multiple domains with the same TLD level. Use DiscardResolvedDupWildcard func first before using RegroupDomainTldLevel.')
+      }
+
+      RootLevelDomains.set(Entry.RootLabel, Entry.Entry)
+    }
+
+    const Group = Groups.get(Entry.RootLabel)
+    if (typeof Group === 'undefined') {
+      Groups.set(Entry.RootLabel, new Set([Entry.Entry]))
+      continue
+    }
+
+    Group.add(Entry.Entry)
+  }
+
+  return new Set(Groups.values())
+}

builder/test/utils/regroup-domain-tldlevel.test.ts

@@ -0,0 +1,23 @@
+import Test from 'ava'
+import { RegroupDomainTldLevel } from '@builder/utils/regroup-domain-tldlevel.js'
+
+Test('RegroupDomainTldLevel discard subdomain elements only if their parent domain exists', T => {
+  const Origin = new Set(['duckduckgo.com', 'access.duckduckgo.com', 'google.com', 'www.google.com'])
+  const Expected = new Set([new Set(['duckduckgo.com']), new Set(['google.com'])])
+  const Actual = RegroupDomainTldLevel(Origin)
+  return T.deepEqual(Actual, Expected)
+})
+
+Test('RegroupDomainTldLevel keep subdomain elements if their parent domain does not exist', T => {
+  const Origin = new Set(['access.duckduckgo.com', 'token.duckduckgo.com', 'www.google.com', 'accounts.google.com'])
+  const Expected = new Set([new Set(['access.duckduckgo.com', 'token.duckduckgo.com']), new Set(['www.google.com', 'accounts.google.com'])])
+  const Actual = RegroupDomainTldLevel(Origin)
+  return T.deepEqual(Actual, Expected)
+})
+
+Test('RegroupDomainTldLevel throw error if multiple domains with the same TLD level exist', T => {
+  const Origin = new Set(['duckduckgo.com', 'duckduckgo.co.kr', 'duckduckgo.co.jp'])
+  const ErrorInstance = T.throws(() => RegroupDomainTldLevel(Origin))
+  const Message = 'RegroupDomainTldLevel: Found multiple domains with the same TLD level. Use DiscardResolvedDupWildcard func first before using RegroupDomainTldLevel.'
+  return T.is(ErrorInstance?.message, Message)
+})