Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

14.6 KB
Raw Blame
import { useNavigate } from "@tanstack/react-router";
import { AnimatePresence } from "motion/react";
import { Trash2Icon } from "lucide-react";
import { useCallback, useEffect, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import {
  AlertDialog,
  AlertDialogClose,
  AlertDialogContent,
  AlertDialogDescription,
  AlertDialogFooter,
  AlertDialogHeader,
  AlertDialogTitle,
} from "@/components/ui/alert-dialog";
import { Button } from "@/components/ui/button";
import CircularProgress from "@/components/ui/circular-progress";
import { Input } from "@/components/ui/input";
import useCreateTask from "@/hooks/mutations/task/use-create-task";
import { useDeleteTask } from "@/hooks/mutations/task/use-delete-task";
import useCreateTaskRelation from "@/hooks/mutations/task-relation/use-create-task-relation";
import { useGetColumns } from "@/hooks/queries/column/use-get-columns";
import useGetTaskRelations from "@/hooks/queries/task-relation/use-get-task-relations";
import useActiveWorkspace from "@/hooks/queries/workspace/use-active-workspace";
import { useGetActiveWorkspaceUsers } from "@/hooks/queries/workspace-users/use-get-active-workspace-users";
import { useWorkspacePermission } from "@/hooks/use-workspace-permission";
import { toast } from "@/lib/toast";
import queryClient from "@/query-client";
import type Task from "@/types/task";
import { SectionAddButton } from "./sections/section-add-button";
import { SectionHeader } from "./sections/section-header";
import { useProjectSlugs } from "./sections/use-project-slugs";
import SubtaskRow from "./subtask-row";
import { useToggleTaskCompletion } from "./use-toggle-task-completion";

type TaskSubtasksProps = {
  taskId: string;
  projectId: string;
  workspaceId: string;
  parentStatus: string;
};

export default function TaskSubtasks({
  taskId,
  projectId,
  workspaceId,
  parentStatus,
}: TaskSubtasksProps) {
  const { t } = useTranslation();
  const navigate = useNavigate();
  const [isAdding, setIsAdding] = useState(false);
  const [newTitle, setNewTitle] = useState("");
  const [deleteTaskId, setDeleteTaskId] = useState<string | null>(null);
  const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
  const [focusedIndex, setFocusedIndex] = useState(-1);
  const containerRef = useRef<HTMLDivElement>(null);

  const { data: relations = [], isSuccess: relationsLoaded } =
    useGetTaskRelations(taskId);
  const { data: workspace } = useActiveWorkspace();
  const { data: workspaceUsers } = useGetActiveWorkspaceUsers(
    workspace?.id ?? "",
  );
  const createTask = useCreateTask();
  const createRelation = useCreateTaskRelation();
  const { mutateAsync: deleteTask } = useDeleteTask();
  const { data: columns = [], isLoading: isLoadingColumns } =
    useGetColumns(projectId);
  const { canCreateTasks, canUpdateTasks } = useWorkspacePermission();
  const displayIdOf = useProjectSlugs(workspaceId);
  const canEdit = canUpdateTasks();
  const canCreate = canCreateTasks();

  const todoSlug = columns.find((c) => !c.isFinal)?.slug;
  const canCreateSubtask =
    parentStatus === "planned" || (!isLoadingColumns && Boolean(todoSlug));

  const subtasks = relations
    .filter(
      (rel) => rel.relationType === "subtask" && rel.sourceTaskId === taskId,
    )
    .map((rel) => ({ relation: rel, task: rel.targetTask }))
    .filter(
      (item): item is typeof item & { task: NonNullable<typeof item.task> } =>
        item.task !== null,
    );

  const completedCount = subtasks.filter((s) => s.task.isCompleted).length;
  const totalCount = subtasks.length;
  const hasSelection = selectedIds.size > 0;

  const toggleSelection = useCallback((id: string) => {
    setSelectedIds((prev) => {
      const next = new Set(prev);
      if (next.has(id)) {
        next.delete(id);
      } else {
        next.add(id);
      }
      return next;
    });
  }, []);

  const clearSelection = useCallback(() => {
    setSelectedIds(new Set());
    setFocusedIndex(-1);
  }, []);

  const buildTaskObject = (subtask: (typeof subtasks)[number]): Task => ({
    id: subtask.task.id,
    title: subtask.task.title,
    number: subtask.task.number,
    description: null,
    status: subtask.task.status,
    priority: subtask.task.priority,
    startDate: null,
    dueDate: null,
    position: null,
    createdAt: "",
    userId: subtask.task.userId,
    assigneeId: subtask.task.userId,
    assigneeName: subtask.task.assigneeName,
    projectId: subtask.task.projectId,
  });

  const getTargetTasks = (currentTask: Task): Task[] => {
    if (hasSelection && selectedIds.has(currentTask.id)) {
      return subtasks
        .filter((s) => selectedIds.has(s.task.id))
        .map(buildTaskObject);
    }
    return [currentTask];
  };

  const handleToggleComplete = useToggleTaskCompletion();

  const getAssignee = (userId: string | null) => {
    if (!userId || !workspaceUsers?.members) return null;
    return (
      workspaceUsers.members.find((member) => member.userId === userId) ?? null
    );
  };

  const getSelectionRadius = (index: number, isSelected: boolean) => {
    if (!isSelected) return "rounded-md";

    const prevSelected =
      index > 0 && selectedIds.has(subtasks[index - 1].task.id);
    const nextSelected =
      index < subtasks.length - 1 &&
      selectedIds.has(subtasks[index + 1].task.id);

    if (prevSelected && nextSelected) return "rounded-none";
    if (prevSelected) return "rounded-t-none rounded-b-md";
    if (nextSelected) return "rounded-t-md rounded-b-none";
    return "rounded-md";
  };

  // Keyboard navigation
  useEffect(() => {
    const container = containerRef.current;
    if (!container || totalCount === 0) return;

    const handleKeyDown = (e: KeyboardEvent) => {
      const target = e.target as HTMLElement | null;
      if (
        target?.closest(
          "input, textarea, [contenteditable='true'], .ProseMirror",
        )
      )
        return;

      if (!container.contains(document.activeElement) && focusedIndex === -1)
        return;

      switch (e.key) {
        case "ArrowDown":
        case "j": {
          e.preventDefault();
          e.stopPropagation();
          setFocusedIndex((prev) => (prev < totalCount - 1 ? prev + 1 : prev));
          break;
        }
        case "ArrowUp":
        case "k": {
          e.preventDefault();
          e.stopPropagation();
          setFocusedIndex((prev) => (prev > 0 ? prev - 1 : prev));
          break;
        }
        case " ": {
          if (focusedIndex >= 0 && focusedIndex < totalCount) {
            e.preventDefault();
            e.stopPropagation();
            toggleSelection(subtasks[focusedIndex].task.id);
          }
          break;
        }
        case "Enter": {
          if (focusedIndex >= 0 && focusedIndex < totalCount) {
            e.preventDefault();
            e.stopPropagation();
            navigate({
              to: "/dashboard/workspace/$workspaceId/project/$projectId/task/$taskId",
              params: {
                workspaceId,
                projectId: subtasks[focusedIndex].task.projectId,
                taskId: subtasks[focusedIndex].task.id,
              },
            });
          }
          break;
        }
        case "Escape": {
          if (hasSelection) {
            e.preventDefault();
            e.stopPropagation();
            clearSelection();
          } else if (focusedIndex >= 0) {
            e.preventDefault();
            e.stopPropagation();
            setFocusedIndex(-1);
          }
          break;
        }
      }
    };

    document.addEventListener("keydown", handleKeyDown, true);
    return () => document.removeEventListener("keydown", handleKeyDown, true);
  }, [
    focusedIndex,
    totalCount,
    subtasks,
    hasSelection,
    clearSelection,
    navigate,
    workspaceId,
    toggleSelection,
  ]);

  const handleAddSubtask = async () => {
    if (!canCreate || !canEdit || !newTitle.trim()) return;
    const initialStatus = parentStatus === "planned" ? "planned" : todoSlug;
    if (!initialStatus) return;

    try {
      const newTask = await createTask.mutateAsync({
        title: newTitle.trim(),
        description: "",
        projectId,
        status: initialStatus,
        priority: "no-priority",
      });

      await createRelation.mutateAsync({
        sourceTaskId: taskId,
        targetTaskId: newTask.id,
        relationType: "subtask",
      });

      setNewTitle("");
      setIsAdding(false);
    } catch {
      toast.error(t("tasks:subtasks.createError"));
    }
  };

  const handleDeleteTask = async () => {
    if (!deleteTaskId) return;
    try {
      await deleteTask(deleteTaskId);
      queryClient.invalidateQueries({ queryKey: ["tasks", projectId] });
      queryClient.invalidateQueries({ queryKey: ["task-relations", taskId] });
      setSelectedIds((prev) => {
        const next = new Set(prev);
        next.delete(deleteTaskId);
        return next;
      });
      toast.success(t("tasks:subtasks.deleteSuccess"), { icon: Trash2Icon });
    } catch (error) {
      toast.error(
        error instanceof Error
          ? error.message
          : t("tasks:subtasks.deleteError"),
      );
    } finally {
      setDeleteTaskId(null);
    }
  };

  return (
    <>
      <section className="flex flex-col gap-1">
        <SectionHeader
          title={t("tasks:subtasks.title")}
          meta={
            totalCount > 0 && (
              <span className="flex items-center gap-1.5 text-muted-foreground text-xs tabular-nums">
                <CircularProgress
                  completed={completedCount}
                  total={totalCount}
                  size={14}
                />
                {completedCount}/{totalCount}
              </span>
            )
          }
          action={
            canEdit &&
            canCreate && (
              <SectionAddButton
                data-task-action="addSubtask"
                aria-label={`${t("tasks:subtasks.addAction")} ${t("tasks:subtasks.title")}`}
                onClick={() => setIsAdding(true)}
                disabled={!canCreateSubtask}
              />
            )
          }
        />

        {/* eslint-disable-next-line jsx-a11y/no-static-element-interactions -- keyboard nav managed via document listener */}
        <div
          ref={containerRef}
          className="flex flex-col"
          onMouseDown={() => {
            if (focusedIndex === -1 && !hasSelection) {
              setFocusedIndex(0);
            }
          }}
        >
          <AnimatePresence
            key={relationsLoaded ? "loaded" : "loading"}
            initial={false}
          >
            {subtasks.map((subtask, index) => {
              const taskObj = buildTaskObject(subtask);
              const isSelected = selectedIds.has(subtask.task.id);

              return (
                <SubtaskRow
                  key={subtask.task.id}
                  task={taskObj}
                  tasks={getTargetTasks(taskObj)}
                  displayId={displayIdOf(
                    subtask.task.projectId,
                    subtask.task.number,
                  )}
                  projectId={subtask.task.projectId}
                  workspaceId={workspace?.id ?? workspaceId}
                  workspaceSlug={workspace?.slug}
                  isSelected={isSelected}
                  isFocused={focusedIndex === index}
                  isCompleted={subtask.task.isCompleted}
                  canEdit={canEdit}
                  selectionRadius={getSelectionRadius(index, isSelected)}
                  assignee={getAssignee(subtask.task.userId)}
                  onToggleComplete={() => handleToggleComplete(taskObj)}
                  onNavigate={() =>
                    navigate({
                      to: "/dashboard/workspace/$workspaceId/project/$projectId/task/$taskId",
                      params: {
                        workspaceId,
                        projectId: subtask.task.projectId,
                        taskId: subtask.task.id,
                      },
                    })
                  }
                  onDeleteClick={() => setDeleteTaskId(subtask.task.id)}
                />
              );
            })}
          </AnimatePresence>
        </div>

        {isAdding && canEdit && canCreate && (
          <div className="flex items-center gap-2 px-1 pt-1">
            <Input
              size="sm"
              placeholder={t("tasks:subtasks.inputPlaceholder")}
              value={newTitle}
              onChange={(e: React.ChangeEvent<HTMLInputElement>) =>
                setNewTitle(e.target.value)
              }
              onKeyDown={(e: React.KeyboardEvent<HTMLInputElement>) => {
                if (e.key === "Enter") handleAddSubtask();
                if (e.key === "Escape") {
                  e.stopPropagation();
                  setIsAdding(false);
                  setNewTitle("");
                }
              }}
              autoFocus
            />
            <Button
              size="xs"
              onClick={handleAddSubtask}
              disabled={
                !newTitle.trim() || createTask.isPending || !canCreateSubtask
              }
            >
              {t("tasks:subtasks.addAction")}
            </Button>
            <Button
              variant="ghost"
              size="xs"
              onClick={() => {
                setIsAdding(false);
                setNewTitle("");
              }}
            >
              {t("common:actions.cancel")}
            </Button>
          </div>
        )}

        {!isAdding && totalCount === 0 && (
          <p className="px-2 py-1 text-muted-foreground text-xs">
            {t("tasks:subtasks.empty")}
          </p>
        )}
      </section>

      <AlertDialog
        open={!!deleteTaskId}
        onOpenChange={(open) => !open && setDeleteTaskId(null)}
      >
        <AlertDialogContent>
          <AlertDialogHeader>
            <AlertDialogTitle>
              {t("tasks:subtasks.deleteDialogTitle")}
            </AlertDialogTitle>
            <AlertDialogDescription>
              {t("tasks:subtasks.deleteDialogDescription")}
            </AlertDialogDescription>
          </AlertDialogHeader>
          <AlertDialogFooter>
            <AlertDialogClose render={<Button variant="outline" size="sm" />}>
              {t("common:actions.cancel")}
            </AlertDialogClose>
            <AlertDialogClose
              render={
                <Button
                  variant="destructive"
                  size="sm"
                  onClick={handleDeleteTask}
                />
              }
            >
              {t("tasks:subtasks.deleteAction")}
            </AlertDialogClose>
          </AlertDialogFooter>
        </AlertDialogContent>
      </AlertDialog>
    </>
  );
}