>
);
}
// ---------------------------------------------------------------------------
// 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 (