291 lines
10 KiB
TypeScript
291 lines
10 KiB
TypeScript
"use client"
|
|
|
|
import { useCallback, useMemo } from "react"
|
|
import type { CatalogLabelPresence } from "@/components/gmail/email-label-picker-block"
|
|
import { resolveLabelPickerVisual } from "@/lib/label-picker-visual"
|
|
import {
|
|
effectiveLabels,
|
|
mergeEmailLabelEdits,
|
|
mergeEmailNotSpam,
|
|
} from "@/lib/label-edits"
|
|
import type { FolderTreeNode } from "@/lib/sidebar-nav-data"
|
|
import {
|
|
LABEL_PICKER_EXCLUDE,
|
|
} from "@/lib/mail-list/label-actions"
|
|
import {
|
|
collectTreeLabels,
|
|
} from "@/components/gmail/email-list/email-list-helpers"
|
|
import type { EmailListData } from "@/components/gmail/email-list/hooks/use-email-list-data"
|
|
|
|
export function useEmailListLabels(data: EmailListData) {
|
|
const {
|
|
allEmails,
|
|
sidebarNav,
|
|
labelEdits,
|
|
notSpamEmailIds,
|
|
setLabelEdits,
|
|
mailActions,
|
|
} = data
|
|
|
|
const collectAllFolderLabels = useCallback((): Set<string> => {
|
|
const s = new Set<string>()
|
|
const walk = (nodes: FolderTreeNode[]) => {
|
|
for (const n of nodes) {
|
|
s.add(n.label.toLowerCase())
|
|
if (n.children?.length) walk(n.children)
|
|
}
|
|
}
|
|
walk(sidebarNav.folderTree)
|
|
return s
|
|
}, [sidebarNav.folderTree])
|
|
|
|
const moveEmailsToTarget = useCallback(
|
|
(emailIds: string[], targetId: string) => {
|
|
if (emailIds.length === 0) return
|
|
const folderLabel = sidebarNav.folderIdToLabel[targetId]
|
|
const isSystemTarget = ["inbox", "sent", "drafts", "spam", "trash"].includes(targetId)
|
|
const allFolderLabels = collectAllFolderLabels()
|
|
|
|
setLabelEdits((prev) => {
|
|
const nextAdd = { ...prev.additions }
|
|
const nextRem = { ...prev.removals }
|
|
|
|
for (const id of emailIds) {
|
|
const email = allEmails.find((e) => e.id === id)
|
|
const currentLabels = effectiveLabels(email, nextAdd, nextRem)
|
|
|
|
if (isSystemTarget) {
|
|
if (targetId === "inbox") {
|
|
for (const lab of currentLabels) {
|
|
if (allFolderLabels.has(lab.toLowerCase())) {
|
|
const cur = nextRem[id] ?? []
|
|
if (!cur.some((l) => l.toLowerCase() === lab.toLowerCase())) {
|
|
nextRem[id] = [...cur, lab]
|
|
}
|
|
if (nextAdd[id]?.length) {
|
|
nextAdd[id] = nextAdd[id].filter((l) => l.toLowerCase() !== lab.toLowerCase())
|
|
if (nextAdd[id].length === 0) delete nextAdd[id]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (folderLabel) {
|
|
for (const lab of currentLabels) {
|
|
if (allFolderLabels.has(lab.toLowerCase()) && lab.toLowerCase() !== folderLabel.toLowerCase()) {
|
|
const cur = nextRem[id] ?? []
|
|
if (!cur.some((l) => l.toLowerCase() === lab.toLowerCase())) {
|
|
nextRem[id] = [...cur, lab]
|
|
}
|
|
if (nextAdd[id]?.length) {
|
|
nextAdd[id] = nextAdd[id].filter((l) => l.toLowerCase() !== lab.toLowerCase())
|
|
if (nextAdd[id].length === 0) delete nextAdd[id]
|
|
}
|
|
}
|
|
}
|
|
if (!currentLabels.some((l) => l.toLowerCase() === folderLabel.toLowerCase())) {
|
|
nextAdd[id] = [...(nextAdd[id] ?? []), folderLabel]
|
|
}
|
|
if (nextRem[id]?.length) {
|
|
nextRem[id] = nextRem[id].filter((l) => l.toLowerCase() !== folderLabel.toLowerCase())
|
|
if (nextRem[id].length === 0) delete nextRem[id]
|
|
}
|
|
const inboxIdx = currentLabels.findIndex((l) => l.toLowerCase() === "inbox")
|
|
if (inboxIdx >= 0 || !email?.labels?.length || email.labels.includes("inbox")) {
|
|
const cur = nextRem[id] ?? []
|
|
if (!cur.some((l) => l.toLowerCase() === "inbox")) {
|
|
nextRem[id] = [...cur, "inbox"]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return { additions: nextAdd, removals: nextRem }
|
|
})
|
|
|
|
if (!isSystemTarget || targetId === "inbox") {
|
|
mailActions.pushRecentMoveTarget(targetId)
|
|
}
|
|
|
|
if (isSystemTarget && targetId !== "inbox") {
|
|
mailActions.hideEmails(emailIds)
|
|
mailActions.pushRecentMoveTarget(targetId)
|
|
}
|
|
},
|
|
[allEmails, sidebarNav.folderIdToLabel, collectAllFolderLabels, setLabelEdits, mailActions]
|
|
)
|
|
|
|
const catalogLabels = useMemo(() => {
|
|
const s = new Set<string>()
|
|
for (const l of collectTreeLabels(sidebarNav.folderTree)) s.add(l)
|
|
for (const row of sidebarNav.labelRows) s.add(row.label)
|
|
for (const e of allEmails) {
|
|
const eff = mergeEmailNotSpam(
|
|
mergeEmailLabelEdits(e, labelEdits),
|
|
notSpamEmailIds
|
|
)
|
|
for (const lab of eff.labels ?? []) {
|
|
if (!LABEL_PICKER_EXCLUDE.has(lab)) s.add(lab)
|
|
}
|
|
}
|
|
return [...s].sort((a, b) => a.localeCompare(b, "fr"))
|
|
}, [sidebarNav.folderTree, sidebarNav.labelRows, allEmails, labelEdits, notSpamEmailIds])
|
|
|
|
const resolveLabelVisual = useCallback(
|
|
(label: string) =>
|
|
resolveLabelPickerVisual(label, {
|
|
folderTree: sidebarNav.folderTree,
|
|
labelRows: sidebarNav.labelRows,
|
|
emailLabelToSidebarFolderId: sidebarNav.emailLabelToSidebarFolderId,
|
|
}),
|
|
[
|
|
sidebarNav.folderTree,
|
|
sidebarNav.labelRows,
|
|
sidebarNav.emailLabelToSidebarFolderId,
|
|
]
|
|
)
|
|
|
|
const resolveLabelCasing = useCallback(
|
|
(raw: string) => {
|
|
const t = raw.trim()
|
|
if (!t) return ""
|
|
const hit = catalogLabels.find((c) => c.toLowerCase() === t.toLowerCase())
|
|
return hit ?? t
|
|
},
|
|
[catalogLabels]
|
|
)
|
|
|
|
const addLabelToEmails = useCallback(
|
|
(ids: string[], label: string) => {
|
|
const resolved = resolveLabelCasing(label)
|
|
if (!resolved || ids.length === 0) return
|
|
sidebarNav.ensureLabelRowForLabelText(resolved)
|
|
setLabelEdits((prev) => {
|
|
const nextAdd = { ...prev.additions }
|
|
const nextRem = { ...prev.removals }
|
|
for (const id of ids) {
|
|
if (nextRem[id]?.length) {
|
|
nextRem[id] = nextRem[id].filter(
|
|
(x) => x.toLowerCase() !== resolved.toLowerCase()
|
|
)
|
|
if (nextRem[id].length === 0) delete nextRem[id]
|
|
}
|
|
const base = allEmails.find((e) => e.id === id)
|
|
const merged = effectiveLabels(base, nextAdd, nextRem)
|
|
if (merged.some((x) => x.toLowerCase() === resolved.toLowerCase())) {
|
|
continue
|
|
}
|
|
nextAdd[id] = [...(nextAdd[id] ?? []), resolved]
|
|
}
|
|
return { additions: nextAdd, removals: nextRem }
|
|
})
|
|
},
|
|
[resolveLabelCasing, allEmails, sidebarNav, setLabelEdits]
|
|
)
|
|
|
|
const getCatalogLabelPresence = useCallback(
|
|
(ids: string[], catalogLabel: string): CatalogLabelPresence => {
|
|
const resolved = resolveLabelCasing(catalogLabel)
|
|
if (!resolved || ids.length === 0) return "none"
|
|
const lc = resolved.toLowerCase()
|
|
let n = 0
|
|
for (const id of ids) {
|
|
const e = allEmails.find((x) => x.id === id)
|
|
const eff = effectiveLabels(e, labelEdits.additions, labelEdits.removals)
|
|
if (eff.some((l) => l.toLowerCase() === lc)) n++
|
|
}
|
|
if (n === 0) return "none"
|
|
if (n === ids.length) return "all"
|
|
return "some"
|
|
},
|
|
[allEmails, labelEdits, resolveLabelCasing]
|
|
)
|
|
|
|
const toggleLabelOnEmails = useCallback(
|
|
(ids: string[], label: string) => {
|
|
const resolved = resolveLabelCasing(label)
|
|
if (!resolved || ids.length === 0) return
|
|
|
|
setLabelEdits((prev) => {
|
|
const presence = (id: string) => {
|
|
const e = allEmails.find((x) => x.id === id)
|
|
if (!e) return false
|
|
return effectiveLabels(e, prev.additions, prev.removals).some(
|
|
(l) => l.toLowerCase() === resolved.toLowerCase()
|
|
)
|
|
}
|
|
const allHave = ids.every((id) => presence(id))
|
|
const nextAdd = { ...prev.additions }
|
|
const nextRem = { ...prev.removals }
|
|
|
|
if (allHave) {
|
|
for (const id of ids) {
|
|
if (nextAdd[id]?.length) {
|
|
const filtered = nextAdd[id].filter(
|
|
(l) => l.toLowerCase() !== resolved.toLowerCase()
|
|
)
|
|
if (filtered.length) nextAdd[id] = filtered
|
|
else delete nextAdd[id]
|
|
}
|
|
const e = allEmails.find((x) => x.id === id)
|
|
if (!e) continue
|
|
const still = effectiveLabels(e, nextAdd, nextRem).some(
|
|
(l) => l.toLowerCase() === resolved.toLowerCase()
|
|
)
|
|
if (still) {
|
|
const cur = nextRem[id] ?? []
|
|
if (!cur.some((l) => l.toLowerCase() === resolved.toLowerCase())) {
|
|
nextRem[id] = [...cur, resolved]
|
|
}
|
|
} else if (nextRem[id]?.length) {
|
|
const fr = nextRem[id].filter(
|
|
(l) => l.toLowerCase() !== resolved.toLowerCase()
|
|
)
|
|
if (fr.length) nextRem[id] = fr
|
|
else delete nextRem[id]
|
|
}
|
|
}
|
|
} else {
|
|
const anyMissing = ids.some((id) => !presence(id))
|
|
if (anyMissing) {
|
|
queueMicrotask(() => sidebarNav.ensureLabelRowForLabelText(resolved))
|
|
}
|
|
for (const id of ids) {
|
|
const e = allEmails.find((x) => x.id === id)
|
|
if (!e) continue
|
|
const had = effectiveLabels(e, prev.additions, prev.removals).some(
|
|
(l) => l.toLowerCase() === resolved.toLowerCase()
|
|
)
|
|
if (nextRem[id]?.length) {
|
|
const fr = nextRem[id].filter(
|
|
(l) => l.toLowerCase() !== resolved.toLowerCase()
|
|
)
|
|
if (fr.length) nextRem[id] = fr
|
|
else delete nextRem[id]
|
|
}
|
|
if (!had) {
|
|
if (!nextAdd[id]) nextAdd[id] = []
|
|
if (!nextAdd[id].some((l) => l.toLowerCase() === resolved.toLowerCase())) {
|
|
nextAdd[id] = [...nextAdd[id], resolved]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return { additions: nextAdd, removals: nextRem }
|
|
})
|
|
},
|
|
[allEmails, resolveLabelCasing, sidebarNav, setLabelEdits]
|
|
)
|
|
|
|
return {
|
|
collectAllFolderLabels,
|
|
moveEmailsToTarget,
|
|
catalogLabels,
|
|
resolveLabelVisual,
|
|
resolveLabelCasing,
|
|
addLabelToEmails,
|
|
toggleLabelOnEmails,
|
|
getCatalogLabelPresence,
|
|
}
|
|
}
|
|
|
|
export type EmailListLabels = ReturnType<typeof useEmailListLabels>
|