"use client"; import { useEffect, useMemo, useState } from "react"; import { X, Trash2, Pencil, Plus } from "lucide-react"; import { toast } from "sonner"; import { Button } from "@/components/ui/button"; import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, } from "@/components/ui/dropdown-menu"; import { Skeleton } from "@/components/ui/skeleton"; import { RelativeTime } from "@/components/shared/relative-time"; import { MetadataFieldInput } from "@/components/shared/metadata-field-input"; import { useDocument } from "@/hooks/use-document"; import { useUpdateDocument } from "@/hooks/use-update-document"; import { convertMetadataValues, metadataToFormValues, } from "@/lib/metadata-form"; import { DocStatusBadge } from "./doc-status-badge"; import { useI18n } from "@/i18n/i18n-context"; import type { Document, MetadataField, MetadataFieldType, } from "@/types/knowledge-base"; interface DocDetailPanelProps { document: Document | null; knowledgeBaseName: string; metadataFields?: MetadataField[]; subspace?: string; onClose: () => void; onDelete?: (document: Document) => void; } export function DocDetailPanel({ document, knowledgeBaseName, metadataFields, subspace, onClose, onDelete, }: DocDetailPanelProps) { const hasSchema = !!metadataFields && metadataFields.length > 0; // Fetch fresh — listDocuments omits the metadata field, so the document // prop coming from the table never has it. Fall back to the prop for // non-metadata fields while the fetch is in flight. const { data: fresh, isLoading: freshLoading } = useDocument( knowledgeBaseName, document?.docId, { subspace, enabled: !!document }, ); const data = fresh ?? document; return ( <> {document ? ( ) : null} ); } function DetailPanelInner({ data, metadataFields, knowledgeBaseName, subspace, hasSchema, metadataLoading, onClose, onDelete, }: { data: Document | null; metadataFields?: MetadataField[]; knowledgeBaseName: string; subspace?: string; hasSchema: boolean; metadataLoading: boolean; onClose: () => void; onDelete?: (document: Document) => void; }) { const { t } = useI18n(); if (!data) return null; return ( <> {/* 遮罩层 - 点击关闭面板 */}

{t("documents.detail.title")}

{/* 基本信息 */}
{t("documents.detail.subspace")} {data.subspace ? ( {data.subspace} ) : ( — )}
{t("documents.detail.status")}
{data.eTag && }
{/* Metadata */} {hasSchema && metadataFields && ( )} {/* 时间信息 */}

{t("documents.detail.timeInfo")}

{t("documents.detail.createdAt")}
{t("documents.detail.updatedAt")}
{/* 失败详情 */} {data.failedDetails && (

{t("documents.detail.failedDetails")}

{data.failedDetails}

)} {/* 删除按钮 */}
); } // --------------------------------------------------------------------------- // Metadata section — schema-driven display // --------------------------------------------------------------------------- type TypePalette = { /** Tag background + text classes */ badge: string; /** Vertical accent bar color (left side of each row) */ bar: string; }; function getTypePalette(type: MetadataFieldType): TypePalette { const base = type.replace(/_list$/, "") as "string" | "long" | "double" | "boolean" | "date"; switch (base) { case "long": case "double": return { badge: "bg-amber-50 text-amber-700 ring-amber-200/70 dark:bg-amber-950/40 dark:text-amber-300 dark:ring-amber-500/30", bar: "bg-amber-400/70 dark:bg-amber-500/60", }; case "boolean": return { badge: "bg-violet-50 text-violet-700 ring-violet-200/70 dark:bg-violet-950/40 dark:text-violet-300 dark:ring-violet-500/30", bar: "bg-violet-400/70 dark:bg-violet-500/60", }; case "date": return { badge: "bg-sky-50 text-sky-700 ring-sky-200/70 dark:bg-sky-950/40 dark:text-sky-300 dark:ring-sky-500/30", bar: "bg-sky-400/70 dark:bg-sky-500/60", }; case "string": default: return { badge: "bg-emerald-50 text-emerald-700 ring-emerald-200/70 dark:bg-emerald-950/40 dark:text-emerald-300 dark:ring-emerald-500/30", bar: "bg-emerald-400/70 dark:bg-emerald-500/60", }; } } function formatTypeLabel(type: MetadataFieldType): string { if (type.endsWith("_list")) return `${type.replace(/_list$/, "")}[]`; return type; } function TypeBadge({ type }: { type: MetadataFieldType }) { const palette = getTypePalette(type); return ( {formatTypeLabel(type)} ); } function FormattedValue({ value, type, }: { value: unknown; type: MetadataFieldType; }) { const { t } = useI18n(); if (type === "boolean") { const bool = Boolean(value); return ( {bool ? "true" : "false"} ); } if (type.endsWith("_list") && Array.isArray(value)) { if (value.length === 0) return ( {t("documents.detail.emptyList")} ); return (
{value.map((item, idx) => ( {String(item)} ))}
); } if (type === "long" || type === "double") { return {String(value)}; } if (type === "date") { return {String(value)}; } // string / fallback return {String(value)}; } function MetadataSection({ fields, metadata, loading, knowledgeBaseName, docId, subspace, }: { fields: MetadataField[]; metadata: Record | undefined; loading: boolean; knowledgeBaseName: string; docId: string; subspace?: string; }) { const { t } = useI18n(); const [editing, setEditing] = useState(false); // The keys present in `values` define which schema fields are "active" in // the edit form. Adding a field inserts a key (with empty value); the // remove button deletes the key. On save, empty values are stripped by // `convertMetadataValues`, matching the backend's overwrite semantics. const [values, setValues] = useState>({}); const updateDocumentMutation = useUpdateDocument(); // Reset to a clean view whenever we switch to a different document. useEffect(() => { setEditing(false); }, [docId]); function handleStartEdit() { // Seed only with fields that currently have a value on the document — // unset schema fields stay hidden until the user explicitly adds them. const all = metadataToFormValues(metadata, fields); const seed: Record = {}; for (const f of fields) { const v = metadata?.[f.name]; if (v === undefined || v === null) continue; seed[f.name] = all[f.name]; } setValues(seed); setEditing(true); } function handleCancel() { setEditing(false); } function handleAddField(name: string) { setValues((prev) => ({ ...prev, [name]: "" })); } function handleRemoveField(name: string) { setValues((prev) => { const next = { ...prev }; delete next[name]; return next; }); } // Only convert active fields — schema fields not in `values` should not // be sent to the backend even with an empty value. const activeFields = useMemo( () => fields.filter((f) => f.name in values), [fields, values], ); const previewMetadata = useMemo( () => convertMetadataValues(values, activeFields), [values, activeFields], ); const availableFields = useMemo( () => fields.filter((f) => !(f.name in values)), [fields, values], ); // View mode: only render fields with actual values on the document. const setFields = useMemo( () => fields.filter((f) => { const v = metadata?.[f.name]; return v !== undefined && v !== null; }), [fields, metadata], ); async function handleSave() { try { await updateDocumentMutation.mutateAsync({ knowledgeBaseName, docId, subspace, metadata: previewMetadata, }); toast.success(t("documents.detail.metadataUpdateSuccess")); setEditing(false); } catch (error) { const message = error instanceof Error ? error.message : t("documents.detail.metadataUpdateFailed"); toast.error(message); } } return (

Metadata

{!loading && ( {editing ? activeFields.length : setFields.length}/{fields.length} )}
{editing ? (
) : ( )}
{loading && !editing ? ( ) : editing ? ( setValues((prev) => ({ ...prev, [name]: next })) } onRemove={handleRemoveField} onAdd={handleAddField} /> ) : setFields.length === 0 ? (

{t("documents.detail.metadataEmpty")}

) : (
{setFields.map((field) => ( ))}
)}
); } function MetadataDisplayRow({ field, value, }: { field: MetadataField; value: unknown; }) { const palette = getTypePalette(field.type); return (
{field.name}
); } function MetadataEditList({ activeFields, availableFields, values, onChange, onRemove, onAdd, }: { activeFields: MetadataField[]; availableFields: MetadataField[]; values: Record; onChange: (name: string, next: string) => void; onRemove: (name: string) => void; onAdd: (name: string) => void; }) { const { t } = useI18n(); return (
{activeFields.length > 0 && (
{activeFields.map((field) => { const palette = getTypePalette(field.type); return (
{field.name}
onChange(field.name, next)} />
); })}
)} {availableFields.length > 0 ? ( {availableFields.map((field) => ( onAdd(field.name)} className="flex items-center justify-between gap-2" > {field.name} ))} ) : ( activeFields.length === 0 && (

{t("documents.detail.metadataNoSchema")}

) )}
); } function DetailRow({ label, value, mono = false, }: { label: string; value: string; mono?: boolean; }) { return (
{label} {value}
); }