⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.
TypeScript honoissue-managementissue-trackerjira-alternativekanbanlinear-alternativemcpproject-managementreactself-hostedtypescript
import { ShortcutKeys } from "@/components/shortcuts/shortcut-keys";
import {
richTextCommands,
type SlashCommand,
type SlashRange,
} from "@/components/editor/slash-commands";
import { BubbleLinkEditor } from "@/components/editor/bubble-link-editor";
import { selectionStartAnchor } from "@/components/editor/selection-start-anchor";
import { TableToolbar } from "@/components/editor/table-toolbar";
import { createEditorExtensions } from "@/components/editor/extensions";
import { insertUploadedAsset as insertEditorAsset } from "@/components/editor/insert-uploaded-asset";
import { useEditorHighlighter } from "@/components/editor/use-editor-highlighter";
import type { Editor } from "@tiptap/core";
import Image from "@tiptap/extension-image";
import { TextSelection } from "@tiptap/pm/state";
import { EditorContent, useEditor } from "@tiptap/react";
import { BubbleMenu } from "@tiptap/react/menus";
import {
Bold,
Check,
ChevronDown,
Copy,
Italic,
Link2,
List,
ListOrdered,
ListTodo,
Paperclip,
UnderlineIcon,
ImageUpIcon,
} from "lucide-react";
import type { MouseEvent as ReactMouseEvent } from "react";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { KaneoMention } from "@kaneo/editor";
import type { MentionMember } from "@/components/task/extensions/mention-list";
import { MentionSuggestion } from "@/components/task/extensions/mention-suggestion";
import { SHIKI_CODEBLOCK_REFRESH_META } from "@/components/task/extensions/shiki-code-block";
import { Button } from "@/components/ui/button";
import { Dialog, DialogPopup } from "@/components/ui/dialog";
import { Input } from "@/components/ui/input";
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuRadioGroup,
DropdownMenuRadioItem,
DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/menu";
import useActiveWorkspace from "@/hooks/queries/workspace/use-active-workspace";
import { useGetActiveWorkspaceUsers } from "@/hooks/queries/workspace-users/use-get-active-workspace-users";
import useGetProjectMembers from "@/hooks/queries/workspace-users/use-get-project-members";
import { cn } from "@/lib/cn";
import {
extractIssueKeyFromUrl,
extractTaskIdFromUrl,
isYouTubeUrl,
normalizeUrl,
} from "@/lib/editor-url-utils";
import { isInCodeBlockLanguagePicker } from "@/lib/is-in-codeblock-language-picker";
import { normalizeCommentMarkdown } from "@/lib/normalize-comment-markdown";
import { pasteMarkdown } from "@/lib/paste-markdown";
import { toast } from "@/lib/toast";
import { uploadTaskImage } from "@/lib/upload-task-image";
type CommentEditorProps = {
value: string;
onChange?: (value: string) => void;
placeholder?: string;
className?: string;
contentClassName?: string;
proseClassName?: string;
autoFocus?: boolean;
disabled?: boolean;
readOnly?: boolean;
showBubbleMenu?: boolean;
slashMenuPosition?: "absolute" | "fixed";
onSubmitShortcut?: () => void;
onCancelShortcut?: () => void;
taskId?: string;
projectId?: string;
uploadSurface?: "description" | "comment";
ensureTaskId?: () => Promise<string | null>;
uploadAsset?: (
file: File,
) => Promise<Awaited<ReturnType<typeof uploadTaskImage>>>;
showQuickAttachButton?: boolean;
onAttachActionChange?: (attach: (() => void) | null) => void;
};
type SlashMenuState = {
from: number;
to: number;
query: string;
top: number;
left: number;
selectedIndex: number;
};
type HoveredCodeBlock = {
language: string;
nodePos: number;
top: number;
left: number;
};
const CODE_LANG_VALUES = [
"bash",
"csharp",
"cpp",
"css",
"go",
"graphql",
"html",
"json",
"java",
"javascript",
"markdown",
"mermaid",
"plaintext",
"python",
"rust",
"sql",
"swift",
"typescript",
"yaml",
] as const;
type EmbedComposerErrorKey = "embedErrorInvalidUrl" | "embedErrorYoutubeOnly";
const COMMENT_SHIKI_LANGUAGE_ALIASES: Record<string, string> = {
plaintext: "text",
};
type EmbedComposerState = {
mode: "choice" | "input";
url: string;
top: number;
left: number;
linkRange?: { from: number; to: number };
range?: SlashRange;
};
export default function CommentEditor({
value,
onChange,
placeholder,
className,
contentClassName,
proseClassName,
autoFocus = false,
disabled = false,
readOnly = false,
showBubbleMenu = true,
slashMenuPosition = "absolute",
onSubmitShortcut,
onCancelShortcut,
taskId,
projectId,
uploadSurface = "comment",
ensureTaskId,
uploadAsset,
showQuickAttachButton = true,
onAttachActionChange,
}: CommentEditorProps) {
const { t } = useTranslation();
const resolvedPlaceholder =
placeholder ?? t("activity:comment.leavePlaceholder");
const { data: activeWorkspace } = useActiveWorkspace();
const mentionWorkspaceId = activeWorkspace?.id ?? "";
const { data: workspaceUsers } = useGetActiveWorkspaceUsers(
projectId ? "" : mentionWorkspaceId,
);
const { data: projectMembers } = useGetProjectMembers({
workspaceId: mentionWorkspaceId,
projectId: projectId ?? "",
});
const mentionMembersRef = useRef<MentionMember[]>([]);
mentionMembersRef.current = useMemo(
() =>
projectId
? (projectMembers ?? []).map((member) => ({
id: member.id,
label: member.name || member.email,
image: member.image,
}))
: (workspaceUsers?.members ?? []).map((member) => ({
id: member.userId,
label: member.user?.name ?? member.user?.email ?? "",
image: member.user?.image ?? null,
})),
[projectId, projectMembers, workspaceUsers],
);
const editorShellRef = useRef<HTMLDivElement | null>(null);
const imageInputRef = useRef<HTMLInputElement | null>(null);
const dragDepthRef = useRef(0);
const isSyncingRef = useRef(false);
const hasHydratedRef = useRef(false);
const latestValueRef = useRef(normalizeCommentMarkdown(value || ""));
const lastEditorRef = useRef<Editor | null>(null);
const isMountedRef = useRef(false);
useEffect(() => {
isMountedRef.current = true;
return () => {
isMountedRef.current = false;
};
}, []);
const taskIdRef = useRef(taskId);
const ensureTaskIdRef = useRef(ensureTaskId);
const uploadAssetRef = useRef(uploadAsset);
uploadAssetRef.current = uploadAsset;
const uploadSurfaceRef = useRef(uploadSurface);
const onSubmitShortcutRef = useRef(onSubmitShortcut);
const onCancelShortcutRef = useRef(onCancelShortcut);
onSubmitShortcutRef.current = onSubmitShortcut;
onCancelShortcutRef.current = onCancelShortcut;
const linkShortcutRef = useRef(() => {});
const attachShortcutRef = useRef(() => {});
const readOnlyRef = useRef(readOnly);
readOnlyRef.current = readOnly;
const pendingImageInsertRef = useRef<{
editor: Editor;
range?: SlashRange;
} | null>(null);
const [slashMenu, setSlashMenu] = useState<SlashMenuState | null>(null);
const {
highlighter: shikiHighlighter,
highlighterRef: shikiHighlighterRef,
languages: availableShikiLanguages,
} = useEditorHighlighter();
const [hoveredCodeBlock, setHoveredCodeBlock] =
useState<HoveredCodeBlock | null>(null);
const hoveredCodeBlockElementRef = useRef<HTMLElement | null>(null);
const codeLanguageHideTimeoutRef = useRef<number | null>(null);
const codeCopyResetTimeoutRef = useRef<number | null>(null);
const [isCodeLanguageMenuOpen, setIsCodeLanguageMenuOpen] = useState(false);
const [isCodeCopied, setIsCodeCopied] = useState(false);
const [embedComposer, setEmbedComposer] = useState<EmbedComposerState | null>(
null,
);
const [embedComposerError, setEmbedComposerError] =
useState<EmbedComposerErrorKey | null>(null);
const [isDragActive, setIsDragActive] = useState(false);
const [previewImage, setPreviewImage] = useState<{
src: string;
alt: string;
} | null>(null);
const codeLanguages = useMemo(
() =>
CODE_LANG_VALUES.map((value) => ({
value,
label: t(`activity:comment.editor.codeLang.${value}`),
})),
[t],
);
const toShikiLanguage = useCallback(
(language: string) => {
const normalized = language.toLowerCase();
const alias = COMMENT_SHIKI_LANGUAGE_ALIASES[normalized];
if (alias) return alias;
if (availableShikiLanguages.has(normalized)) return normalized;
return "text";
},
[availableShikiLanguages],
);
const getOverlayPosition = useCallback(
(editorView: Editor["view"], pos: number) => {
const coords = editorView.coordsAtPos(pos);
const shellRect = editorShellRef.current?.getBoundingClientRect();
if (slashMenuPosition === "fixed" || !shellRect) {
return { top: coords.bottom + 8, left: coords.left };
}
return {
top: coords.bottom - shellRect.top + 8,
left: coords.left - shellRect.left,
};
},
[slashMenuPosition],
);
useEffect(() => {
taskIdRef.current = taskId;
ensureTaskIdRef.current = ensureTaskId;
uploadSurfaceRef.current = uploadSurface;
}, [ensureTaskId, taskId, uploadSurface]);
const insertUploadedAsset = useCallback(
(
editor: Editor,
asset: Awaited<ReturnType<typeof uploadTaskImage>>,
range?: SlashRange,
) => {
insertEditorAsset(
editor,
asset,
t("activity:comment.editor.failedToUploadFile"),
range,
);
},
[t],
);
const handleAssetFileUpload = useCallback(
async (file: File, targetEditor?: Editor | null, range?: SlashRange) => {
const activeEditor = targetEditor || lastEditorRef.current;
const initialTaskId = taskIdRef.current;
const resolvedTaskId =
initialTaskId ?? (await ensureTaskIdRef.current?.());
if (!activeEditor || (!resolvedTaskId && !uploadAssetRef.current)) {
toast.error(t("activity:comment.editor.uploadsOnlyOnSavedTasks"));
return;
}
const loadingToast = toast.loading(
t("activity:comment.editor.uploadingFile"),
);
try {
const uploadedAsset = uploadAssetRef.current
? await uploadAssetRef.current(file)
: await uploadTaskImage({
taskId: resolvedTaskId!,
surface: uploadSurfaceRef.current,
file,
});
// Reuse a replacement editor only while it still belongs to the task
// that owns the uploaded asset.
const currentEditor = !activeEditor.isDestroyed
? activeEditor
: lastEditorRef.current;
const taskChanged =
initialTaskId === undefined
? taskIdRef.current !== undefined &&
taskIdRef.current !== resolvedTaskId
: taskIdRef.current !== initialTaskId;
if (!isMountedRef.current || taskChanged) {
toast.dismiss(loadingToast);
return;
}
if (!currentEditor || currentEditor.isDestroyed) {
throw new Error(t("activity:comment.editor.failedToUploadFile"));
}
// Only report success when the image actually landed in the document;
// insertUploadedAsset throws otherwise and the catch below reports it.
insertUploadedAsset(currentEditor, uploadedAsset, range);
toast.dismiss(loadingToast);
toast.success(
uploadedAsset.kind === "image"
? t("activity:comment.editor.imageUploaded")
: t("activity:comment.editor.fileAttached"),
{ icon: ImageUpIcon },
);
} catch (error) {
toast.dismiss(loadingToast);
toast.error(
error instanceof Error
? error.message
: t("activity:comment.editor.failedToUploadFile"),
);
}
},
[insertUploadedAsset, t],
);
const canUploadFiles = Boolean(taskId || ensureTaskId || uploadAsset);
const openImagePicker = useCallback(
(activeEditor?: Editor | null, range?: SlashRange) => {
pendingImageInsertRef.current = activeEditor
? { editor: activeEditor, range }
: null;
imageInputRef.current?.click();
},
[],
);
const hasFileDrag = useCallback((event: React.DragEvent<HTMLElement>) => {
return Array.from(event.dataTransfer?.items || []).some(
(item) => item.kind === "file",
);
}, []);
const handleShellDragEnter = useCallback(
(event: React.DragEvent<HTMLElement>) => {
if (readOnly || disabled || !canUploadFiles || !hasFileDrag(event)) {
return;
}
event.preventDefault();
dragDepthRef.current += 1;
setIsDragActive(true);
},
[canUploadFiles, disabled, hasFileDrag, readOnly],
);
const handleShellDragOver = useCallback(
(event: React.DragEvent<HTMLElement>) => {
if (readOnly || disabled || !canUploadFiles || !hasFileDrag(event)) {
return;
}
event.preventDefault();
event.dataTransfer.dropEffect = "copy";
if (!isDragActive) {
setIsDragActive(true);
}
},
[canUploadFiles, disabled, hasFileDrag, isDragActive, readOnly],
);
const handleShellDragLeave = useCallback(
(event: React.DragEvent<HTMLElement>) => {
if (readOnly || disabled || !canUploadFiles || !hasFileDrag(event)) {
return;
}
event.preventDefault();
dragDepthRef.current = Math.max(0, dragDepthRef.current - 1);
if (dragDepthRef.current === 0) {
setIsDragActive(false);
}
},
[canUploadFiles, disabled, hasFileDrag, readOnly],
);
const handleShellDrop = useCallback(
(event: React.DragEvent<HTMLElement>) => {
if (readOnly || disabled || !canUploadFiles || !hasFileDrag(event)) {
return;
}
dragDepthRef.current = 0;
setIsDragActive(false);
},
[canUploadFiles, disabled, hasFileDrag, readOnly],
);
const slashCommands = useMemo<SlashCommand[]>(
() => [
{
id: "paragraph",
shortcutId: "editorParagraph",
label: t("activity:comment.editor.slashParagraph"),
group: "text",
search: t("activity:comment.editor.searchParagraph"),
run: richTextCommands.find((command) => command.id === "paragraph")!
.run,
},
{
id: "heading-2",
shortcutId: "editorHeading2",
label: t("activity:comment.editor.slashHeading"),
group: "text",
search: t("activity:comment.editor.searchHeading"),
run: richTextCommands.find((command) => command.id === "heading-2")!
.run,
},
{
id: "bullet-list",
shortcutId: "editorBulletList",
label: t("activity:comment.editor.slashBulletList"),
group: "lists",
search: t("activity:comment.editor.searchBulletList"),
run: richTextCommands.find((command) => command.id === "bullet-list")!
.run,
},
{
id: "task-list",
shortcutId: "editorChecklist",
label: t("activity:comment.editor.slashTaskList"),
group: "lists",
search: t("activity:comment.editor.searchTaskList"),
run: richTextCommands.find((command) => command.id === "task-list")!
.run,
},
{
id: "ordered-list",
shortcutId: "editorNumberedList",
label: t("activity:comment.editor.slashOrderedList"),
group: "lists",
search: t("activity:comment.editor.searchOrderedList"),
run: richTextCommands.find((command) => command.id === "ordered-list")!
.run,
},
{
id: "blockquote",
shortcutId: "editorQuote",
label: t("activity:comment.editor.slashQuote"),
group: "insert",
search: t("activity:comment.editor.searchQuote"),
run: richTextCommands.find((command) => command.id === "blockquote")!
.run,
},
{
id: "code-block",
shortcutId: "editorCodeBlock",
label: t("activity:comment.editor.slashCodeBlock"),
group: "insert",
search: t("activity:comment.editor.searchCodeBlock"),
run: richTextCommands.find((command) => command.id === "code-block")!
.run,
},
{
id: "table",
label: t("activity:comment.editor.slashTable"),
group: "insert",
search: t("activity:comment.editor.searchTable"),
run: richTextCommands.find((command) => command.id === "table")!.run,
},
{
id: "file",
label: t("activity:comment.editor.slashFile"),
group: "insert",
search: t("activity:comment.editor.searchFile"),
run: (activeEditor, range) => {
activeEditor.chain().focus().deleteRange(range).run();
openImagePicker(activeEditor);
},
},
],
[openImagePicker, t],
);
const filteredSlashCommands = useMemo(() => {
const query = slashMenu?.query.trim().toLowerCase() || "";
if (!query) return slashCommands;
return slashCommands.filter(
(command) =>
command.label.toLowerCase().includes(query) ||
command.search.includes(query),
);
}, [slashCommands, slashMenu?.query]);
const slashMenuRef = useRef(slashMenu);
slashMenuRef.current = slashMenu;
const filteredSlashCommandsRef = useRef(filteredSlashCommands);
filteredSlashCommandsRef.current = filteredSlashCommands;
const disabledRef = useRef(disabled);
disabledRef.current = disabled;
const editorRef = useRef<Editor | null>(null);
const editor = useEditor(
{
immediatelyRender: false,
autofocus: autoFocus,
editable: !readOnly && !disabled,
extensions: createEditorExtensions({
placeholder: resolvedPlaceholder,
highlighter: () => shikiHighlighterRef.current,
resolveLanguage: toShikiLanguage,
image: Image,
mermaidErrorKey: "activity:comment.editor.mermaid.renderFailed",
extra: [
KaneoMention,
MentionSuggestion.configure({
getMembers: () => mentionMembersRef.current,
}),
],
}),
editorProps: {
attributes: {
class: cn(
proseClassName || "kaneo-comment-editor-prose",
readOnly && "kaneo-comment-editor-prose-readonly",
),
},
handlePaste: (view, event) => {
if (readOnly || disabled) return false;
const pastedFiles = Array.from(event.clipboardData?.files || []);
const pastedFile = pastedFiles[0];
if (pastedFile) {
event.preventDefault();
void handleAssetFileUpload(pastedFile, editor);
return true;
}
const plainText = event.clipboardData?.getData("text/plain") || "";
if (pasteMarkdown(view, event)) return true;
const pastedText = plainText.trim();
if (!pastedText || /\s/.test(pastedText)) return false;
const url = normalizeUrl(pastedText);
if (!url) return false;
const issueKey = extractIssueKeyFromUrl(url);
const taskIdFromUrl = extractTaskIdFromUrl(url);
if (issueKey || taskIdFromUrl) {
event.preventDefault();
view.dispatch(
view.state.tr.replaceSelectionWith(
view.state.schema.nodes.kaneoIssueLink.create({
url,
issueKey: issueKey || "",
taskId: taskIdFromUrl || "",
}),
),
);
return true;
}
if (!isYouTubeUrl(url)) return false;
event.preventDefault();
const { from } = view.state.selection;
const linkMark = view.state.schema.marks.link?.create({ href: url });
const linkText = view.state.schema.text(
url,
linkMark ? [linkMark] : [],
);
view.dispatch(
view.state.tr
.replaceSelectionWith(linkText, false)
.scrollIntoView(),
);
const coords = getOverlayPosition(view, view.state.selection.from);
setEmbedComposer({
mode: "choice",
url,
top: coords.top,
left: coords.left,
linkRange: { from, to: from + url.length },
});
setEmbedComposerError(null);
return true;
},
handleClick: (_view, _pos, event) => {
if (!readOnlyRef.current) return false;
const target = event.target as HTMLElement;
const anchor = target.closest("a");
if (anchor?.href) {
window.open(anchor.href, "_blank", "noopener,noreferrer");
return true;
}
return false;
},
handleDrop: (_view, event) => {
if (readOnly || disabled) return false;
const droppedFiles = Array.from(event.dataTransfer?.files || []);
if (droppedFiles.length === 0) return false;
event.preventDefault();
// Each upload inserts after the previous one, the same way pasted
// files do, so a multi-file drop keeps every file.
for (const droppedFile of droppedFiles) {
void handleAssetFileUpload(droppedFile, editor);
}
return true;
},
handleTextInput: (view, _from, _to, text) => {
if (readOnly || disabled || text !== "`") return false;
const { state } = view;
const { $from } = state.selection;
if ($from.parent.type.name !== "paragraph") return false;
const textBefore = $from.parent.textBetween(
0,
$from.parentOffset,
"\0",
"\0",
);
if (!/^\s*``$/.test(textBefore)) return false;
const paragraphStart = $from.before();
const codeBlock = state.schema.nodes.codeBlock?.create();
if (!codeBlock) return false;
const tr = state.tr.replaceWith(
paragraphStart,
paragraphStart + $from.parent.nodeSize,
codeBlock,
);
tr.setSelection(
TextSelection.near(tr.doc.resolve(paragraphStart + 1)),
);
view.dispatch(tr.scrollIntoView());
return true;
},
handleKeyDown: (view, event) => {
const slashMenu = slashMenuRef.current;
const filteredSlashCommands = filteredSlashCommandsRef.current;
const readOnly = readOnlyRef.current;
const disabled = disabledRef.current;
const editor = editorRef.current;
const mod = event.metaKey || event.ctrlKey;
const key = event.key.toLowerCase();
if (!readOnly && !disabled && mod && !event.altKey) {
if (key === "k" && !event.shiftKey && !view.state.selection.empty) {
event.preventDefault();
linkShortcutRef.current();
return true;
}
if (key === "u" && event.shiftKey) {
event.preventDefault();
attachShortcutRef.current();
return true;
}
}
if (!readOnly && !disabled && slashMenu) {
if (event.key === "ArrowDown") {
event.preventDefault();
setSlashMenu((current) => {
if (!current) return current;
return {
...current,
selectedIndex:
(current.selectedIndex + 1) %
Math.max(filteredSlashCommands.length, 1),
};
});
return true;
}
if (event.key === "ArrowUp") {
event.preventDefault();
setSlashMenu((current) => {
if (!current) return current;
return {
...current,
selectedIndex:
(current.selectedIndex -
1 +
Math.max(filteredSlashCommands.length, 1)) %
Math.max(filteredSlashCommands.length, 1),
};
});
return true;
}
if (
(event.key === "Enter" || event.key === "Tab") &&
filteredSlashCommands.length
) {
event.preventDefault();
if (!editor) return true;
const command =
filteredSlashCommands[
Math.min(
slashMenu.selectedIndex,
filteredSlashCommands.length - 1,
)
];
if (command) {
command.run(editor, { from: slashMenu.from, to: slashMenu.to });
setSlashMenu(null);
}
return true;
}
if (event.key === "Escape") {
event.preventDefault();
event.stopPropagation();
setSlashMenu(null);
return true;
}
}
if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
const submit = onSubmitShortcutRef.current;
if (!readOnly && !disabled && submit) {
event.preventDefault();
submit();
return true;
}
}
if (
event.key === "Escape" &&
!readOnly &&
!disabled &&
onCancelShortcutRef.current
) {
event.preventDefault();
event.stopPropagation();
onCancelShortcutRef.current();
return true;
}
if (
(event.metaKey || event.ctrlKey) &&
event.key.toLowerCase() === "a" &&
editor
) {
const { state } = editor.view;
const { $from } = state.selection;
if ($from.parent.type.name === "codeBlock") {
event.preventDefault();
editor.view.dispatch(
state.tr.setSelection(
TextSelection.create(state.doc, $from.start(), $from.end()),
),
);
return true;
}
}
return false;
},
},
onUpdate: ({ editor: activeEditor }) => {
if (readOnly || disabled || !onChange || isSyncingRef.current) return;
const markdown = normalizeCommentMarkdown(activeEditor.getMarkdown());
latestValueRef.current = markdown;
onChange(markdown);
},
},
[handleAssetFileUpload, resolvedPlaceholder, toShikiLanguage],
);
editorRef.current = editor;
useEffect(() => {
if (!onAttachActionChange) return;
onAttachActionChange(editor ? () => openImagePicker(editor) : null);
return () => {
onAttachActionChange(null);
};
}, [editor, onAttachActionChange, openImagePicker]);
useEffect(() => {
if (!editor || !shikiHighlighter) return;
editor.view.dispatch(
editor.state.tr.setMeta(SHIKI_CODEBLOCK_REFRESH_META, true),
);
}, [editor, shikiHighlighter]);
useEffect(() => {
if (!editor || typeof document === "undefined") return;
const root = document.documentElement;
const refreshShikiTheme = () => {
editor.view.dispatch(
editor.state.tr.setMeta(SHIKI_CODEBLOCK_REFRESH_META, true),
);
};
const observer = new MutationObserver((mutations) => {
for (const mutation of mutations) {
if (mutation.attributeName === "class") {
refreshShikiTheme();
break;
}
}
});
observer.observe(root, { attributes: true, attributeFilter: ["class"] });
return () => {
observer.disconnect();
};
}, [editor]);
useEffect(() => {
// The editor instance can be destroyed and replaced while effects are
// flushing (e.g. Shiki resolving recreates it via useEditor deps). The
// next run attaches to the replacement instance.
if (!editor || editor.isDestroyed) return;
const handleImagePreviewClick = (event: MouseEvent) => {
const target = event.target as HTMLElement | null;
if (!(target instanceof HTMLImageElement)) return;
if (!target.classList.contains("kaneo-editor-image")) return;
event.preventDefault();
setPreviewImage({
src: target.currentSrc || target.src,
alt: target.alt || t("activity:comment.editor.previewImageAlt"),
});
};
const dom = editor.view.dom;
dom.addEventListener("click", handleImagePreviewClick);
return () => {
dom.removeEventListener("click", handleImagePreviewClick);
};
}, [editor, t]);
const updateSlashMenu = useCallback(
(activeEditor: Editor) => {
if (readOnly || disabled) {
setSlashMenu(null);
return;
}
const { state, view } = activeEditor;
const { selection } = state;
if (!selection.empty) {
setSlashMenu(null);
return;
}
const { $from } = selection;
if (!$from.parent.isTextblock) {
setSlashMenu(null);
return;
}
const textBefore = $from.parent.textBetween(
0,
$from.parentOffset,
"\0",
"\0",
);
const match = textBefore.match(/(?:^|\s)\/([^\s/]*)$/);
if (!match) {
setSlashMenu(null);
return;
}
const query = match[1] || "";
const matchText = match[0];
const startsWithSpace = matchText.startsWith(" ");
const slashOffset =
$from.parentOffset - matchText.length + (startsWithSpace ? 1 : 0);
const from = $from.start() + slashOffset;
const to = from + matchText.trimStart().length;
const { top, left } = getOverlayPosition(view, $from.pos);
setSlashMenu((current) => ({
from,
to,
query,
top,
left,
selectedIndex: current?.query === query ? current.selectedIndex : 0,
}));
},
[disabled, getOverlayPosition, readOnly],
);
useEffect(() => {
if (!editor) return;
const syncSlash = () => updateSlashMenu(editor);
editor.on("selectionUpdate", syncSlash);
editor.on("update", syncSlash);
return () => {
editor.off("selectionUpdate", syncSlash);
editor.off("update", syncSlash);
};
}, [editor, updateSlashMenu]);
useEffect(() => {
if (!editor) return;
editor.setEditable(!readOnly && !disabled);
}, [disabled, editor, readOnly]);
useEffect(() => {
if (!editor) return;
if (lastEditorRef.current !== editor) {
hasHydratedRef.current = false;
lastEditorRef.current = editor;
}
const incoming = normalizeCommentMarkdown(value || "");
if (!hasHydratedRef.current) {
isSyncingRef.current = true;
latestValueRef.current = incoming;
editor.commands.setContent(incoming, {
emitUpdate: false,
contentType: "markdown",
});
hasHydratedRef.current = true;
queueMicrotask(() => {
isSyncingRef.current = false;
});
return;
}
if (incoming === latestValueRef.current) return;
isSyncingRef.current = true;
editor.commands.setContent(incoming, {
emitUpdate: false,
contentType: "markdown",
});
latestValueRef.current = incoming;
queueMicrotask(() => {
isSyncingRef.current = false;
});
}, [editor, value]);
const [isEditingLink, setIsEditingLink] = useState(false);
const setLink = useCallback(() => {
if (readOnly || disabled || !editor) return;
setIsEditingLink(true);
}, [disabled, editor, readOnly]);
linkShortcutRef.current = setLink;
attachShortcutRef.current = () => openImagePicker(editor);
const bubbleAnchor = useCallback(
() => (editor ? selectionStartAnchor(editor) : null),
[editor],
);
const bubbleOptions = useMemo(
() => ({ onHide: () => setIsEditingLink(false) }),
[],
);
const resolveCodeBlockNodeData = useCallback(
(pos: number) => {
if (!editor) return null;
const resolvedPos = editor.state.doc.resolve(
Math.max(0, Math.min(pos, editor.state.doc.content.size)),
);
for (let depth = resolvedPos.depth; depth > 0; depth -= 1) {
const node = resolvedPos.node(depth);
if (node.type.name !== "codeBlock") continue;
return {
language: (node.attrs.language as string | undefined) || "auto",
nodePos: resolvedPos.before(depth),
};
}
return null;
},
[editor],
);
const updateHoveredCodeBlockFromElement = useCallback(
(element: HTMLElement | null) => {
if (!editor || !element) {
if (!isCodeLanguageMenuOpen) {
hoveredCodeBlockElementRef.current = null;
setHoveredCodeBlock(null);
}
return;
}
const view = editor.view;
const pos = view.posAtDOM(element, 0);
const nodeData = resolveCodeBlockNodeData(pos);
if (!nodeData) return;
const rect = element.getBoundingClientRect();
const shellRect = editorShellRef.current?.getBoundingClientRect();
const top =
slashMenuPosition === "fixed" || !shellRect
? rect.top + 6
: rect.top - shellRect.top + 6;
const left =
slashMenuPosition === "fixed" || !shellRect
? rect.right - 12
: rect.right - shellRect.left - 12;
setHoveredCodeBlock((current) => {
if (current?.nodePos !== nodeData.nodePos) {
setIsCodeCopied(false);
}
return {
language: nodeData.language.toLowerCase(),
nodePos: nodeData.nodePos,
top,
left,
};
});
hoveredCodeBlockElementRef.current = element;
},
[
editor,
isCodeLanguageMenuOpen,
resolveCodeBlockNodeData,
slashMenuPosition,
],
);
const setCodeLanguage = useCallback(
(language: string) => {
if (!editor || !hoveredCodeBlock) return;
const resolvedLanguage = language === "auto" ? "" : language;
const { nodePos } = hoveredCodeBlock;
const node = editor.state.doc.nodeAt(nodePos);
if (node?.type.name !== "codeBlock") return;
editor
.chain()
.focus()
.command(({ tr }) => {
tr.setNodeMarkup(nodePos, undefined, {
...node.attrs,
language: resolvedLanguage,
});
return true;
})
.run();
setHoveredCodeBlock((current) =>
current ? { ...current, language } : current,
);
},
[editor, hoveredCodeBlock],
);
const activeCodeLanguageLabel = useMemo(() => {
if (!hoveredCodeBlock) return t("activity:comment.editor.plaintext");
if (hoveredCodeBlock.language === "auto")
return t("activity:comment.editor.autoDetect");
const match = codeLanguages.find(
(option) => option.value === hoveredCodeBlock.language,
);
return match?.label || hoveredCodeBlock.language;
}, [codeLanguages, hoveredCodeBlock, t]);
useEffect(() => {
if (!hoveredCodeBlock || isCodeLanguageMenuOpen) return;
const syncPosition = () => {
const element = hoveredCodeBlockElementRef.current;
if (!element) return;
updateHoveredCodeBlockFromElement(element);
};
window.addEventListener("scroll", syncPosition, true);
window.addEventListener("resize", syncPosition);
return () => {
window.removeEventListener("scroll", syncPosition, true);
window.removeEventListener("resize", syncPosition);
};
}, [
hoveredCodeBlock,
isCodeLanguageMenuOpen,
updateHoveredCodeBlockFromElement,
]);
const groupedSlashCommands = useMemo(
() => [
{
title: t("activity:comment.editor.slashGroupText"),
items: filteredSlashCommands.filter(
(command) => command.group === "text",
),
},
{
title: t("activity:comment.editor.slashGroupLists"),
items: filteredSlashCommands.filter(
(command) => command.group === "lists",
),
},
{
title: t("activity:comment.editor.slashGroupInsert"),
items: filteredSlashCommands.filter(
(command) => command.group === "insert",
),
},
],
[filteredSlashCommands, t],
);
const submitEmbedComposer = useCallback(
(mode: "embed" | "link") => {
if (!editor || !embedComposer) return;
const url = normalizeUrl(embedComposer.url);
if (!url) {
setEmbedComposerError("embedErrorInvalidUrl");
return;
}
const chain = editor.chain().focus();
if (embedComposer.mode === "choice" && mode === "link") {
setEmbedComposer(null);
setEmbedComposerError(null);
return;
}
if (embedComposer.linkRange) {
chain.deleteRange(embedComposer.linkRange);
} else if (embedComposer.range) {
chain.deleteRange(embedComposer.range);
}
if (mode === "link") {
chain
.insertContent({
type: "text",
text: url,
marks: [
{
type: "link",
attrs: {
href: url,
},
},
],
})
.run();
} else {
if (!isYouTubeUrl(url)) {
setEmbedComposerError("embedErrorYoutubeOnly");
return;
}
chain
.insertContent({
type: "embedBlock",
attrs: {
url,
mode: "embed",
},
})
.run();
}
setEmbedComposer(null);
setEmbedComposerError(null);
},
[editor, embedComposer],
);
useEffect(() => {
if (!embedComposer) return;
const handleKeyDown = (event: KeyboardEvent) => {
if (!embedComposer) return;
event.stopPropagation();
event.stopImmediatePropagation();
if (embedComposer.mode === "choice") {
if (event.key === "ArrowDown" || event.key === "ArrowUp") {
event.preventDefault();
return;
}
if (event.key === "Tab") {
event.preventDefault();
submitEmbedComposer("embed");
return;
}
if (event.key === "Escape") {
event.preventDefault();
setEmbedComposer(null);
setEmbedComposerError(null);
return;
}
if (event.key === "Enter") {
event.preventDefault();
submitEmbedComposer("embed");
}
return;
}
if (event.key === "Escape") {
event.preventDefault();
setEmbedComposer(null);
setEmbedComposerError(null);
}
};
window.addEventListener("keydown", handleKeyDown, true);
return () => {
window.removeEventListener("keydown", handleKeyDown, true);
};
}, [embedComposer, submitEmbedComposer]);
const handleEditorMouseMove = useCallback(
(event: ReactMouseEvent<HTMLElement>) => {
if (disabled) return;
const target = event.target as HTMLElement;
if (target.closest(".kaneo-codeblock-language")) return;
const hovered = target.closest(
"pre.kaneo-tiptap-codeblock",
) as HTMLElement | null;
if (!hovered) {
if (!isCodeLanguageMenuOpen) {
hoveredCodeBlockElementRef.current = null;
setHoveredCodeBlock(null);
}
return;
}
if (codeLanguageHideTimeoutRef.current !== null) {
window.clearTimeout(codeLanguageHideTimeoutRef.current);
codeLanguageHideTimeoutRef.current = null;
}
updateHoveredCodeBlockFromElement(hovered);
},
[disabled, isCodeLanguageMenuOpen, updateHoveredCodeBlockFromElement],
);
const handleEditorMouseLeave = useCallback(
(event: ReactMouseEvent<HTMLElement>) => {
const relatedTarget = event.relatedTarget;
if (isInCodeBlockLanguagePicker(relatedTarget)) return;
if (isCodeLanguageMenuOpen) return;
if (codeLanguageHideTimeoutRef.current !== null) {
window.clearTimeout(codeLanguageHideTimeoutRef.current);
}
codeLanguageHideTimeoutRef.current = window.setTimeout(() => {
codeLanguageHideTimeoutRef.current = null;
const pickerIsHovered = Boolean(
document.querySelector(".kaneo-codeblock-language:hover"),
);
if (pickerIsHovered || isCodeLanguageMenuOpen) return;
hoveredCodeBlockElementRef.current = null;
setHoveredCodeBlock(null);
}, 40);
},
[isCodeLanguageMenuOpen],
);
useEffect(() => {
return () => {
if (codeLanguageHideTimeoutRef.current !== null) {
window.clearTimeout(codeLanguageHideTimeoutRef.current);
}
if (codeCopyResetTimeoutRef.current !== null) {
window.clearTimeout(codeCopyResetTimeoutRef.current);
}
};
}, []);
const copyHoveredCodeBlock = useCallback(async () => {
if (!editor || !hoveredCodeBlock) return;
const node = editor.state.doc.nodeAt(hoveredCodeBlock.nodePos);
if (node?.type.name !== "codeBlock") return;
const content = node.textContent || "";
if (!content) return;
try {
await navigator.clipboard.writeText(content);
setIsCodeCopied(true);
if (codeCopyResetTimeoutRef.current !== null) {
window.clearTimeout(codeCopyResetTimeoutRef.current);
}
codeCopyResetTimeoutRef.current = window.setTimeout(() => {
setIsCodeCopied(false);
codeCopyResetTimeoutRef.current = null;
}, 1400);
} catch (_error) {
// ignore clipboard write failures
}
}, [editor, hoveredCodeBlock]);
return (
<section
ref={editorShellRef}
aria-label={
readOnly
? t("activity:comment.editor.ariaCommentContent")
: t("activity:comment.editor.ariaCommentEditor")
}
className={cn(
"kaneo-comment-editor-shell",
isDragActive && "is-drag-active",
readOnly && "kaneo-comment-editor-shell-readonly",
className,
)}
onDragEnter={handleShellDragEnter}
onDragOver={handleShellDragOver}
onDragLeave={handleShellDragLeave}
onDrop={handleShellDrop}
>
{!readOnly && !disabled && (
<input
ref={imageInputRef}
type="file"
className="sr-only"
onChange={(event) => {
const file = event.target.files?.[0];
if (!file) return;
const pendingInsert = pendingImageInsertRef.current;
pendingImageInsertRef.current = null;
void handleAssetFileUpload(
file,
pendingInsert?.editor,
pendingInsert?.range,
);
event.target.value = "";
}}
/>
)}
{editor && hoveredCodeBlock && !disabled && (
<div
className="kaneo-codeblock-language"
style={{
top: hoveredCodeBlock.top,
left: hoveredCodeBlock.left,
position: slashMenuPosition,
}}
>
<button
type="button"
className="kaneo-codeblock-language-trigger kaneo-codeblock-copy-trigger"
aria-label={
isCodeCopied
? t("activity:comment.editor.ariaCopied")
: t("activity:comment.editor.ariaCopyCode")
}
onMouseDown={(event) => {
event.preventDefault();
}}
onClick={() => {
void copyHoveredCodeBlock();
}}
>
{isCodeCopied ? (
<Check className="size-3.5" />
) : (
<Copy className="size-3.5" />
)}
<span>
{isCodeCopied
? t("activity:comment.editor.copied")
: t("activity:comment.editor.copy")}
</span>
</button>
{!readOnly && (
<DropdownMenu
open={isCodeLanguageMenuOpen}
onOpenChange={setIsCodeLanguageMenuOpen}
>
<DropdownMenuTrigger asChild>
<button
type="button"
className="kaneo-codeblock-language-trigger"
>
<span className="truncate">{activeCodeLanguageLabel}</span>
<ChevronDown className="size-3.5 opacity-70" />
</button>
</DropdownMenuTrigger>
<DropdownMenuContent
align="end"
side="bottom"
sideOffset={6}
className="max-h-72 w-48 overflow-y-auto"
>
<DropdownMenuRadioGroup
value={hoveredCodeBlock.language}
onValueChange={setCodeLanguage}
>
<DropdownMenuRadioItem value="auto">
{t("activity:comment.editor.autoDetect")}
</DropdownMenuRadioItem>
<DropdownMenuSeparator />
{codeLanguages.map(({ value, label }) => (
<DropdownMenuRadioItem key={value} value={value}>
{label}
</DropdownMenuRadioItem>
))}
</DropdownMenuRadioGroup>
</DropdownMenuContent>
</DropdownMenu>
)}
</div>
)}
{editor && !readOnly && !disabled && showBubbleMenu && (
<BubbleMenu
editor={editor}
className="kaneo-comment-editor-bubble"
getReferencedVirtualElement={bubbleAnchor}
options={bubbleOptions}
shouldShow={({ editor: activeEditor, from, to }) => {
if (activeEditor.isActive("embedBlock")) return false;
if (activeEditor.isActive("image")) return false;
if (activeEditor.isEmpty) return false;
return from !== to;
}}
>
{isEditingLink ? (
<BubbleLinkEditor
editor={editor}
buttonClassName="kaneo-comment-editor-bubble-btn"
onClose={() => setIsEditingLink(false)}
/>
) : (
<>
<Button
type="button"
variant="ghost"
size="xs"
className={cn(
"kaneo-comment-editor-bubble-btn",
editor.isActive("bold") && "bg-accent text-accent-foreground",
)}
onClick={() => editor.chain().focus().toggleBold().run()}
>
<Bold className="size-3.5" />
</Button>
<Button
type="button"
variant="ghost"
size="xs"
className={cn(
"kaneo-comment-editor-bubble-btn",
editor.isActive("italic") &&
"bg-accent text-accent-foreground",
)}
onClick={() => editor.chain().focus().toggleItalic().run()}
>
<Italic className="size-3.5" />
</Button>
<Button
type="button"
variant="ghost"
size="xs"
className={cn(
"kaneo-comment-editor-bubble-btn",
editor.isActive("underline") &&
"bg-accent text-accent-foreground",
)}
onClick={() => editor.chain().focus().toggleUnderline().run()}
>
<UnderlineIcon className="size-3.5" />
</Button>
<Button
type="button"
variant="ghost"
size="xs"
className={cn(
"kaneo-comment-editor-bubble-btn",
editor.isActive("bulletList") &&
"bg-accent text-accent-foreground",
)}
onClick={() => editor.chain().focus().toggleBulletList().run()}
>
<List className="size-3.5" />
</Button>
<Button
type="button"
variant="ghost"
size="xs"
className={cn(
"kaneo-comment-editor-bubble-btn",
editor.isActive("taskList") &&
"bg-accent text-accent-foreground",
)}
onClick={() => editor.chain().focus().toggleTaskList().run()}
>
<ListTodo className="size-3.5" />
</Button>
<Button
type="button"
variant="ghost"
size="xs"
className={cn(
"kaneo-comment-editor-bubble-btn",
editor.isActive("orderedList") &&
"bg-accent text-accent-foreground",
)}
onClick={() => editor.chain().focus().toggleOrderedList().run()}
>
<ListOrdered className="size-3.5" />
</Button>
<Button
type="button"
variant="ghost"
size="xs"
className={cn(
"kaneo-comment-editor-bubble-btn",
editor.isActive("link") && "bg-accent text-accent-foreground",
)}
onClick={setLink}
>
<Link2 className="size-3.5" />
</Button>
<Button
type="button"
variant="ghost"
size="xs"
className="kaneo-comment-editor-bubble-btn"
onClick={() => openImagePicker(editor)}
>
<Paperclip className="size-3.5" />
</Button>
</>
)}
</BubbleMenu>
)}
{editor && !readOnly && !disabled && showBubbleMenu && (
<BubbleMenu
editor={editor}
pluginKey="kaneo-comment-table-bubble"
className="kaneo-comment-editor-bubble"
shouldShow={({ editor: activeEditor, from, to }) =>
activeEditor.isActive("table") && from === to
}
>
<TableToolbar
editor={editor}
className="kaneo-comment-editor-bubble-btn"
labels={{
addColumnBefore: t(
"activity:comment.editor.table.addColumnBefore",
{ defaultValue: "Insert column left" },
),
addColumnAfter: t(
"activity:comment.editor.table.addColumnAfter",
{ defaultValue: "Insert column right" },
),
deleteColumn: t("activity:comment.editor.table.deleteColumn", {
defaultValue: "Delete column",
}),
addRowBefore: t("activity:comment.editor.table.addRowBefore", {
defaultValue: "Insert row above",
}),
addRowAfter: t("activity:comment.editor.table.addRowAfter", {
defaultValue: "Insert row below",
}),
deleteRow: t("activity:comment.editor.table.deleteRow", {
defaultValue: "Delete row",
}),
deleteTable: t("activity:comment.editor.table.deleteTable", {
defaultValue: "Delete table",
}),
}}
/>
</BubbleMenu>
)}
{slashMenu && !readOnly && !disabled && (
<div
className="kaneo-tiptap-slash-menu"
style={{
top: slashMenu.top,
left: slashMenu.left,
position: slashMenuPosition,
}}
>
{filteredSlashCommands.length > 0 ? (
groupedSlashCommands.map((group) => {
if (!group.items.length) return null;
return (
<div key={group.title} className="kaneo-tiptap-slash-group">
<div className="kaneo-tiptap-slash-group-title">
{group.title}
</div>
{group.items.map((command) => {
const index = filteredSlashCommands.findIndex(
(candidate) => candidate.id === command.id,
);
return (
<button
key={command.id}
type="button"
className={cn(
"kaneo-tiptap-slash-item",
slashMenu.selectedIndex === index && "is-selected",
)}
onMouseEnter={() =>
setSlashMenu((current) =>
current
? { ...current, selectedIndex: index }
: current,
)
}
onMouseDown={(event) => {
event.preventDefault();
if (!editor) return;
command.run(editor, {
from: slashMenu.from,
to: slashMenu.to,
});
setSlashMenu(null);
}}
>
<span className="kaneo-tiptap-slash-label">
{command.label}
</span>
{command.shortcutId && (
<span className="kaneo-tiptap-slash-shortcut">
<ShortcutKeys
id={command.shortcutId}
tone="muted"
/>
</span>
)}
</button>
);
})}
</div>
);
})
) : (
<div className="kaneo-tiptap-slash-empty">
{t("activity:comment.editor.noCommands")}
</div>
)}
</div>
)}
{editor && embedComposer && (
<div
className="kaneo-embed-composer"
style={{
top: embedComposer.top,
left: embedComposer.left,
position: slashMenuPosition,
}}
>
{embedComposer.mode === "choice" ? (
<div className="kaneo-embed-choice-menu">
<button
type="button"
className="kaneo-embed-choice-item is-primary"
onMouseDown={(event) => {
event.preventDefault();
submitEmbedComposer("embed");
}}
>
<span>{t("activity:comment.editor.embedVideo")}</span>
<span className="kaneo-embed-choice-hint">
{t("activity:comment.editor.hintTab")}
</span>
</button>
<button
type="button"
className="kaneo-embed-choice-item"
onMouseDown={(event) => {
event.preventDefault();
setEmbedComposer(null);
setEmbedComposerError(null);
}}
>
<span>{t("activity:comment.editor.keepAsLink")}</span>
<span className="kaneo-embed-choice-hint">
{t("activity:comment.editor.hintEsc")}
</span>
</button>
</div>
) : (
<form
className="kaneo-embed-composer-form"
onSubmit={(event) => {
event.preventDefault();
submitEmbedComposer("embed");
}}
>
<Input
size="sm"
value={embedComposer.url}
onChange={(event) => {
setEmbedComposer((current) =>
current ? { ...current, url: event.target.value } : current,
);
if (embedComposerError) setEmbedComposerError(null);
}}
placeholder={t("activity:comment.editor.pasteUrl")}
autoFocus
/>
<div className="kaneo-embed-composer-actions">
<Button
type="button"
size="xs"
variant="ghost"
onClick={() => submitEmbedComposer("link")}
>
{t("activity:comment.editor.asLink")}
</Button>
<Button type="submit" size="xs">
{t("activity:comment.editor.embed")}
</Button>
<Button
type="button"
size="xs"
variant="ghost"
onClick={() => {
setEmbedComposer(null);
setEmbedComposerError(null);
}}
>
{t("common:actions.cancel")}
</Button>
</div>
{embedComposerError && (
<p className="kaneo-embed-composer-error">
{t(`activity:comment.editor.${embedComposerError}`)}
</p>
)}
</form>
)}
</div>
)}
<EditorContent
editor={editor}
className={cn("kaneo-comment-editor-content", contentClassName)}
onMouseMove={handleEditorMouseMove}
onMouseLeave={handleEditorMouseLeave}
/>
{!readOnly && !disabled && showQuickAttachButton && (
<button
type="button"
className="kaneo-editor-quick-attach"
onMouseDown={(event) => {
event.preventDefault();
}}
onClick={() => openImagePicker(editor)}
aria-label={t("activity:comment.attachFile")}
>
<Paperclip className="size-3.5" />
</button>
)}
{isDragActive && (
<div className="kaneo-editor-drop-indicator">
<span>{t("activity:comment.editor.dropImageToUpload")}</span>
</div>
)}
<Dialog
open={Boolean(previewImage)}
onOpenChange={(open) => {
if (!open) setPreviewImage(null);
}}
>
<DialogPopup
className="w-auto max-w-6xl border-0 bg-transparent p-0 shadow-none before:hidden"
showCloseButton={false}
bottomStickOnMobile={false}
>
{previewImage && (
<div className="flex max-h-[90vh] items-center justify-center">
<img
src={previewImage.src}
alt={previewImage.alt}
className="max-h-[85vh] max-w-[92vw] rounded-xl border border-white/12 bg-black/30 object-contain shadow-2xl"
/>
</div>
)}
</DialogPopup>
</Dialog>
</section>
);
}