899 lines
34 KiB
TypeScript
899 lines
34 KiB
TypeScript
type BooleanStorage = Pick<Storage, 'getItem' | 'setItem'>
|
||
type NavigationView = 'tasks' | 'today' | 'upcoming' | 'trash' | 'habits' | 'countdowns' | 'memos' | 'calendar' | 'settings'
|
||
type StoredNavigation = { view: NavigationView; listId: string }
|
||
const NAVIGATION_VIEWS = new Set<NavigationView>(['tasks', 'today', 'upcoming', 'trash', 'habits', 'countdowns', 'memos', 'calendar', 'settings'])
|
||
|
||
export function readStoredNavigation(storage: BooleanStorage, key: string): StoredNavigation {
|
||
try {
|
||
const value = JSON.parse(storage.getItem(key) ?? 'null')
|
||
if (value && NAVIGATION_VIEWS.has(value.view) && typeof value.listId === 'string') {
|
||
return { view: value.view, listId: value.listId }
|
||
}
|
||
} catch { /* storage may be unavailable or invalid */ }
|
||
return { view: defaultView(), listId: '' }
|
||
}
|
||
|
||
export function writeStoredNavigation(storage: BooleanStorage, key: string, view: NavigationView, listId: string) {
|
||
try { storage.setItem(key, JSON.stringify({ view, listId })) } catch { /* storage may be unavailable */ }
|
||
}
|
||
|
||
export function readStoredBoolean(storage: BooleanStorage, key: string, fallback: boolean) {
|
||
try {
|
||
const value = storage.getItem(key)
|
||
if (value === 'true') return true
|
||
if (value === 'false') return false
|
||
} catch { /* storage may be unavailable */ }
|
||
return fallback
|
||
}
|
||
|
||
export function writeStoredBoolean(storage: BooleanStorage, key: string, value: boolean) {
|
||
try { storage.setItem(key, String(value)) } catch { /* storage may be unavailable */ }
|
||
}
|
||
|
||
export function dateKey(date: Date) {
|
||
const y = date.getFullYear()
|
||
const m = `${date.getMonth() + 1}`.padStart(2, '0')
|
||
const d = `${date.getDate()}`.padStart(2, '0')
|
||
return `${y}-${m}-${d}`
|
||
}
|
||
|
||
export function habitWeek(now = new Date()) {
|
||
const monday = new Date(now.getFullYear(), now.getMonth(), now.getDate())
|
||
monday.setDate(monday.getDate() - ((monday.getDay() + 6) % 7))
|
||
return Array.from({ length: 7 }, (_, index) => {
|
||
const date = new Date(monday)
|
||
date.setDate(monday.getDate() + index)
|
||
return date
|
||
})
|
||
}
|
||
|
||
export function mergePage<T>(page: T[] | { items?: T[]; next_cursor?: string | null }) {
|
||
if (Array.isArray(page)) return { items: page, nextCursor: null }
|
||
return { items: page.items ?? [], nextCursor: page.next_cursor ?? null }
|
||
}
|
||
|
||
export function isTaskView(view: string) {
|
||
return view === 'tasks' || view === 'today' || view === 'upcoming'
|
||
}
|
||
|
||
export function defaultView() {
|
||
return 'today' as const
|
||
}
|
||
|
||
export function quickTaskFields(view: string, activeList: string, inboxList: string, now = new Date()) {
|
||
if (view !== 'today') return { list_id: activeList }
|
||
const parts = new Intl.DateTimeFormat('en-CA', {
|
||
timeZone: 'Asia/Shanghai',
|
||
year: 'numeric',
|
||
month: '2-digit',
|
||
day: '2-digit',
|
||
}).formatToParts(now)
|
||
const value = (type: Intl.DateTimeFormatPartTypes) => parts.find((part) => part.type === type)?.value
|
||
return {
|
||
list_id: inboxList,
|
||
due_at: `${value('year')}-${value('month')}-${value('day')}T12:00:00+08:00`,
|
||
}
|
||
}
|
||
|
||
export function isHabitComplete(kind: string | undefined, value: number | boolean | undefined, target = 1) {
|
||
if (kind === 'numeric') return Number(value ?? 0) >= target
|
||
return Boolean(value)
|
||
}
|
||
|
||
export type HabitHistoryLog = { day: string; value: number }
|
||
|
||
export function habitHistoryWindow(toDay: string, size = 90) {
|
||
const [year, month, day] = toDay.split('-').map(Number)
|
||
const to = new Date(year, month - 1, day)
|
||
const from = new Date(to)
|
||
from.setDate(from.getDate() - (size - 1))
|
||
return { from: dateKey(from), to: dateKey(to) }
|
||
}
|
||
|
||
export function dayBefore(day: string) {
|
||
const [year, month, date] = day.split('-').map(Number)
|
||
const value = new Date(year, month - 1, date)
|
||
value.setDate(value.getDate() - 1)
|
||
return dateKey(value)
|
||
}
|
||
|
||
export function mergeHabitHistory(previous: HabitHistoryLog[], incoming: HabitHistoryLog[]) {
|
||
const merged = new Map(previous.map((item) => [item.day, item]))
|
||
for (const item of incoming) merged.set(item.day, { day: item.day, value: Number(item.value) })
|
||
return [...merged.values()].sort((a, b) => b.day.localeCompare(a.day))
|
||
}
|
||
|
||
export function formatHabitHistoryNumber(value: number) {
|
||
return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(6)))
|
||
}
|
||
|
||
type HabitDetailFields = {
|
||
kind?: string
|
||
target?: number
|
||
unit?: string
|
||
archived_at?: string | null
|
||
schedule_type?: 'daily' | 'weekly' | 'monthly' | 'interval'
|
||
weekdays?: number[] | null
|
||
month_days?: number[] | null
|
||
interval_days?: number | null
|
||
}
|
||
|
||
export function formatHabitRecordMode(habit: HabitDetailFields) {
|
||
if (habit.kind !== 'numeric') return '完成 / 未完成'
|
||
const unit = habit.unit ? ` ${habit.unit}` : ''
|
||
return `按数量记录 · 目标 ${formatHabitHistoryNumber(habit.target ?? 1)}${unit}`
|
||
}
|
||
|
||
export function formatHabitSchedule(habit: HabitDetailFields) {
|
||
if (habit.schedule_type === 'weekly') {
|
||
const weekdays = habit.weekdays ?? []
|
||
if (!weekdays.length) return '每周（日期未设置）'
|
||
const labels = ['一', '二', '三', '四', '五', '六', '日']
|
||
return `每${weekdays.map((day) => `周${labels[day] ?? day}`).join('、')}`
|
||
}
|
||
if (habit.schedule_type === 'monthly') {
|
||
const monthDays = habit.month_days ?? []
|
||
return monthDays.length ? `每月 ${monthDays.join('、')} 日` : '每月（日期未设置）'
|
||
}
|
||
if (habit.schedule_type === 'interval') {
|
||
return habit.interval_days ? `每 ${habit.interval_days} 天` : '按间隔（天数未设置）'
|
||
}
|
||
return '每天'
|
||
}
|
||
|
||
export function formatHabitDetailDate(day?: string) {
|
||
if (!day) return '未提供'
|
||
const [year, month, date] = day.split('-').map(Number)
|
||
if (!year || !month || !date) return day
|
||
return `${year}年${month}月${date}日`
|
||
}
|
||
|
||
export function formatHabitDetailProgress(habit: Pick<HabitDetailFields, 'kind' | 'target' | 'unit' | 'archived_at'> & { value?: number | boolean }) {
|
||
if (habit.archived_at) return null
|
||
const target = habit.target ?? 1
|
||
const value = Number(habit.value ?? 0)
|
||
if (habit.kind !== 'numeric') {
|
||
const complete = Boolean(habit.value)
|
||
return { primary: complete ? '已完成' : '未完成', note: complete ? '今日目标已达成' : '今天尚未完成', semantic: complete ? '已完成' : '未完成' }
|
||
}
|
||
const complete = value >= target
|
||
return {
|
||
primary: `${formatHabitHistoryNumber(value)} / ${formatHabitHistoryNumber(target)}`,
|
||
note: complete ? '今日目标已达成' : `今天还差 ${formatHabitHistoryNumber(Math.max(0, target - value))}${habit.unit ? ` ${habit.unit}` : ''}`,
|
||
semantic: complete ? '已达标' : `${Math.round(target > 0 ? value / target * 100 : 0)}%`,
|
||
}
|
||
}
|
||
|
||
type HabitSchedule = {
|
||
kind?: string
|
||
cells?: Array<{ day: string; scheduled?: boolean; paused?: boolean; value?: number | boolean }>
|
||
}
|
||
|
||
export function isHabitScheduledToday(habit: HabitSchedule, day: string) {
|
||
const cell = (habit.cells ?? []).find((item) => item.day === day)
|
||
return Boolean(cell?.scheduled && !cell.paused)
|
||
}
|
||
|
||
export function nextHabitSwipeValue(kind: string | undefined, current: number | boolean | undefined, target = 1) {
|
||
const value = Number(current ?? 0)
|
||
if (kind === 'numeric') return Math.min(value + 1, target)
|
||
return value > 0 ? 0 : 1
|
||
}
|
||
|
||
export function previousHabitSwipeValue(kind: string | undefined, current: number | boolean | undefined) {
|
||
const value = Number(current ?? 0)
|
||
if (kind === 'numeric') return Math.max(0, value - 1)
|
||
return 0
|
||
}
|
||
|
||
export function habitButtonValue(kind: string | undefined, current: number | boolean | undefined, target = 1) {
|
||
if (isHabitComplete(kind, current, target)) return 0
|
||
return nextHabitSwipeValue(kind, current, target)
|
||
}
|
||
|
||
export function habitButtonNotice(kind: string | undefined, previous: number | boolean | undefined, next: number | boolean) {
|
||
if (kind === 'numeric' && Number(previous ?? 0) > 0 && Number(next) === 0) return '今日进度已重置'
|
||
if (kind !== 'numeric' && Number(previous ?? 0) > 0 && Number(next) === 0) return '已取消完成'
|
||
return Number(next) > Number(previous ?? 0) ? '已记录一次 🎉' : '已减少一次'
|
||
}
|
||
|
||
export function numericHabitInputValue(input: number | string | undefined) {
|
||
if (input === undefined || input === '') return null
|
||
const value = Number(input)
|
||
return Number.isFinite(value) && value >= 0 ? value : null
|
||
}
|
||
|
||
export function countdownDayText(days: number) {
|
||
if (days > 0) return `还有 ${days} 天`
|
||
if (days === 0) return '就是今天'
|
||
return `已经 ${Math.abs(days)} 天`
|
||
}
|
||
|
||
export function countdownKindLabel(kind: string) {
|
||
return ({ countdown: '倒数日', anniversary: '纪念日', birthday: '生日' } as Record<string, string>)[kind] ?? '倒数日'
|
||
}
|
||
|
||
export function calendarModeLabel(mode: string) {
|
||
return mode === 'lunar' ? '农历' : '公历'
|
||
}
|
||
|
||
export function shouldToggleRowSwipe(deltaX: number, deltaY: number) {
|
||
return deltaX >= 64 && deltaX > Math.abs(deltaY) * 1.5
|
||
}
|
||
|
||
export function nextTotalAfterLocalTaskAdd(total: number) {
|
||
return Math.max(0, Number(total) || 0) + 1
|
||
}
|
||
|
||
export function nextTotalAfterLocalTaskRemoval(total: number, removed = 1) {
|
||
return Math.max(0, (Number(total) || 0) - Math.max(0, removed))
|
||
}
|
||
|
||
export type TrashMutationResult =
|
||
| { mutated: false; refreshed: false; error: unknown }
|
||
| { mutated: true; refreshed: boolean }
|
||
|
||
export async function performTrashMutation(
|
||
mutate: () => Promise<unknown>,
|
||
reconcileLocal: () => void,
|
||
refresh: () => Promise<boolean>,
|
||
): Promise<TrashMutationResult> {
|
||
try {
|
||
await mutate()
|
||
} catch (error) {
|
||
return { mutated: false, refreshed: false, error }
|
||
}
|
||
reconcileLocal()
|
||
return { mutated: true, refreshed: await refresh() }
|
||
}
|
||
|
||
export function fabBottomReserved(safeAreaBottom = 0, navigationHeight = 56, gap = 12) {
|
||
return navigationHeight + Math.max(0, safeAreaBottom) + gap
|
||
}
|
||
|
||
export function clampFabPosition(x: number, y: number, viewportWidth: number, viewportHeight: number, size = 56, margin = 14, bottomReserved = 84) {
|
||
return {
|
||
x: Math.min(Math.max(x, margin), Math.max(margin, viewportWidth - size - margin)),
|
||
y: Math.min(Math.max(y, margin), Math.max(margin, viewportHeight - size - bottomReserved)),
|
||
}
|
||
}
|
||
|
||
export function snapFabPosition(x: number, y: number, viewportWidth: number, viewportHeight: number, size = 56, margin = 14, bottomReserved = 84) {
|
||
const clamped = clampFabPosition(x, y, viewportWidth, viewportHeight, size, margin, bottomReserved)
|
||
const left = margin
|
||
const right = Math.max(margin, viewportWidth - size - margin)
|
||
const midpoint = viewportWidth / 2
|
||
return { x: clamped.x + size / 2 < midpoint ? left : right, y: clamped.y }
|
||
}
|
||
|
||
export function isFabDrag(deltaX: number, deltaY: number, threshold = 8) {
|
||
return Math.hypot(deltaX, deltaY) >= threshold
|
||
}
|
||
|
||
let habitGridCache: { week: string; habits: unknown[] } | null = null
|
||
let countdownCache: { items: unknown[]; archived: unknown[]; writtenAt: number } | null = null
|
||
let countdownInFlight: Promise<{ items: unknown[]; archived: unknown[] }> | null = null
|
||
let countdownCacheGeneration = 0
|
||
const requestGenerations = new Map<string, number>()
|
||
|
||
export function beginLatestRequest(key: string) {
|
||
const generation = (requestGenerations.get(key) ?? 0) + 1
|
||
requestGenerations.set(key, generation)
|
||
return generation
|
||
}
|
||
|
||
export function isLatestRequest(key: string, generation: number) {
|
||
return requestGenerations.get(key) === generation
|
||
}
|
||
|
||
export type RequestContext = { key: string; generation: number }
|
||
|
||
export function captureRequestContext(key: string): RequestContext {
|
||
return { key, generation: requestGenerations.get(key) ?? 0 }
|
||
}
|
||
|
||
export function commitIfRequestContextCurrent(context: RequestContext, commit: () => void) {
|
||
if (!isLatestRequest(context.key, context.generation)) return false
|
||
commit()
|
||
return true
|
||
}
|
||
|
||
export async function runLatestRequest<T>(
|
||
key: string,
|
||
request: () => Promise<T>,
|
||
callbacks: {
|
||
success: (value: T) => void
|
||
error: (reason: unknown) => void
|
||
finally: () => void
|
||
},
|
||
) {
|
||
const generation = beginLatestRequest(key)
|
||
let committed = false
|
||
try {
|
||
const value = await request()
|
||
if (isLatestRequest(key, generation)) {
|
||
callbacks.success(value)
|
||
committed = true
|
||
}
|
||
} catch (reason) {
|
||
if (isLatestRequest(key, generation)) callbacks.error(reason)
|
||
} finally {
|
||
if (isLatestRequest(key, generation)) callbacks.finally()
|
||
}
|
||
return committed
|
||
}
|
||
|
||
type MutationOwnership = { current: () => boolean }
|
||
|
||
type LatestMutationCallbacks<T> = {
|
||
success?: (value: T, ownership: MutationOwnership) => void | Promise<void>
|
||
error?: (reason: unknown, ownership: MutationOwnership) => void | Promise<void>
|
||
settled?: (result: { ok: true; value: T } | { ok: false; reason: unknown }, ownership: MutationOwnership) => void | Promise<void>
|
||
}
|
||
|
||
export function createKeyedLatestMutationQueue() {
|
||
type Entry = { generation: number; tail: Promise<void> }
|
||
const entries = new Map<string, Entry>()
|
||
|
||
return {
|
||
size: () => entries.size,
|
||
async run<T>(key: string, mutation: () => Promise<T>, callbacks: LatestMutationCallbacks<T> = {}) {
|
||
let entry = entries.get(key)
|
||
if (!entry) {
|
||
entry = { generation: 0, tail: Promise.resolve() }
|
||
entries.set(key, entry)
|
||
}
|
||
const generation = ++entry.generation
|
||
const ownership = { current: () => entries.get(key) === entry && entry.generation === generation }
|
||
const pending = entry.tail.catch(() => undefined).then(mutation)
|
||
const tail = pending.then(() => undefined, () => undefined)
|
||
entry.tail = tail
|
||
try {
|
||
const value = await pending
|
||
await callbacks.settled?.({ ok: true, value }, ownership)
|
||
if (!ownership.current()) return false
|
||
await callbacks.success?.(value, ownership)
|
||
return ownership.current()
|
||
} catch (reason) {
|
||
await callbacks.settled?.({ ok: false, reason }, ownership)
|
||
if (ownership.current()) await callbacks.error?.(reason, ownership)
|
||
return false
|
||
} finally {
|
||
if (entries.get(key) === entry && entry.generation === generation && entry.tail === tail) entries.delete(key)
|
||
}
|
||
},
|
||
}
|
||
}
|
||
|
||
export function createHabitMutationCoordinator<T>() {
|
||
type Entry = { generation: number; tail: Promise<void>; confirmed: T }
|
||
const entries = new Map<string, Entry>()
|
||
|
||
return {
|
||
size: () => entries.size,
|
||
async run(
|
||
key: string,
|
||
previous: T,
|
||
next: T,
|
||
mutation: () => Promise<unknown>,
|
||
callbacks: {
|
||
current?: () => boolean
|
||
reconcile?: (confirmed: T) => void | Promise<void>
|
||
success?: (ownership: MutationOwnership) => void | Promise<void>
|
||
error?: (rollback: T, reason: unknown, ownership: MutationOwnership) => void | Promise<void>
|
||
} = {},
|
||
) {
|
||
let entry = entries.get(key)
|
||
if (!entry) {
|
||
entry = { generation: 0, tail: Promise.resolve(), confirmed: previous }
|
||
entries.set(key, entry)
|
||
}
|
||
const generation = ++entry.generation
|
||
const ownership = {
|
||
current: () => entries.get(key) === entry && entry.generation === generation && callbacks.current?.() !== false,
|
||
}
|
||
const pending = entry.tail.catch(() => undefined).then(mutation)
|
||
const tail = pending.then(() => undefined, () => undefined)
|
||
entry.tail = tail
|
||
let result: { ok: true } | { ok: false; reason: unknown }
|
||
try {
|
||
await pending
|
||
result = { ok: true }
|
||
} catch (reason) {
|
||
result = { ok: false, reason }
|
||
}
|
||
try {
|
||
if (result.ok) {
|
||
entry.confirmed = next
|
||
await callbacks.reconcile?.(entry.confirmed)
|
||
if (!ownership.current()) return false
|
||
await callbacks.success?.(ownership)
|
||
return ownership.current()
|
||
}
|
||
await callbacks.reconcile?.(entry.confirmed)
|
||
if (ownership.current()) await callbacks.error?.(entry.confirmed, result.reason, ownership)
|
||
return false
|
||
} finally {
|
||
if (entries.get(key) === entry && entry.generation === generation && entry.tail === tail) entries.delete(key)
|
||
}
|
||
},
|
||
}
|
||
}
|
||
|
||
export function createTaskToggleCoordinator<T extends { completed: boolean; version: number }>() {
|
||
type Entry = { tail: Promise<void>; intendedCompleted: boolean; confirmed: T; generation: number }
|
||
const entries = new Map<string, Entry>()
|
||
|
||
return {
|
||
size: () => entries.size,
|
||
async toggle(
|
||
key: string,
|
||
initial: T,
|
||
mutation: (payload: { completed: boolean; version: number }) => Promise<T>,
|
||
callbacks: {
|
||
current?: () => boolean
|
||
beforeReconcile?: (value: T, ownership: MutationOwnership) => void | Promise<void>
|
||
reconcile?: (confirmed: T, ownership: MutationOwnership) => void | Promise<void>
|
||
success?: (value: T, ownership: MutationOwnership) => void | Promise<void>
|
||
error?: (confirmed: T, reason: unknown, ownership: MutationOwnership) => void | Promise<void>
|
||
} = {},
|
||
) {
|
||
let entry = entries.get(key)
|
||
if (!entry) {
|
||
entry = { tail: Promise.resolve(), intendedCompleted: initial.completed, confirmed: initial, generation: 0 }
|
||
entries.set(key, entry)
|
||
}
|
||
entry.intendedCompleted = !entry.intendedCompleted
|
||
const intendedCompleted = entry.intendedCompleted
|
||
const generation = ++entry.generation
|
||
const ownership = { current: () => entry!.generation === generation && callbacks.current?.() !== false }
|
||
const pending = entry.tail.then(async () => {
|
||
const value = await mutation({ completed: intendedCompleted, version: entry!.confirmed.version })
|
||
entry!.confirmed = value
|
||
return value
|
||
})
|
||
entry.tail = pending.then(() => undefined, () => undefined)
|
||
try {
|
||
let value: T
|
||
try {
|
||
value = await pending
|
||
} catch (reason) {
|
||
await callbacks.reconcile?.(entry.confirmed, ownership)
|
||
if (ownership.current()) await callbacks.error?.(entry.confirmed, reason, ownership)
|
||
return false
|
||
}
|
||
if (ownership.current()) await callbacks.beforeReconcile?.(value, ownership)
|
||
await callbacks.reconcile?.(value, ownership)
|
||
if (!ownership.current()) return false
|
||
await callbacks.success?.(value, ownership)
|
||
return ownership.current()
|
||
} finally {
|
||
if (entry.generation === generation && entries.get(key) === entry) entries.delete(key)
|
||
}
|
||
},
|
||
}
|
||
}
|
||
|
||
type CurrentViewReconciliationOptions<TContext> = {
|
||
capture: () => TContext
|
||
isTaskBacked: (context: TContext) => boolean
|
||
isTrash?: (context: TContext) => boolean
|
||
sameContext: (left: TContext, right: TContext) => boolean
|
||
loadTaskView: (context: TContext, ownership: MutationOwnership) => Promise<void>
|
||
loadTrash?: (ownership: MutationOwnership) => Promise<void>
|
||
affectsTrash?: boolean
|
||
affectsTaskView?: boolean
|
||
}
|
||
|
||
export async function reconcileCurrentTaskView<TContext>(options: CurrentViewReconciliationOptions<TContext>) {
|
||
const context = options.capture()
|
||
const ownership = { current: () => options.sameContext(context, options.capture()) }
|
||
if (options.affectsTaskView !== false && options.isTaskBacked(context)) {
|
||
await options.loadTaskView(context, ownership)
|
||
return ownership.current()
|
||
}
|
||
if (options.affectsTrash && options.isTrash?.(context) && options.loadTrash) {
|
||
await options.loadTrash(ownership)
|
||
return ownership.current()
|
||
}
|
||
return false
|
||
}
|
||
|
||
export function createTaskCompletionExitCoordinator(setExit: (key: string, active: boolean) => void) {
|
||
const tokens = new Map<string, object>()
|
||
|
||
const supersede = (key: string) => {
|
||
tokens.delete(key)
|
||
setExit(key, false)
|
||
}
|
||
|
||
const clearAll = () => {
|
||
const keys = [...tokens.keys()]
|
||
tokens.clear()
|
||
keys.forEach((key) => setExit(key, false))
|
||
}
|
||
|
||
const begin = (key: string, animate: boolean) => {
|
||
tokens.delete(key)
|
||
if (!animate) {
|
||
setExit(key, false)
|
||
return null
|
||
}
|
||
const token = {}
|
||
tokens.set(key, token)
|
||
setExit(key, true)
|
||
return token
|
||
}
|
||
|
||
const wait = async (key: string, token: object | null, waitForExit: () => Promise<void>) => {
|
||
if (!token) return
|
||
try {
|
||
await waitForExit()
|
||
} finally {
|
||
if (tokens.get(key) === token) {
|
||
tokens.delete(key)
|
||
setExit(key, false)
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
size: () => tokens.size,
|
||
supersede,
|
||
clearAll,
|
||
begin,
|
||
wait,
|
||
async run(key: string, animate: boolean, waitForExit: () => Promise<void>) {
|
||
const token = begin(key, animate)
|
||
await wait(key, token, waitForExit)
|
||
},
|
||
}
|
||
}
|
||
|
||
type TaskToggleState = {
|
||
id: string
|
||
list_id: string
|
||
parent_id: string | null
|
||
title: string
|
||
description: string
|
||
priority: number
|
||
completed: boolean
|
||
completed_at: string | null
|
||
version: number
|
||
due_at: string | null
|
||
due_has_time: boolean
|
||
subtasks?: TaskToggleState[]
|
||
}
|
||
|
||
export function taskVersionedPatchPayload<T extends { version: number }, P extends object>(task: T, patch: P): P & { version: number } {
|
||
return { ...patch, version: task.version }
|
||
}
|
||
|
||
export function mergeTaskToggleResponse<T extends TaskToggleState>(draft: T, response: TaskToggleState): T {
|
||
return {
|
||
...response,
|
||
list_id: draft.list_id,
|
||
parent_id: draft.parent_id,
|
||
title: draft.title,
|
||
description: draft.description,
|
||
priority: draft.priority,
|
||
due_at: draft.due_at,
|
||
due_has_time: draft.due_has_time,
|
||
subtasks: draft.subtasks,
|
||
} as T
|
||
}
|
||
|
||
type MutationSuccessCallback<T> = (value: T) => void | Promise<void>
|
||
type MutationReconciliationOptions = { affectsTrash?: boolean; affectsTaskView?: boolean }
|
||
|
||
export type MutationReconciler<TContext> = {
|
||
run<T>(
|
||
mutation: () => Promise<T>,
|
||
onSuccess: (value: T) => void,
|
||
onError?: (reason: unknown) => void,
|
||
onCurrentSuccess?: MutationSuccessCallback<T>,
|
||
reconciliation?: MutationReconciliationOptions,
|
||
): Promise<boolean>
|
||
}
|
||
|
||
export function createMutationReconciler<TContext>(
|
||
currentContext: () => TContext,
|
||
sameContext: (left: TContext, right: TContext) => boolean,
|
||
reconcileCurrentView: (options?: MutationReconciliationOptions) => Promise<unknown>,
|
||
): MutationReconciler<TContext> {
|
||
let dirty = 0
|
||
let reconciled = 0
|
||
let refreshLoop: Promise<void> | null = null
|
||
|
||
const reconcile = (context: TContext, options?: MutationReconciliationOptions) => {
|
||
if (!sameContext(context, currentContext())) return Promise.resolve()
|
||
dirty += 1
|
||
if (!refreshLoop) {
|
||
refreshLoop = (async () => {
|
||
while (reconciled < dirty && sameContext(context, currentContext())) {
|
||
const target = dirty
|
||
await reconcileCurrentView(options)
|
||
if (!sameContext(context, currentContext())) break
|
||
reconciled = target
|
||
}
|
||
})().finally(() => { refreshLoop = null })
|
||
}
|
||
return refreshLoop
|
||
}
|
||
|
||
return {
|
||
async run(mutation, onSuccess, onError, onCurrentSuccess, reconciliation) {
|
||
const context = currentContext()
|
||
let value: Awaited<ReturnType<typeof mutation>>
|
||
try {
|
||
value = await mutation()
|
||
} catch (reason) {
|
||
if (sameContext(context, currentContext())) onError?.(reason)
|
||
return false
|
||
}
|
||
if (sameContext(context, currentContext())) {
|
||
onSuccess(value)
|
||
const currentSuccess = onCurrentSuccess?.(value)
|
||
if (currentSuccess instanceof Promise) await currentSuccess
|
||
} else {
|
||
await reconcileCurrentView(reconciliation)
|
||
return true
|
||
}
|
||
await reconcile(context, reconciliation)
|
||
if (sameContext(context, currentContext()) && reconciled < dirty) await reconcile(context, reconciliation)
|
||
return true
|
||
},
|
||
}
|
||
}
|
||
|
||
export function startPrimaryWithBackground<T>(
|
||
primary: Array<() => Promise<T>>,
|
||
background: () => Promise<unknown>,
|
||
) {
|
||
const pending = primary.map((start) => start())
|
||
void background().catch(() => undefined)
|
||
return Promise.all(pending)
|
||
}
|
||
|
||
export function readHabitGridCache<T>(week: string): T[] | null {
|
||
return habitGridCache?.week === week ? habitGridCache.habits as T[] : null
|
||
}
|
||
|
||
export function writeHabitGridCache<T>(week: string, habits: T[]) {
|
||
habitGridCache = { week, habits }
|
||
}
|
||
|
||
export function invalidateHabitGridCache() {
|
||
habitGridCache = null
|
||
}
|
||
|
||
export async function performHabitRestore(actions: {
|
||
restore: () => Promise<unknown>
|
||
commitRestore: () => void
|
||
refreshGrid: () => Promise<boolean | unknown>
|
||
}) {
|
||
await actions.restore()
|
||
actions.commitRestore()
|
||
try {
|
||
const refreshed = await actions.refreshGrid()
|
||
return { restored: true as const, refreshed: refreshed !== false }
|
||
} catch {
|
||
return { restored: true as const, refreshed: false }
|
||
}
|
||
}
|
||
|
||
export function readCountdownCache<T>() {
|
||
if (!countdownCache) return null
|
||
return { items: countdownCache.items as T[], archived: countdownCache.archived as T[] }
|
||
}
|
||
|
||
export function writeCountdownCache<T>(items: T[], archived: T[], now = Date.now()) {
|
||
countdownCache = { items, archived, writtenAt: now }
|
||
}
|
||
|
||
export function invalidateCountdownCache() {
|
||
countdownCacheGeneration += 1
|
||
countdownCache = null
|
||
countdownInFlight = null
|
||
}
|
||
|
||
export function getCountdownCacheGeneration() {
|
||
return countdownCacheGeneration
|
||
}
|
||
|
||
export function isCountdownCacheGenerationCurrent(generation: number) {
|
||
return generation === countdownCacheGeneration
|
||
}
|
||
|
||
export function loadCountdownCache<T>(
|
||
fetcher: () => Promise<{ items: T[]; archived: T[] }>,
|
||
options: { now?: number; maxAge?: number; force?: boolean } = {},
|
||
) {
|
||
const now = options.now ?? Date.now()
|
||
const maxAge = options.maxAge ?? 30_000
|
||
if (!options.force && countdownCache && now - countdownCache.writtenAt < maxAge) {
|
||
return Promise.resolve(readCountdownCache<T>()!)
|
||
}
|
||
if (countdownInFlight) return countdownInFlight as Promise<{ items: T[]; archived: T[] }>
|
||
const generation = countdownCacheGeneration
|
||
const pending = fetcher().then((data) => {
|
||
if (generation === countdownCacheGeneration) writeCountdownCache(data.items, data.archived, now)
|
||
return data
|
||
}).finally(() => {
|
||
if (countdownInFlight === pending) countdownInFlight = null
|
||
})
|
||
countdownInFlight = pending as Promise<{ items: unknown[]; archived: unknown[] }>
|
||
return pending
|
||
}
|
||
|
||
export type HabitFormValues = {
|
||
name: string
|
||
kind: 'boolean' | 'numeric'
|
||
target: number
|
||
max_value?: number | null
|
||
schedule_type: 'daily' | 'weekly' | 'monthly' | 'interval'
|
||
weekdays?: number[] | null
|
||
month_days?: number[] | null
|
||
interval_days?: number | null
|
||
}
|
||
|
||
export type HabitFormErrors = Partial<Record<keyof HabitFormValues, string>>
|
||
|
||
export function normalizeRequiredName(input: string) {
|
||
const value = input.trim()
|
||
return { value, error: value ? '' : '名称不能为空，请输入至少一个可见字符。' }
|
||
}
|
||
|
||
export function validateHabitForm(form: HabitFormValues): HabitFormErrors {
|
||
const errors: HabitFormErrors = {}
|
||
if (!form.name.trim()) errors.name = '请输入习惯名称'
|
||
if (form.kind === 'numeric') {
|
||
if (!Number.isFinite(Number(form.target)) || Number(form.target) <= 0) errors.target = '目标值必须大于 0'
|
||
if (form.max_value != null && (!Number.isFinite(Number(form.max_value)) || Number(form.max_value) <= 0 || Number(form.max_value) < Number(form.target))) errors.max_value = '最大值不能小于目标值'
|
||
}
|
||
if (form.schedule_type === 'weekly') {
|
||
const values = form.weekdays ?? []
|
||
if (!values.length) errors.weekdays = '至少选择一个星期'
|
||
else if (new Set(values).size !== values.length) errors.weekdays = '星期不能重复'
|
||
}
|
||
if (form.schedule_type === 'monthly') {
|
||
const values = form.month_days ?? []
|
||
if (!values.length || values.some((day) => !Number.isInteger(day) || day < 1 || day > 31)) errors.month_days = '请输入 1 到 31 的日期'
|
||
else if (new Set(values).size !== values.length) errors.month_days = '日期不能重复'
|
||
}
|
||
if (form.schedule_type === 'interval' && (!Number.isInteger(Number(form.interval_days)) || Number(form.interval_days) < 1)) errors.interval_days = '间隔天数至少为 1'
|
||
return errors
|
||
}
|
||
|
||
export function changedHabitFields(before: HabitFormValues, after: HabitFormValues) {
|
||
const result: Partial<HabitFormValues> = {}
|
||
for (const key of Object.keys(after) as Array<keyof HabitFormValues>) {
|
||
const oldValue = before[key]
|
||
const newValue = after[key]
|
||
if (JSON.stringify(oldValue) !== JSON.stringify(newValue)) (result as Record<string, unknown>)[key] = newValue
|
||
}
|
||
return result
|
||
}
|
||
|
||
export function habitActionState(cell?: { scheduled?: boolean; paused?: boolean }, archived = false) {
|
||
if (archived) return { writable: false, reason: '该习惯已归档' }
|
||
if (cell?.paused) return { writable: false, reason: '今天已暂停' }
|
||
if (!cell?.scheduled) return { writable: false, reason: '今天未安排' }
|
||
return { writable: true, reason: '' }
|
||
}
|
||
|
||
export type ArchivePanelState = 'idle' | 'loading' | 'success' | 'error'
|
||
|
||
export function archivePanelFlags(state: ArchivePanelState, count: number) {
|
||
return {
|
||
loading: state === 'loading',
|
||
error: state === 'error',
|
||
empty: state === 'success' && count === 0,
|
||
list: state === 'success' && count > 0,
|
||
}
|
||
}
|
||
|
||
export function formatArchivedAt(value?: string | null, options: { timeZone?: string } = {}) {
|
||
const formatted = formatLocalShortDateTime(value, options)
|
||
return formatted === '未知时间' ? '归档时间未知' : `归档于 ${formatted}`
|
||
}
|
||
|
||
export function formatUserAgent(userAgent?: string | null): string {
|
||
const ua = userAgent?.trim() ?? ''
|
||
let device = '未知设备'
|
||
if (/iPhone/i.test(ua)) device = 'iPhone'
|
||
else if (/iPad/i.test(ua) || (/Macintosh/i.test(ua) && /Mobile/i.test(ua))) device = 'iPad'
|
||
else if (/Android/i.test(ua) && /Mobile/i.test(ua)) device = 'Android 手机'
|
||
else if (/Android/i.test(ua)) device = 'Android 平板'
|
||
else if (/Windows/i.test(ua)) device = 'Windows'
|
||
else if (/Macintosh|Mac OS X/i.test(ua)) device = 'Mac'
|
||
else if (/Linux/i.test(ua)) device = 'Linux'
|
||
|
||
let browser = '未知浏览器'
|
||
if (/Edg(?:e|iOS|A)?\//i.test(ua)) browser = 'Edge'
|
||
else if (/Chrome\/|CriOS\//i.test(ua)) browser = 'Chrome'
|
||
else if (/Firefox\/|FxiOS\//i.test(ua)) browser = 'Firefox'
|
||
else if (/Safari\//i.test(ua) && /Version\//i.test(ua)) browser = 'Safari'
|
||
return `${device} · ${browser}`
|
||
}
|
||
|
||
export function formatLocalShortDateTime(value?: string | null, options: { timeZone?: string } = {}): string {
|
||
const source = value?.trim()
|
||
if (!source) return '未知时间'
|
||
const calendar = /^(\d{4})-(\d{2})-(\d{2})T/.exec(source)
|
||
if (calendar) {
|
||
const [, year, month, day] = calendar
|
||
const probe = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)))
|
||
if (probe.getUTCFullYear() !== Number(year) || probe.getUTCMonth() + 1 !== Number(month) || probe.getUTCDate() !== Number(day)) return '未知时间'
|
||
}
|
||
const timezoneLess = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/i.test(source)
|
||
const date = new Date(timezoneLess ? `${source}Z` : source)
|
||
if (Number.isNaN(date.getTime())) return '未知时间'
|
||
try {
|
||
return new Intl.DateTimeFormat('zh-CN', { dateStyle: 'short', timeStyle: 'short', ...options }).format(date)
|
||
} catch {
|
||
return '未知时间'
|
||
}
|
||
}
|
||
|
||
const AUDIT_ACTIONS: Record<string, string> = {
|
||
create: '创建', update: '更新', complete: '完成', delete: '删除', archive: '归档', restore: '恢复', move: '移动', import: '导入',
|
||
}
|
||
const AUDIT_ENTITIES: Record<string, string> = {
|
||
task: '任务', list: '清单', folder: '文件夹', countdown: '倒数日', backup: '备份',
|
||
}
|
||
|
||
export function formatAuditAction(action?: string | null): string {
|
||
return action ? AUDIT_ACTIONS[action.toLowerCase()] ?? '其他操作' : '其他操作'
|
||
}
|
||
|
||
export function formatAuditEntity(entityType?: string | null): string {
|
||
return entityType ? AUDIT_ENTITIES[entityType.toLowerCase()] ?? '内容' : '内容'
|
||
}
|
||
|
||
export function formatHabitApiError(detail: unknown): string {
|
||
const source = detail && typeof detail === 'object' && !Array.isArray(detail) && 'detail' in detail
|
||
? (detail as Record<string, unknown>).detail
|
||
: detail
|
||
const text = typeof source === 'string' ? source : ''
|
||
const mappings: Array<[string, string]> = [
|
||
['暂停日不可记录正向进度', '今天已暂停，不能记录进度。'],
|
||
['非计划日不可记录正向进度', '今天未安排该习惯，不能记录进度。'],
|
||
['归档习惯不可修改', '该习惯已归档，不能继续操作。'],
|
||
['请先归档再永久删除', '请先归档该习惯，再永久删除。'],
|
||
]
|
||
for (const [needle, message] of mappings) if (text.includes(needle)) return message
|
||
if (Array.isArray(source)) {
|
||
const field = source.map((item) => item && typeof item === 'object' && Array.isArray((item as Record<string, unknown>).loc) ? ((item as Record<string, unknown>).loc as unknown[]).at(-1) : '').find(Boolean)
|
||
const fieldMessages: Record<string, string> = {
|
||
name: '名称不能为空，请输入至少一个可见字符。', weekdays: '每周计划至少选择一天，且不能重复。', month_days: '每月日期必须是 1–31，且不能重复。', interval_days: '间隔天数至少为 1。', target: '目标值必须大于 0。', max_value: '最大值必须大于 0。',
|
||
}
|
||
if (typeof field === 'string' && fieldMessages[field]) return fieldMessages[field]
|
||
}
|
||
return formatApiErrorDetail(source)
|
||
}
|
||
|
||
export function formatApiErrorDetail(detail: unknown): string {
|
||
if (typeof detail === 'string') return detail
|
||
if (Array.isArray(detail)) {
|
||
const messages = detail.map((item) => {
|
||
if (item && typeof item === 'object') {
|
||
const record = item as Record<string, unknown>
|
||
const location = Array.isArray(record.loc)
|
||
? record.loc.filter((part) => part !== 'body').join('.')
|
||
: ''
|
||
const message = typeof record.msg === 'string' ? record.msg : JSON.stringify(record)
|
||
return location ? `${location}：${message}` : message
|
||
}
|
||
return String(item)
|
||
})
|
||
return messages.filter(Boolean).join('；') || '请求参数有误'
|
||
}
|
||
if (detail && typeof detail === 'object') {
|
||
const record = detail as Record<string, unknown>
|
||
if ('detail' in record) return formatApiErrorDetail(record.detail)
|
||
return JSON.stringify(record)
|
||
}
|
||
return '请求失败'
|
||
}
|