@allbluecn/web-app 0.4.21 → 0.5.0

package/src/server/serverFns/story/__tests__/story-groups.test.ts

@@ -84,7 +84,7 @@ describe("listStoriesInGroupFn", () => {
     const arg = mocks.findMany.mock.calls[0][0] as any;
     expect(arg.where.AND).toContainEqual({ state: "todo" });
     expect(arg.where.archived).toBe(false);
-    expect(arg.orderBy).toEqual({ createdAt: "desc" });
+    expect(arg.orderBy).toEqual([{ createdAt: "desc" }, { id: "asc" }]);
     expect(mocks.count).not.toHaveBeenCalled();
   });
 
@@ -222,6 +222,24 @@ describe("listStoryGroupsFn", () => {
     expect(out.groups.find((g) => g.key === "backlog")?.total).toBe(0);
   });
 
+  it("state/priority 组间顺序按枚举序排列（与筛选 pop 一致），不受 DB 返回顺序影响", async () => {
+    mocks.groupBy.mockResolvedValue([
+      { state: "done", _count: { _all: 91 } },
+      { state: "in_progress", _count: { _all: 2 } },
+      { state: "todo", _count: { _all: 1 } },
+    ]);
+    const stateOut = await listStoryGroupsFn({ data: { archived: false, groupBy: "state" } });
+    expect(stateOut.groups.map((g) => g.key)).toEqual(["todo", "in_progress", "done"]);
+
+    mocks.groupBy.mockResolvedValue([
+      { priority: "low", _count: { _all: 4 } },
+      { priority: "urgent", _count: { _all: 2 } },
+      { priority: "medium", _count: { _all: 1 } },
+    ]);
+    const priorityOut = await listStoryGroupsFn({ data: { archived: false, groupBy: "priority" } });
+    expect(priorityOut.groups.map((g) => g.key)).toEqual(["urgent", "medium", "low"]);
+  });
+
   it("labels 分组按 storyLabel.groupBy 聚合并计入 no-labels", async () => {
     mocks.storyLabelGroupBy.mockResolvedValue([
       { labelId: "l1", _count: { _all: 2 } },

package/src/server/serverFns/story/index.ts

@@ -81,10 +81,9 @@ export {
 } from "./story-children";
 
 export {
-  addDependencyFn,
+  addDependenciesFn,
   removeDependencyFn,
   getDependenciesFn,
-  validateDependencyFn,
 } from "./story-dependencies";
 
 export {

package/src/server/serverFns/story/story-dependencies.ts

@@ -20,199 +20,143 @@ import { getRequest } from "@tanstack/react-start/server";
 import { z } from "zod";
 import { prisma } from "@allbluecn/database";
 import { requireAuth } from "@/server/auth-helpers";
-import type { DependencyType } from "@/components/story/types";
+import { STORY_LIST_SELECT, castStoryUsers } from "./types";
+import type { DependencyRow } from "@/components/story/types";
 
-async function hasCycle(sourceId: string, targetId: string): Promise<boolean> {
-  const visited = new Set<string>();
+const edgeTypeSchema = z.enum(["BLOCKS", "STARTS_BEFORE", "FINISHES_BEFORE"]);
 
-  async function dfs(currentId: string): Promise<boolean> {
-    if (visited.has(currentId)) return false;
-    visited.add(currentId);
-
-    const outgoing = await prisma.storyDependency.findMany({
-      where: { sourceId: currentId, type: "BLOCKS" },
-      select: { targetId: true },
-    });
-
-    for (const dep of outgoing) {
-      if (dep.targetId === targetId) return true;
-      if (await dfs(dep.targetId)) return true;
-    }
-
-    return false;
-  }
-
-  return dfs(sourceId);
-}
-
-export const addDependencyFn = createServerFn({ method: "POST" })
+export const addDependenciesFn = createServerFn({ method: "POST" })
   .validator(
     z.object({
-      sourceId: z.string(),
-      targetId: z.string(),
-      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
+      items: z
+        .array(
+          z.object({
+            sourceId: z.string(),
+            targetId: z.string(),
+            type: edgeTypeSchema,
+          }),
+        )
+        .min(1),
     }),
   )
   .handler(async ({ data }) => {
     const request = getRequest();
-    const session = await requireAuth(request);
+    await requireAuth(request);
 
-    const existing = await prisma.storyDependency.findUnique({
-      where: {
-        sourceId_targetId_type: {
-          sourceId: data.sourceId,
-          targetId: data.targetId,
-          type: data.type,
-        },
-      },
+    // 一次性取全部出边（3 类型合并；不按 projectId 裁剪——跨项目边同样参与环判定），
+    // 构建内存邻接表供本批循环的环检测复用，避免 O(items × 可达节点) 次串行 RTT
+    const allEdges = await prisma.storyDependency.findMany({
+      select: { sourceId: true, targetId: true },
     });
-    if (existing) {
-      throw new Error("依赖关系已存在");
+    const adjacency = new Map<string, string[]>();
+    for (const e of allEdges) {
+      const list = adjacency.get(e.sourceId);
+      if (list) list.push(e.targetId);
+      else adjacency.set(e.sourceId, [e.targetId]);
     }
 
-    const dep = await prisma.storyDependency.create({
-      data: {
-        sourceId: data.sourceId,
-        targetId: data.targetId,
-        type: data.type,
-      },
-    });
+    // 环检测：从 fromId 出发沿 source→target 有向边能否到达 toId（纯内存遍历）
+    // batchEdges：本批已插入边（防批内互指环漏检）
+    function reaches(
+      fromId: string,
+      toId: string,
+      batchEdges: Array<{ sourceId: string; targetId: string }>,
+    ): boolean {
+      const visited = new Set<string>();
+      const stack = [fromId];
+      while (stack.length > 0) {
+        const current = stack.pop()!;
+        if (current === toId) return true;
+        if (visited.has(current)) continue;
+        visited.add(current);
+        for (const next of adjacency.get(current) ?? []) {
+          if (!visited.has(next)) stack.push(next);
+        }
+        for (const e of batchEdges) {
+          if (e.sourceId === current && !visited.has(e.targetId)) stack.push(e.targetId);
+        }
+      }
+      return false;
+    }
 
-    return dep;
+    const created: string[] = [];
+    const failed: Array<{ targetId: string; reason: "SELF" | "DUPLICATED" | "CYCLE" }> = [];
+    const batchEdges: Array<{ sourceId: string; targetId: string }> = [];
+
+    for (const item of data.items) {
+      if (item.sourceId === item.targetId) {
+        failed.push({ targetId: item.targetId, reason: "SELF" });
+        continue;
+      }
+      const existing = await prisma.storyDependency.findFirst({
+        where: {
+          OR: [
+            { sourceId: item.sourceId, targetId: item.targetId },
+            { sourceId: item.targetId, targetId: item.sourceId },
+          ],
+        },
+        select: { id: true },
+      });
+      if (existing) {
+        failed.push({ targetId: item.targetId, reason: "DUPLICATED" });
+        continue;
+      }
+      // 插入 (S,T) 后成环 ⇔ 已存在路径 T →…→ S（含本批边）
+      if (reaches(item.targetId, item.sourceId, batchEdges)) {
+        failed.push({ targetId: item.targetId, reason: "CYCLE" });
+        continue;
+      }
+      const dep = await prisma.storyDependency.create({ data: item });
+      created.push(dep.id);
+      batchEdges.push({ sourceId: item.sourceId, targetId: item.targetId });
+    }
+
+    return { created, failed };
   });
 
 export const removeDependencyFn = createServerFn({ method: "POST" })
-  .validator(
-    z.object({
-      sourceId: z.string(),
-      targetId: z.string(),
-      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
-    }),
-  )
+  .validator(z.object({ depId: z.string() }))
   .handler(async ({ data }) => {
     const request = getRequest();
-    const session = await requireAuth(request);
-
-    const dep = await prisma.storyDependency.delete({
-      where: {
-        sourceId_targetId_type: {
-          sourceId: data.sourceId,
-          targetId: data.targetId,
-          type: data.type,
-        },
-      },
-    });
-
-    return dep;
+    await requireAuth(request);
+    return prisma.storyDependency.delete({ where: { id: data.depId } });
   });
 
 export const getDependenciesFn = createServerFn({ method: "GET" })
   .validator(z.object({ storyId: z.string() }))
   .handler(async ({ data }) => {
     const request = getRequest();
-    const session = await requireAuth(request);
+    await requireAuth(request);
 
     const deps = await prisma.storyDependency.findMany({
-      where: {
-        OR: [{ sourceId: data.storyId }, { targetId: data.storyId }],
-      },
-      include: {
-        source: {
-          select: { id: true, name: true, state: true },
-        },
-        target: {
-          select: { id: true, name: true, state: true },
-        },
-      },
+      where: { OR: [{ targetId: data.storyId }, { sourceId: data.storyId }] },
+      select: { id: true, sourceId: true, targetId: true, type: true },
     });
-
-    const grouped = {
-      blocking: deps
-        .filter((d) => d.sourceId === data.storyId && d.type === "BLOCKS")
-        .map((d) => ({
-          id: d.target.id,
-          title: d.target.name,
-          status: d.target.state,
-          type: "blocks" as DependencyType,
-        })),
-      blockedBy: deps
-        .filter((d) => d.targetId === data.storyId && d.type === "BLOCKS")
-        .map((d) => ({
-          id: d.source.id,
-          title: d.source.name,
-          status: d.source.state,
-          type: "blocked_by" as DependencyType,
-        })),
-      relatesTo: deps
-        .filter((d) => d.type === "RELATES_TO")
-        .map((d) => {
-          const isSource = d.sourceId === data.storyId;
-          const other = isSource ? d.target : d.source;
-          return {
-            id: other.id,
-            title: other.name,
-            status: other.state,
-            type: "relates_to" as DependencyType,
-          };
-        }),
-    };
-
-    return grouped;
-  });
-
-export const validateDependencyFn = createServerFn({ method: "POST" })
-  .validator(
-    z.object({
-      sourceId: z.string(),
-      targetId: z.string(),
-      type: z.enum(["BLOCKS", "BLOCKED_BY", "RELATES_TO"]),
-    }),
-  )
-  .handler(async ({ data }) => {
-    const request = getRequest();
-    const session = await requireAuth(request);
-
-    if (data.sourceId === data.targetId) {
-      return { valid: false, reason: "不能创建自我依赖" };
-    }
-
-    if (data.type === "BLOCKS") {
-      const reverse = await prisma.storyDependency.findUnique({
-        where: {
-          sourceId_targetId_type: {
-            sourceId: data.targetId,
-            targetId: data.sourceId,
-            type: "BLOCKS",
-          },
-        },
-      });
-      if (!reverse) {
-        return {
-          valid: false,
-          reason: "blocks 依赖必须成对出现（需要同时创建反向 blocks）",
-        };
-      }
+    if (deps.length === 0) {
+      return { dependsOn: [] as DependencyRow[], dependents: [] as DependencyRow[] };
     }
 
-    const source = await prisma.story.findUnique({
-      where: { id: data.sourceId },
-      select: { parentId: true },
+    const ids = [...new Set(deps.flatMap((d) => [d.sourceId, d.targetId]))];
+    const stories = await prisma.story.findMany({
+      where: { id: { in: ids } },
+      select: STORY_LIST_SELECT,
     });
-    const target = await prisma.story.findUnique({
-      where: { id: data.targetId },
-      select: { parentId: true },
-    });
-
-    if (source?.parentId === data.targetId || target?.parentId === data.sourceId) {
-      return {
-        valid: false,
-        reason: "父子需求之间不能有 blocks/blocked_by 依赖",
-      };
-    }
+    const byId = new Map(stories.map((s) => [s.id, castStoryUsers(s)]));
 
-    if (await hasCycle(data.sourceId, data.targetId)) {
-      return { valid: false, reason: "会形成循环依赖" };
-    }
+    const build = (d: (typeof deps)[number], storyId: string): DependencyRow | null => {
+      const otherId = d.sourceId === storyId ? d.targetId : d.sourceId;
+      const s = byId.get(otherId);
+      return s ? ({ ...s, depId: d.id, depType: d.type } as DependencyRow) : null;
+    };
 
-    return { valid: true };
+    return {
+      dependsOn: deps
+        .filter((d) => d.targetId === data.storyId)
+        .map((d) => build(d, data.storyId))
+        .filter((r): r is DependencyRow => r !== null),
+      dependents: deps
+        .filter((d) => d.sourceId === data.storyId)
+        .map((d) => build(d, data.storyId))
+        .filter((r): r is DependencyRow => r !== null),
+    };
   });

package/src/server/serverFns/story/story-groups.ts

@@ -78,9 +78,11 @@ export const listStoriesInGroupFn = createServerFn({ method: "GET" })
 
     const field = ORDER_FIELD[data.orderBy];
     const dir: "asc" | "desc" = data.orderDir === "asc" ? "asc" : "desc";
-    const orderBy: Prisma.StoryOrderByWithRelationInput = field
+    const primary: Prisma.StoryOrderByWithRelationInput = field
       ? { [field]: dir }
       : { createdAt: dir };
+    // id tiebreaker：主排序键相同的行（同批创建等）顺序必须确定，否则重拉时顺序抖动
+    const orderBy: Prisma.StoryOrderByWithRelationInput[] = [primary, { id: "asc" }];
 
     const items = await prisma.story.findMany({
       where,
@@ -132,9 +134,11 @@ export const listAllGroupsItemsFn = createServerFn({ method: "GET" })
     const base = buildListWhere({ ...data, projectId });
     const field = ORDER_FIELD[data.orderBy];
     const dir: "asc" | "desc" = data.orderDir === "asc" ? "asc" : "desc";
-    const orderBy: Prisma.StoryOrderByWithRelationInput = field
+    const primary: Prisma.StoryOrderByWithRelationInput = field
       ? { [field]: dir }
       : { createdAt: dir };
+    // id tiebreaker：与 listStoriesInGroupFn 保持一致，保证分页跨批次全序稳定
+    const orderBy: Prisma.StoryOrderByWithRelationInput[] = [primary, { id: "asc" }];
 
     const batchTake = data.take * data.groupCount;
     const items = await prisma.story.findMany({
@@ -216,6 +220,19 @@ function deriveGroupKey(groupBy: GroupKey, row: Record<string, unknown>): string
   }
 }
 
+/** 组间显示顺序与筛选 pop 的值顺序一致（state/priority 按枚举序，其余维度保持 DB 返回序；未知 key 排最后） */
+const GROUP_DISPLAY_ORDER: Partial<Record<GroupKey, readonly string[]>> = {
+  state: STORY_STATES.map((s) => s.value),
+  priority: STORY_PRIORITIES.map((p) => p.value),
+};
+
+function sortGroupKeys(groupBy: GroupKey, keys: string[]): string[] {
+  const order = GROUP_DISPLAY_ORDER[groupBy];
+  if (!order) return keys;
+  const rank = new Map(order.map((k, i) => [k, i]));
+  return [...keys].sort((a, b) => (rank.get(a) ?? order.length) - (rank.get(b) ?? order.length));
+}
+
 export const listStoryGroupsFn = createServerFn({ method: "GET" })
   .validator(listGroupsSchema)
   .handler(async ({ data }) => {
@@ -293,6 +310,9 @@ export const listStoryGroupsFn = createServerFn({ method: "GET" })
         if (!keys.includes(k)) keys.push(k);
       }
     }
-    const groups: Array<{ key: string; total: number }> = keys.map((k) => ({ key: k, total: totalMap.get(k) ?? 0 }));
+    const groups: Array<{ key: string; total: number }> = sortGroupKeys(data.groupBy, keys).map((k) => ({
+      key: k,
+      total: totalMap.get(k) ?? 0,
+    }));
     return { groups };
   });

package/src/server/serverFns/story/story-transfer.ts

@@ -349,7 +349,8 @@ const listProjectStoriesSchema = z.object({
   search: z.string().optional(),
   cursor: z.string().optional(),
   excludeStoryId: z.string().optional(),
-  mode: z.enum(["parent", "child"]).default("parent"),
+  excludeIds: z.array(z.string()).optional(),
+  mode: z.enum(["parent", "child", "dependency"]).default("parent"),
   pageSize: z.number().int().min(1).max(50).default(20),
 });
 
@@ -365,16 +366,17 @@ export const listProjectStoriesFn = createServerFn({ method: "GET" })
       if (data.mode === "parent") {
         const descendants = await collectDescendantIds(data.excludeStoryId);
         for (const id of descendants) excludeIds.add(id);
-      } else {
+      } else if (data.mode === "child") {
         const ancestors = await collectAncestorIds(data.excludeStoryId);
         for (const id of ancestors) excludeIds.add(id);
       }
     }
+    for (const id of data.excludeIds ?? []) excludeIds.add(id);
 
     const stories = await prisma.story.findMany({
       where: {
         ...(data.projectId ? { projectId: data.projectId } : {}),
-        parentId: null,
+        ...(data.mode === "dependency" ? {} : { parentId: null }),
         archived: false,
         ...(excludeIds.size > 0
           ? { id: { notIn: Array.from(excludeIds) } }

package/src/server/serverFns/team.ts

@@ -183,7 +183,7 @@ export const clearExpiredInvitationsFn = createServerFn({ method: 'POST' })
     const session = await requireAuth(request)
     const ownerId = session.user!.id!
     const res = await prisma.teamInvitation.deleteMany({
-      where: { ownerId, status: 'expired' },
+      where: { ownerId, status: 'expired', channel: 'email' },
     })
     await auditLog({
       workspaceId: '',
@@ -279,8 +279,9 @@ export const refreshTeamInvitationLinkFn = createServerFn({ method: 'POST' })
         },
         data: { status: 'invalidated', processedAt: new Date() },
       })
-      await tx.teamInvitation.deleteMany({
+      await tx.teamInvitation.updateMany({
         where: { ownerId, channel: 'link', status: { in: ['pending', 'pending_approval'] } },
+        data: { status: 'revoked' },
       })
       return tx.teamInvitation.create({
         data: {
@@ -493,6 +494,54 @@ export const rejectTeamJoinRequestFn = createServerFn({ method: 'POST' })
     return { success: true }
   })
 
+export const deleteTeamInvitationFn = createServerFn({ method: 'POST' })
+  .validator(revokeSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    const ownerId = session.user!.id!
+
+    const invRow = await prisma.teamInvitation.findUnique({ where: { id: data.invitationId } })
+    if (!invRow || invRow.ownerId !== ownerId) throw new Error('邀请不存在')
+    // link 渠道行下挂 joinRequest（级联删除），禁止单独删除
+    if (invRow.channel === 'link') throw new Error('链接邀请记录不可删除')
+
+    await prisma.teamInvitation.delete({ where: { id: invRow.id } })
+
+    await auditLog({
+      workspaceId: '',
+      userId: ownerId,
+      resourceType: 'teamInvitation',
+      resourceId: invRow.id,
+      action: 'team.invite.delete',
+      metadata: { email: invRow.email },
+    })
+    return { success: true }
+  })
+
+export const deleteTeamJoinRequestFn = createServerFn({ method: 'POST' })
+  .validator(joinRequestSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    const session = await requireAuth(request)
+    const ownerId = session.user!.id!
+
+    const reqRow = await prisma.teamJoinRequest.findUnique({ where: { id: data.requestId } })
+    if (!reqRow || reqRow.ownerId !== ownerId) throw new Error('申请不存在')
+
+    await prisma.teamJoinRequest.delete({ where: { id: reqRow.id } })
+
+    await auditLog({
+      workspaceId: '',
+      userId: ownerId,
+      resourceType: 'teamJoinRequest',
+      resourceId: reqRow.id,
+      action: 'team.join.delete',
+      metadata: { email: reqRow.email },
+    })
+    return { success: true }
+  })
+
 export const listTeamUsersFn = createServerFn({ method: 'GET' }).handler(async () => {
   const request = getRequest()
   const session = await requireAuth(request)

package/src/components/knowledge/knowledge-settings-panel.tsx

@@ -1,148 +0,0 @@
-// SPDX-License-Identifier: AGPL-3.0-or-later
-// AllBlue - 理想之海
-// Copyright (C) 2026 AllBlue Contributors
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-import { useState } from 'react'
-import { useNavigate } from '@tanstack/react-router'
-import { Globe, Lock, Trash2 } from 'lucide-react'
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from '@/components/ui/dialog'
-import { Button } from '@/components/ui/button'
-import { Label } from '@/components/ui/label'
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@/components/ui/select'
-import { deleteKnowledgeFn, updateKnowledgeFn } from '@/server/serverFns/knowledge'
-import { useTranslation } from 'react-i18next'
-
-interface KbData {
-  id: string
-  name: string
-  visibility?: string
-}
-
-interface KnowledgeSettingsPanelProps {
-  open: boolean
-  onOpenChange: (open: boolean) => void
-  kb: KbData
-  onUpdate?: () => void
-}
-
-export function KnowledgeSettingsPanel({ open, onOpenChange, kb, onUpdate }: KnowledgeSettingsPanelProps) {
-  const { t } = useTranslation('knowledge')
-  const navigate = useNavigate()
-  const [visibility, setVisibility] = useState((kb as any).visibility || 'private')
-  const [deleting, setDeleting] = useState(false)
-  const [saving, setSaving] = useState(false)
-
-  const handleVisibilityChange = async (value: string) => {
-    const v = value as 'private' | 'team'
-    setVisibility(v)
-    setSaving(true)
-    try {
-      await updateKnowledgeFn({ data: { id: kb.id, visibility: v } })
-      onUpdate?.()
-    } catch (e) {
-      console.error('Update visibility failed:', e instanceof Error ? e.message : String(e))
-    }
-    setSaving(false)
-  }
-
-  const handleDelete = async () => {
-    setDeleting(true)
-    try {
-      await deleteKnowledgeFn({ data: { id: kb.id } })
-      onOpenChange(false)
-      navigate({ to: '/knowledge' })
-    } catch (e) {
-      console.error('Delete failed:', e instanceof Error ? e.message : String(e))
-    }
-    setDeleting(false)
-  }
-
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="sm:max-w-md">
-        <DialogHeader>
-          <DialogTitle>{t('kbSettings.title')}</DialogTitle>
-          <DialogDescription>{t('kbSettings.subtitle', { name: kb.name })}</DialogDescription>
-        </DialogHeader>
-
-        <div className="space-y-6 py-4">
-          <div className="space-y-2">
-            <Label>{t('kbSettings.ownership')}</Label>
-            <Select value={visibility} onValueChange={handleVisibilityChange} disabled={saving}>
-              <SelectTrigger>
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value="private">
-                  <div className="flex items-center gap-2">
-                    <Lock className="size-4" />
-                    {t('kbSettings.private')}
-                  </div>
-                </SelectItem>
-                <SelectItem value="team">
-                  <div className="flex items-center gap-2">
-                    <Globe className="size-4" />
-                    {t('kbSettings.team')}
-                  </div>
-                </SelectItem>
-              </SelectContent>
-            </Select>
-            <p className="text-xs text-muted-foreground">
-              {t('kbSettings.teamHint')}
-            </p>
-          </div>
-
-          <div className="border-t pt-4">
-            <div className="space-y-2">
-              <Label className="text-destructive">{t('kbSettings.danger')}</Label>
-              <p className="text-xs text-muted-foreground">
-                {t('kbSettings.deleteHint')}
-              </p>
-              <Button
-                variant="destructive"
-                size="sm"
-                onClick={handleDelete}
-                disabled={deleting}
-              >
-                <Trash2 className="size-4 mr-1" />
-                {deleting ? t('kbSettings.deleting') : t('kbSettings.delete')}
-              </Button>
-            </div>
-          </div>
-        </div>
-
-        <DialogFooter>
-          <Button variant="outline" onClick={() => onOpenChange(false)}>
-            {t('kbSettings.close')}
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  )
-}