kongdeqiang
2026-10-12 285bf234bd50ce54fcae7bb777f8fa579b91266e
fix: 新增分组
7个文件已添加
926 ■■■■■ 已修改文件
src/api/chatGroupApi.js 33 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/components/ArchivedChatDrawer.vue 295 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/components/ChatListItem.vue 223 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/utils/chatTime.js 126 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/utils/download.js 62 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/utils/sidebarGroups.js 76 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/utils/uiPrefs.js 111 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/api/chatGroupApi.js
New file
@@ -0,0 +1,33 @@
import http from './axios'
/**
 * 对话分组(用户自建的文件夹)。
 *
 * 与「今天 / 昨天 / 更早」的时间分组无关:那是前端按时间算出来的视图归类,
 * 这里是存在数据库里、用户可以命名和增删的实体。
 */
/** 当前用户的全部分组(含每个分组的会话数) */
export function listChatGroups() {
  return http.get('/chat-groups')
}
/** 新建分组 */
export function createChatGroup(name) {
  return http.post('/chat-groups', { name })
}
/** 重命名分组 */
export function renameChatGroup(groupId, name) {
  return http.put(`/chat-groups/${groupId}`, { name })
}
/**
 * 删除分组。
 *
 * 只解除分组关系,**不会删除组内会话** —— 它们会回到「未分组」。
 * 返回值里带 movedChats(被移出的会话数),用于给用户一句明确的提示。
 */
export function deleteChatGroup(groupId) {
  return http.delete(`/chat-groups/${groupId}`)
}
src/components/ArchivedChatDrawer.vue
New file
@@ -0,0 +1,295 @@
<template>
  <n-drawer v-model:show="visible" :width="460" placement="right">
    <n-drawer-content closable>
      <template #header>
        <div class="drawer-header">
          <span>归档对话</span>
          <span class="drawer-count">{{ total }} 个</span>
        </div>
      </template>
      <div class="archive-search">
        <n-input
          v-model:value="keyword"
          size="small"
          clearable
          placeholder="在归档的对话里搜索"
          @input="handleInput"
        />
      </div>
      <n-spin v-if="loading || searching" size="small" class="archive-loading" />
      <div v-else-if="visibleChats.length === 0" class="empty-hint archive-empty">
        <template v-if="isSearching">
          没有找到匹配「{{ keyword }}」的归档对话
        </template>
        <template v-else>
          还没有归档的对话<br />
          在对话的「⋯」菜单里选「归档」,聊完的对话就会收进这里
        </template>
      </div>
      <div
        v-for="chat in visibleChats"
        v-else
        :key="chat.id"
        class="archive-item"
        :class="{ active: chat.id === activeChatId }"
        @click="$emit('select', chat.id)"
      >
        <div class="archive-item-main">
          <div class="archive-title">{{ chat.title || '新对话' }}</div>
          <div v-if="chat.matchSnippet" class="archive-snippet">{{ chat.matchSnippet }}</div>
          <div class="archive-meta">
            <span>归档于 {{ relative(chat.archivedAt) }}</span>
            <span class="dot">·</span>
            <span>{{ chat.messageCount || 0 }} 条消息</span>
          </div>
        </div>
        <div class="archive-actions" @click.stop>
          <n-button text size="tiny" @click="restore(chat)">恢复</n-button>
          <n-dropdown
            trigger="click"
            :options="downloadOptions"
            placement="bottom-end"
            @select="(key) => download(chat, key)"
          >
            <n-button text size="tiny">下载</n-button>
          </n-dropdown>
          <n-button text size="tiny" class="danger" @click="confirmDelete(chat)">删除</n-button>
        </div>
      </div>
    </n-drawer-content>
  </n-drawer>
</template>
<script setup>
import { computed, ref, watch } from 'vue'
import {
  NButton,
  NDrawer,
  NDrawerContent,
  NDropdown,
  NInput,
  NSpin,
  useDialog,
  useMessage
} from 'naive-ui'
import { useChatStore } from '@/stores/chatStore'
import { formatRelative } from '@/utils/chatTime'
const props = defineProps({
  show: { type: Boolean, default: false }
})
const emit = defineEmits(['update:show', 'select'])
const chatStore = useChatStore()
const message = useMessage()
const dialog = useDialog()
const loading = ref(false)
const keyword = ref('')
/** 抽屉开关:本地代理 v-model:show */
const visible = computed({
  get: () => props.show,
  set: (value) => emit('update:show', value)
})
const activeChatId = computed(() => chatStore.activeChatId)
const total = computed(() => chatStore.archivedChats.length)
const isSearching = computed(() => keyword.value.trim().length > 0)
const searching = computed(() => chatStore.archiveSearching)
/**
 * 归档列表的加载时机。
 *
 * 抽屉每次打开都重新拉一次,而不是依赖挂载时的一次加载:
 * 归档动作可能发生在这个组件之外(侧边栏菜单),
 * 每次打开都刷新是最省心也最不容易出现「归档了但列表里没有」的做法。
 */
watch(visible, async (open) => {
  if (!open) return
  keyword.value = ''
  chatStore.clearArchiveSearch()
  loading.value = true
  try {
    await chatStore.loadArchivedChats()
  } catch (error) {
    message.error(error.message || '加载归档对话失败')
  } finally {
    loading.value = false
  }
})
/** 搜索态显示结果,否则显示全部归档会话 */
const visibleChats = computed(() =>
  isSearching.value ? chatStore.archiveResults : chatStore.archivedChats
)
let timer = null
function handleInput() {
  if (timer) clearTimeout(timer)
  const value = keyword.value
  if (!value.trim()) {
    chatStore.clearArchiveSearch()
    return
  }
  timer = setTimeout(async () => {
    try {
      await chatStore.searchArchive(value)
    } catch (error) {
      message.error(error.message || '搜索失败')
    }
  }, 250)
}
function relative(value) {
  return formatRelative(value)
}
const downloadOptions = [
  { label: 'JSON(含全部分支)', key: 'json' },
  { label: 'TXT(纯文本)', key: 'txt' },
  { label: 'PDF(带页码排版)', key: 'pdf' }
]
async function restore(chat) {
  try {
    await chatStore.setArchived(chat.id, false)
    message.success('已恢复到对话列表')
  } catch (error) {
    message.error(error.message || '恢复失败')
  }
}
async function download(chat, format) {
  try {
    const filename = await chatStore.exportChat(chat.id, format)
    message.success(`已导出 ${filename}`)
  } catch (error) {
    message.error(error.message || '导出失败')
  }
}
function confirmDelete(chat) {
  dialog.warning({
    title: '删除对话',
    content: `确定删除「${chat.title || '新对话'}」吗?归档只是收起,删除是**不可恢复**的,`
      + '该会话的所有消息都会被一并删除。',
    positiveText: '删除',
    negativeText: '取消',
    onPositiveClick: async () => {
      try {
        await chatStore.removeChat(chat.id)
        message.success('已删除')
      } catch (error) {
        message.error(error.message || '删除失败')
        return false
      }
      return true
    }
  })
}
</script>
<style scoped>
.drawer-header {
  display: flex;
  align-items: baseline;
  gap: 8px;
}
.drawer-count {
  font-size: 12px;
  color: var(--text-muted);
  font-weight: 400;
}
.archive-search {
  margin-bottom: 10px;
}
.archive-loading {
  display: flex;
  justify-content: center;
  padding: 24px 0;
}
.archive-empty {
  padding: 32px 8px;
  line-height: 1.9;
  text-align: center;
}
.archive-item {
  display: flex;
  align-items: center;
  gap: 10px;
  padding: 10px;
  border-radius: 8px;
  cursor: pointer;
  border: 1px solid transparent;
}
.archive-item:hover {
  background: var(--bg-hover);
}
.archive-item.active {
  background: #eef2f7;
  border-color: #cbd5e1;
}
.archive-item-main {
  flex: 1;
  min-width: 0;
}
.archive-title {
  font-size: 13.5px;
  font-weight: 500;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}
.archive-snippet {
  font-size: 11.5px;
  color: var(--text-secondary);
  margin-top: 3px;
  display: -webkit-box;
  -webkit-line-clamp: 2;
  -webkit-box-orient: vertical;
  overflow: hidden;
}
.archive-meta {
  font-size: 11.5px;
  color: var(--text-muted);
  margin-top: 3px;
}
.dot {
  margin: 0 4px;
}
.archive-actions {
  display: flex;
  align-items: center;
  gap: 6px;
  flex-shrink: 0;
  opacity: 0;
  transition: opacity 0.12s ease;
}
.archive-item:hover .archive-actions {
  opacity: 1;
}
.danger {
  color: #d03050;
}
</style>
src/components/ChatListItem.vue
New file
@@ -0,0 +1,223 @@
<template>
  <div
    class="chat-item"
    :class="{ active: active, indented: indented }"
    :title="fullTime(chat.updatedAt)"
    @click="$emit('select', chat.id)"
  >
    <div class="chat-item-main">
      <!-- 双击进入就地重命名,符合桌面端文件管理的直觉 -->
      <n-input
        v-if="editing"
        ref="renameInputRef"
        v-model:value="editingTitle"
        size="tiny"
        @blur="commitRename"
        @keyup.enter="commitRename"
        @keyup.esc="cancelRename"
        @click.stop
      />
      <div v-else class="chat-title" @dblclick.stop="startRename">
        <span v-if="chat.pinned" class="pin-icon" title="已置顶">📌</span>
        {{ chat.title || '新对话' }}
      </div>
      <!-- 命中消息内容时展示片段(搜索结果用),方便确认是不是这次对话 -->
      <div v-if="chat.matchSnippet" class="chat-snippet">{{ chat.matchSnippet }}</div>
      <div class="chat-meta">
        <span class="chat-date">{{ time(chat.updatedAt) }}</span>
        <span class="chat-dot">·</span>
        <span>{{ chat.messageCount || 0 }} 条消息</span>
        <span v-if="chat.collectionNames?.length" class="chat-rag-tag">
          · {{ chat.collectionNames.length }} 个知识库
        </span>
        <span v-if="chat.matchType" class="match-badge">{{ matchLabel }}</span>
      </div>
    </div>
    <n-dropdown
      trigger="click"
      :options="options"
      placement="bottom-end"
      @select="(key) => $emit('menu', key, chat)"
    >
      <n-button text class="chat-more" @click.stop>⋯</n-button>
    </n-dropdown>
  </div>
</template>
<script setup>
import { computed, nextTick, ref } from 'vue'
import { NButton, NDropdown, NInput, useMessage } from 'naive-ui'
import { useChatStore } from '@/stores/chatStore'
import { formatChatTime, formatFullTime } from '@/utils/chatTime'
/**
 * 侧边栏里的一条会话。
 *
 * 抽成组件是因为同一个条目现在要出现在三个地方:搜索结果、时间分组、
 * 自定义分组。复制三份模板意味着以后改一处样式要记得改三处
 * (这个项目的图片显示 bug 就是这么来的)。
 */
const props = defineProps({
  chat: { type: Object, required: true },
  active: { type: Boolean, default: false },
  /** 分组内的条目缩进一层,体现层级 */
  indented: { type: Boolean, default: false },
  /** 菜单项由父组件提供:不同位置(搜索态/分组内)可用操作不同 */
  options: { type: Array, required: true }
})
const emit = defineEmits(['select', 'menu'])
const chatStore = useChatStore()
const toast = useMessage()
// 就地重命名:条目自己管理编辑态,父组件不必为「哪一条在编辑」维护状态
const editing = ref(false)
const editingTitle = ref('')
const renameInputRef = ref(null)
function time(value) {
  return formatChatTime(value)
}
function fullTime(value) {
  return formatFullTime(value)
}
const matchLabel = computed(() => {
  const type = props.chat.matchType
  if (type === 'title') return '标题命中'
  if (type === 'both') return '标题+内容'
  return '内容命中'
})
function startRename() {
  if (editing.value) return
  editing.value = true
  editingTitle.value = props.chat.title || ''
  nextTick(() => renameInputRef.value?.focus?.())
}
function cancelRename() {
  editing.value = false
  editingTitle.value = ''
}
async function commitRename() {
  const title = editingTitle.value.trim()
  // 没改动或为空则放弃,避免产生空标题
  if (!title || title === props.chat.title) {
    cancelRename()
    return
  }
  try {
    await chatStore.renameChat(props.chat.id, title)
    toast.success('已重命名')
  } catch (error) {
    toast.error(error.message || '重命名失败')
  } finally {
    cancelRename()
  }
}
defineExpose({ startRename })
</script>
<style scoped>
.chat-item {
  display: flex;
  align-items: center;
  gap: 4px;
  padding: 9px 10px;
  border-radius: 8px;
  cursor: pointer;
  margin-bottom: 2px;
  transition: background 0.12s ease;
}
.chat-item:hover {
  background: var(--bg-hover);
}
.chat-item.active {
  background: #e3e5e8;
}
/* 分组内的条目缩进,体现「它在这个文件夹里」 */
.chat-item.indented {
  padding-left: 20px;
}
.chat-item-main {
  flex: 1;
  min-width: 0;
}
.chat-title {
  font-size: 13.5px;
  font-weight: 500;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}
.pin-icon {
  font-size: 11px;
  margin-right: 2px;
}
.chat-snippet {
  font-size: 11.5px;
  color: var(--text-secondary);
  margin-top: 3px;
  display: -webkit-box;
  -webkit-line-clamp: 2;
  -webkit-box-orient: vertical;
  overflow: hidden;
  line-height: 1.5;
}
.chat-meta {
  font-size: 11.5px;
  color: var(--text-muted);
  margin-top: 3px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}
.chat-date {
  /* 等宽数字:多行日期在视觉上对齐,扫视时不会参差 */
  font-variant-numeric: tabular-nums;
}
.chat-dot {
  margin: 0 4px;
}
.chat-rag-tag {
  color: #6b7280;
}
.match-badge {
  color: #0f766e;
  margin-left: 6px;
}
.chat-more {
  opacity: 0;
  font-size: 16px;
  line-height: 1;
  padding: 0 4px;
  color: var(--text-secondary);
  transition: opacity 0.12s ease;
}
.chat-item:hover .chat-more,
.chat-item.active .chat-more {
  opacity: 1;
}
</style>
src/utils/chatTime.js
New file
@@ -0,0 +1,126 @@
/**
 * 会话列表的时间处理与分组。
 *
 * 「今天 / 昨天 / 更早」这三个分组的判定看起来简单,但有几个必须处理好的点:
 *
 *   1. **按本地日历日比较,不是按 24 小时差**
 *      凌晨 1 点看到「昨天 23:00 的对话」,如果按「相差不到 24 小时」算,
 *      它会被归到「今天」,与用户的直觉不符。
 *   2. **时间是 ISO 字符串且不带时区**
 *      后端返回的是 LocalDateTime(如 2026-10-09T10:32:24),
 *      `new Date('2026-10-09T10:32:24')` 在浏览器里按**本地时区**解析,
 *      行为正好符合预期;但如果哪天后端改成带 Z 的格式,
 *      这里的比较逻辑需要跟着调整(所以集中在本文件里处理)。
 *   3. **置顶会话单独成组**
 *      它们已经按「置顶先后」排好序,再做时间分组反而会把顺序打乱。
 */
const DAY_MS = 24 * 60 * 60 * 1000
/** 解析后端时间;无法解析时返回 null,由调用方兜底 */
export function parseTime(value) {
  if (!value) return null
  if (value instanceof Date) return value
  const date = new Date(value)
  return Number.isNaN(date.getTime()) ? null : date
}
function startOfDay(date) {
  return new Date(date.getFullYear(), date.getMonth(), date.getDate())
}
/**
 * 相差几个「日历日」。
 * 0=今天,1=昨天,2=前天…… 只按日期算,忽略具体时刻。
 */
export function daysAgo(date, now = new Date()) {
  if (!date) return Number.MAX_SAFE_INTEGER
  const diff = startOfDay(now).getTime() - startOfDay(date).getTime()
  return Math.round(diff / DAY_MS)
}
function pad(n) {
  return String(n).padStart(2, '0')
}
/**
 * 列表项上显示的日期文本 —— 用户明确要求「列表里要能看到日期」,
 * 所以这里始终带上日期,而不是只给一个 HH:mm。
 *
 *   今天   → 今天 10:32
 *   昨天   → 昨天 10:32
 *   今年   → 10-09 10:32
 *   往年   → 2025-10-09 10:32
 */
export function formatChatTime(value, now = new Date()) {
  const date = parseTime(value)
  if (!date) return ''
  const time = `${pad(date.getHours())}:${pad(date.getMinutes())}`
  const ago = daysAgo(date, now)
  if (ago === 0) return `今天 ${time}`
  if (ago === 1) return `昨天 ${time}`
  if (date.getFullYear() === now.getFullYear()) {
    return `${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${time}`
  }
  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${time}`
}
/** 完整时间,用于 hover 提示 */
export function formatFullTime(value) {
  const date = parseTime(value)
  if (!date) return ''
  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
    `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
}
/** 相对时间,用于归档列表这类不强调精确时刻的地方 */
export function formatRelative(value, now = new Date()) {
  const date = parseTime(value)
  if (!date) return ''
  const ago = daysAgo(date, now)
  if (ago === 0) return '今天'
  if (ago === 1) return '昨天'
  if (ago < 30) return `${ago} 天前`
  if (date.getFullYear() === now.getFullYear()) {
    return `${date.getMonth() + 1} 月 ${date.getDate()} 日`
  }
  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
}
/**
 * 把会话列表按「置顶 / 今天 / 昨天 / 更早」分组。
 *
 * @param {Array} chats 后端已排好序的列表(置顶在前,其余按最近活跃倒序)
 * @returns {Array<{key:string,label:string,chats:Array}>} 只返回非空分组
 *
 * 注意:组内顺序**完全沿用后端顺序**,这里只做分桶,不排序。
 */
export function groupChats(chats, now = new Date()) {
  const list = Array.isArray(chats) ? chats : []
  const pinned = []
  const today = []
  const yesterday = []
  const earlier = []
  for (const chat of list) {
    if (chat.pinned) {
      pinned.push(chat)
      continue
    }
    // 分组依据用「最近活跃时间」:用户对「这段对话是什么时候的」的记忆
    // 通常来自最后一次交谈,而不是创建时间
    const ago = daysAgo(parseTime(chat.updatedAt || chat.createdAt), now)
    if (ago <= 0) today.push(chat)
    else if (ago === 1) yesterday.push(chat)
    else earlier.push(chat)
  }
  const groups = []
  if (pinned.length) groups.push({ key: 'pinned', label: '置顶', chats: pinned })
  if (today.length) groups.push({ key: 'today', label: '今天', chats: today })
  if (yesterday.length) groups.push({ key: 'yesterday', label: '昨天', chats: yesterday })
  if (earlier.length) groups.push({ key: 'earlier', label: '更早', chats: earlier })
  return groups
}
src/utils/download.js
New file
@@ -0,0 +1,62 @@
/**
 * 浏览器端文件下载。
 *
 * 为什么要走 Blob + 临时 <a> 而不是直接 `location.href = url`:
 *   导出接口需要 `Authorization` 头,而浏览器直接跳转是发不出自定义头的,
 *   结果就是一个 401 的空白页。所以必须先由 axios 带 token 取回字节,
 *   再在内存里造一个对象 URL 交给浏览器保存。
 */
/**
 * 从 Content-Disposition 响应头解析服务端建议的文件名。
 *
 * 服务端按 RFC 5987 同时给了两个:
 *   attachment; filename="export.pdf"; filename*=UTF-8''%E4%B8%AD%E6%96%87.pdf
 * 中文名只能从 filename* 里取(filename 那个是 ASCII 兜底)。
 *
 * @returns {string|null} 解析不出来时返回 null,由调用方用默认名兜底
 */
export function filenameFromDisposition(disposition) {
  if (!disposition) return null
  // 优先 filename*(带字符集与百分号编码)
  const star = /filename\*\s*=\s*([^;]+)/i.exec(disposition)
  if (star) {
    let value = star[1].trim().replace(/^["']|["']$/g, '')
    const parts = value.split("''")
    if (parts.length === 2) {
      value = parts[1]
    }
    try {
      return decodeURIComponent(value)
    } catch {
      // 编码异常时退回下面的普通 filename
    }
  }
  const plain = /filename\s*=\s*"?([^";]+)"?/i.exec(disposition)
  if (plain) {
    return plain[1].trim()
  }
  return null
}
/**
 * 触发浏览器保存一个 Blob。
 *
 * 必须 revokeObjectURL:不释放的话,每下载一次就在内存里留一份
 * 完整文件的副本,直到页面关闭 —— 下载几个大 PDF 就会明显吃内存。
 */
export function saveBlob(blob, filename) {
  const url = URL.createObjectURL(blob)
  const a = document.createElement('a')
  a.href = url
  a.download = filename || 'download'
  a.style.display = 'none'
  document.body.appendChild(a)
  a.click()
  document.body.removeChild(a)
  // 交给浏览器一点时间开始下载,再释放
  setTimeout(() => URL.revokeObjectURL(url), 1000)
}
src/utils/sidebarGroups.js
New file
@@ -0,0 +1,76 @@
import { daysAgo, parseTime } from './chatTime'
/**
 * 把会话列表编排成侧边栏要显示的结构。
 *
 * 三条规则,顺序也是优先级:
 *
 *   1. **置顶且未分组** → 进「置顶」区(固定在列表最上方)
 *   2. **有分组**       → 进它自己的分组(哪怕它还置顶着 —— 用户既然把它
 *                        放进了文件夹,就不该再把它从文件夹里抽走;
 *                        置顶在这里体现为「排在该分组最前 + 带图钉」)
 *   3. **其余**         → 按今天 / 昨天 / 更早自动归类
 *
 * 也就是说自定义分组与时间分组是**互斥**的:进了文件夹就不再出现在
 * 时间分组里,避免同一条对话在侧边栏出现两次(点哪个都会打开同一条,
 * 但用户会以为有两份)。
 *
 * 组内顺序直接沿用后端返回的顺序(后端已按 pinned / pinned_at / updated_at
 * 排好),这里只做分桶,不重排 —— 否则「前端排一遍、后端排一遍」
 * 迟早会出现两边不一致,刷新一次顺序又跳回去。
 *
 * @param {Array} chats 后端返回的会话列表(已排序)
 * @param {Array} groups 后端返回的分组列表(已按创建顺序)
 * @param {Date} now 注入当前时间,便于测试
 */
export function buildSidebarSections(chats, groups, now = new Date()) {
  const list = Array.isArray(chats) ? chats : []
  const groupList = Array.isArray(groups) ? groups : []
  const pinned = []
  const buckets = new Map()
  const today = []
  const yesterday = []
  const earlier = []
  for (const group of groupList) {
    buckets.set(group.id, [])
  }
  for (const chat of list) {
    // 分组可能已被删除而会话还残留 group_id(并发/异常数据):
    // 这时按「未分组」处理,宁可让它落到时间分组里,也不要它凭空消失
    const bucket = chat.groupId != null ? buckets.get(chat.groupId) : undefined
    if (bucket) {
      bucket.push(chat)
      continue
    }
    if (chat.pinned) {
      pinned.push(chat)
      continue
    }
    const ago = daysAgo(parseTime(chat.updatedAt || chat.createdAt), now)
    if (ago <= 0) today.push(chat)
    else if (ago === 1) yesterday.push(chat)
    else earlier.push(chat)
  }
  const timeGroups = []
  if (today.length) timeGroups.push({ key: 'today', label: '今天', chats: today })
  if (yesterday.length) timeGroups.push({ key: 'yesterday', label: '昨天', chats: yesterday })
  if (earlier.length) timeGroups.push({ key: 'earlier', label: '更早', chats: earlier })
  return {
    pinned,
    // 空分组也要保留:用户刚建好还没放东西的文件夹应该看得见,
    // 否则「我明明建了分组,怎么没了」
    groups: groupList.map((group) => ({
      id: group.id,
      name: group.name,
      chats: buckets.get(group.id) || []
    })),
    timeGroups
  }
}
src/utils/uiPrefs.js
New file
@@ -0,0 +1,111 @@
import { ref, watch } from 'vue'
/**
 * 折叠状态这类**纯视图偏好**的读写。
 *
 * 为什么不存到数据库:点一下折叠就发一个写请求,既没必要也容易失败
 * (网络抖一下折叠状态就和眼睛看到的不一致了)。这类状态属于「这台机器的
 * 这个浏览器窗口」,放 localStorage 正好,刷新后仍然保持。
 *
 * key 里会带上用户 id:同一台机器上换账号登录时,两个用户的分组折叠状态
 * 不该互相影响。
 */
const PREFIX = 'webui_ui_'
function storageKey(key) {
  // 从 localStorage 里已保存的用户信息取 id 做后缀。
  // 不 import authStore:那会形成 utils → store 的反向依赖,
  // 而这里只需要一个稳定的标识符。
  let who = 'anon'
  try {
    const raw = localStorage.getItem('webui_user')
    if (raw) {
      const user = JSON.parse(raw)
      who = user?.id ?? user?.username ?? 'anon'
    }
  } catch {
    // 解析失败就用 anon,不影响功能
  }
  return `${PREFIX}${who}_${key}`
}
/**
 * 一个会持久化到 localStorage 的布尔开关。
 *
 * @param {string} key 状态名(会自动加上用户前缀)
 * @param {boolean} defaultValue 没有存过时的默认值
 * @returns {{ collapsed: import('vue').Ref<boolean>, toggle: Function, set: Function }}
 */
export function usePersistentFlag(key, defaultValue = false) {
  const storage = storageKey(key)
  let initial = defaultValue
  try {
    const raw = localStorage.getItem(storage)
    if (raw === '1') initial = true
    else if (raw === '0') initial = false
  } catch {
    // 隐私模式下 localStorage 可能不可用,退回默认值即可
  }
  const state = ref(initial)
  watch(state, (value) => {
    try {
      localStorage.setItem(storage, value ? '1' : '0')
    } catch {
      // 存不进去不影响使用,只是刷新后不记得
    }
  })
  return {
    // 字段名就叫 collapsed:之前这里叫 value,调用方按 `{ collapsed }` 解构,
    // 拿到的是 undefined,导致「折叠了但界面没反应」——
    // 名字必须和它的语义一致,别让人猜。
    collapsed: state,
    toggle: () => { state.value = !state.value },
    set: (v) => { state.value = !!v }
  }
}
/**
 * 一组「分组各自的折叠状态」,同样持久化。
 *
 * 存的是一张 map:{ [groupId]: true/false },
 * 默认展开 —— 收藏起来的对话列表默认收起会让人以为分组是空的。
 */
export function usePersistentMap(key) {
  const storage = storageKey(key)
  let initial = {}
  try {
    const raw = localStorage.getItem(storage)
    if (raw) initial = JSON.parse(raw) || {}
  } catch {
    initial = {}
  }
  const state = ref(initial)
  watch(state, (value) => {
    try {
      localStorage.setItem(storage, JSON.stringify(value))
    } catch {
      // 同上,静默忽略
    }
  }, { deep: true })
  return {
    /**
     * 默认**展开**:只有显式存过 true 才算收起。
     *
     * 这里踩过一次自己的坑:一开始把「收起」定义为存 false,
     * 而 toggle 写成 `!(next[id] === false)` —— 缺省值 undefined 会让它算出 true,
     * 也就是「第一次点击反而写入了展开状态」,结果折叠永远不生效。
     * 判定与写入必须严格互逆:存 true = 收起,缺省 = 展开。
     */
    isCollapsed: (id) => state.value[id] === true,
    toggle(id) {
      const next = { ...state.value }
      next[id] = !(next[id] === true)
      state.value = next
    }
  }
}