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.

fix(web): faster drag and drop

pixo200058b6fa0c7a5b
diff --git a/apps/web/src/components/kanban-board/column/column-dropzone.tsx b/apps/web/src/components/kanban-board/column/column-dropzone.tsx
index fbeb24b54..e747f4879 100644
--- a/apps/web/src/components/kanban-board/column/column-dropzone.tsx
+++ b/apps/web/src/components/kanban-board/column/column-dropzone.tsx
@@ -3,63 +3,36 @@ import {
type SortingStrategy,
verticalListSortingStrategy,
} from "@dnd-kit/sortable";
-import { AnimatePresence, motion, useReducedMotion } from "framer-motion";
import type { ProjectWithTasks } from "@/types/project";
import TaskCard from "../task-card";
const keepOrder: SortingStrategy = () => null;
-const CARD_ENTER = { type: "spring", duration: 0.3, bounce: 0 } as const;
-const CARD_EXIT = { duration: 0.15, ease: [0.23, 1, 0.32, 1] } as const;
-
type ColumnDropzoneProps = {
column: ProjectWithTasks["columns"][number];
- activeTaskId: string | null;
disableDragDrop?: boolean;
disableSorting?: boolean;
};
export function ColumnDropzone({
column,
- activeTaskId,
disableDragDrop = false,
disableSorting = false,
}: ColumnDropzoneProps) {
- const reduceMotion = useReducedMotion();
- const hidden = reduceMotion
- ? { opacity: 0 }
- : { opacity: 0, transform: "scale(0.98)" };
- const shown = reduceMotion
- ? { opacity: 1 }
- : { opacity: 1, transform: "scale(1)" };
-
return (
<SortableContext
items={column.tasks}
strategy={disableSorting ? keepOrder : verticalListSortingStrategy}
>
<div className="flex flex-col gap-1.5">
- <AnimatePresence initial={false} mode="popLayout">
- {column.tasks.map((task) => (
- <motion.div
- key={task.id}
- initial={task.id === activeTaskId ? false : hidden}
- animate={shown}
- exit={
- task.id === activeTaskId
- ? undefined
- : { ...hidden, transition: CARD_EXIT }
- }
- transition={CARD_ENTER}
- >
- <TaskCard
- task={task}
- disableDragDrop={disableDragDrop}
- isFinalColumn={column.isFinal}
- />
- </motion.div>
- ))}
- </AnimatePresence>
+ {column.tasks.map((task) => (
+ <TaskCard
+ key={task.id}
+ task={task}
+ disableDragDrop={disableDragDrop}
+ isFinalColumn={column.isFinal}
+ />
+ ))}
</div>
</SortableContext>
);
diff --git a/apps/web/src/components/kanban-board/column/index.tsx b/apps/web/src/components/kanban-board/column/index.tsx
index 052280f84..670d76fd5 100644
--- a/apps/web/src/components/kanban-board/column/index.tsx
+++ b/apps/web/src/components/kanban-board/column/index.tsx
@@ -9,7 +9,6 @@ import { ColumnSortHint } from "./column-sort-hint";
type ColumnProps = {
column: ProjectWithTasks["columns"][number];
- activeTaskId: string | null;
sortHint?: string;
disableDragDrop?: boolean;
disableSorting?: boolean;
@@ -62,7 +61,6 @@ export const columnVariants = cva(
function Column({
column,
- activeTaskId,
sortHint,
disableDragDrop = false,
disableSorting = false,
@@ -91,7 +89,6 @@ function Column({
<div className="min-h-0 flex-1 overflow-y-auto overflow-x-hidden px-1.5 pt-1.5 pb-1.5 [-webkit-overflow-scrolling:touch]">
<ColumnDropzone
column={column}
- activeTaskId={activeTaskId}
disableDragDrop={disableDragDrop}
disableSorting={disableSorting}
/>
diff --git a/apps/web/src/components/kanban-board/filtered-drag.test.tsx b/apps/web/src/components/kanban-board/filtered-drag.test.tsx
index 65719e4c9..5c7e9ba6f 100644
--- a/apps/web/src/components/kanban-board/filtered-drag.test.tsx
+++ b/apps/web/src/components/kanban-board/filtered-drag.test.tsx
@@ -1,4 +1,4 @@
-import { cleanup, fireEvent, render } from "@testing-library/react";
+import { act, cleanup, fireEvent, render } from "@testing-library/react";
import {
afterEach,
beforeEach,
@@ -18,6 +18,8 @@ const mocks = vi.hoisted(() => ({
reorder: vi.fn(),
setQueryData: vi.fn(),
invalidateQueries: vi.fn(),
+ isReordering: false,
+ isFetching: false,
success: undefined as
| ((
result: unknown,
@@ -26,6 +28,7 @@ const mocks = vi.hoisted(() => ({
| undefined,
}));
vi.mock("@tanstack/react-query", () => ({
+ useIsFetching: () => Number(mocks.isFetching),
useQueryClient: () => ({
setQueryData: mocks.setQueryData,
invalidateQueries: mocks.invalidateQueries,
@@ -34,7 +37,7 @@ vi.mock("@tanstack/react-query", () => ({
}),
useMutation: ({ onSuccess }: { onSuccess: typeof mocks.success }) => {
mocks.success = onSuccess;
- return { mutate: mocks.reorder, isPending: false };
+ return { mutate: mocks.reorder, isPending: mocks.isReordering };
},
}));
vi.mock("@kaneo/libs", () => ({ client: {} }));
@@ -73,7 +76,7 @@ vi.mock("./column", () => ({
/>
),
}));
-vi.mock("./task-card", () => ({ default: () => null }));
+vi.mock("./task-card/task-card-content", () => ({ default: () => null }));
vi.mock("@dnd-kit/core", () => ({
DndContext: ({
children,
@@ -106,6 +109,11 @@ vi.mock("@dnd-kit/core", () => ({
<button onClick={drop("b")}>drop</button>
<button onClick={drop("a")}>drop-on-card</button>
<button onClick={drop("c")}>drop-c</button>
+ <button
+ onClick={() => onDragEnd({ active: { id: "b" }, over: { id: "c" } })}
+ >
+ drop-b-on-c
+ </button>
<button onClick={() => onDragEnd({ active: { id: "a" }, over: null })}>
drop-gap
</button>
@@ -124,7 +132,11 @@ vi.mock("@dnd-kit/core", () => ({
defaultDropAnimationSideEffects: vi.fn(),
}));
-beforeEach(() => vi.clearAllMocks());
+beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.isReordering = false;
+ mocks.isFetching = false;
+});
afterEach(cleanup);
describe("filtered board dragging", () => {
it("moves visible tasks in canonical state and sends one ordering mutation", () => {
@@ -203,6 +215,68 @@ it("rejects an in-flight Kanban drop after a failed refresh disables dragging",
expect(mocks.setQueryData).not.toHaveBeenCalled();
});
+it("queues a second task move through the first save and refresh", () => {
+ const canonical = {
+ id: "p",
+ columns: [
+ {
+ id: "todo",
+ slug: "todo",
+ tasks: [
+ { id: "a", status: "todo", position: 0 },
+ { id: "b", status: "todo", position: 1 },
+ ],
+ },
+ {
+ id: "doing",
+ slug: "doing",
+ tasks: [{ id: "c", status: "doing", position: 0 }],
+ },
+ ],
+ plannedTasks: [],
+ archivedTasks: [],
+ } as unknown as ProjectWithTasks;
+ mocks.project = canonical;
+ const view = render(<KanbanBoard project={canonical} />);
+ fireEvent.click(view.getByText("drop-c"));
+ expect(mocks.reorder).toHaveBeenCalledOnce();
+
+ const afterFirst = mocks.setProject.mock.calls[0][0];
+ mocks.project = afterFirst;
+ mocks.isReordering = true;
+ view.rerender(<KanbanBoard project={afterFirst} />);
+ fireEvent.click(view.getByText("drop-b-on-c"));
+ expect(mocks.reorder).toHaveBeenCalledOnce();
+ expect(view.getByTestId("column-doing")).toHaveAttribute(
+ "data-task-ids",
+ "c,b,a",
+ );
+
+ mocks.isReordering = false;
+ mocks.isFetching = true;
+ act(() => mocks.reorder.mock.calls[0][1].onSettled());
+ view.rerender(<KanbanBoard project={afterFirst} />);
+ expect(mocks.reorder).toHaveBeenCalledOnce();
+
+ mocks.isFetching = false;
+ view.rerender(<KanbanBoard project={afterFirst} />);
+ expect(mocks.reorder).toHaveBeenCalledTimes(2);
+ const request = mocks.reorder.mock.calls[1][0];
+ expect(request.previousBoard).toBe(afterFirst);
+ expect(request.tasks).toContainEqual(
+ expect.objectContaining({ id: "b", status: "doing" }),
+ );
+ expect(request.expectedTasks).toEqual(
+ afterFirst.columns.flatMap((column: ProjectWithTasks["columns"][number]) =>
+ column.tasks.map(({ id, position, status }) => ({
+ id,
+ position,
+ status,
+ })),
+ ),
+ );
+});
+
it("refreshes personal work after a cross-column status change", () => {
const project = {
id: "p",
diff --git a/apps/web/src/components/kanban-board/index.tsx b/apps/web/src/components/kanban-board/index.tsx
index 51f41125e..92b7c4f38 100644
--- a/apps/web/src/components/kanban-board/index.tsx
+++ b/apps/web/src/components/kanban-board/index.tsx
@@ -15,7 +15,7 @@ import {
useSensor,
useSensors,
} from "@dnd-kit/core";
-import { useQueryClient } from "@tanstack/react-query";
+import { useIsFetching, useQueryClient } from "@tanstack/react-query";
import { useMutation } from "@tanstack/react-query";
import reorderTasks, { type TaskReorder } from "@/fetchers/task/reorder-tasks";
import { toast } from "@/lib/toast";
@@ -26,7 +26,7 @@ import { findTaskColumn } from "./drag-preview/find-task-column";
import { moveBoardTask } from "./move-task";
import { useDragPreview } from "./drag-preview/use-drag-preview";
import { useReducedMotion } from "framer-motion";
-import { useEffect, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
import { useTaskViewShortcuts } from "@/components/project/task-view-keys/use-task-view-shortcuts";
import { useProjectBackground } from "@/hooks/use-project-background";
import { cn } from "@/lib/cn";
@@ -37,7 +37,9 @@ import useProjectStore from "@/store/project";
import type { ProjectWithTasks } from "@/types/project";
import BulkToolbar from "../bulk-selection/bulk-toolbar";
import Column from "./column";
-import TaskCard from "./task-card";
+import TaskCardContent from "./task-card/task-card-content";
+import { useBoardMoveQueue } from "./use-board-move-queue";
+import { previewBoardMoves } from "./preview-board-moves";
type KanbanBoardProps = {
project: ProjectWithTasks;
@@ -56,6 +58,8 @@ function KanbanBoard({
}: KanbanBoardProps) {
const isAutomaticallySorted = sortedByNumber || sortedByPriority;
const queryClient = useQueryClient();
+ const isFetching =
+ useIsFetching({ queryKey: ["tasks", project.id], exact: true }) > 0;
const { project: storedProject, setProject } = useProjectStore();
const setAvailableTasks = useBulkSelectionStore(
(state) => state.setAvailableTasks,
@@ -64,7 +68,6 @@ function KanbanBoard({
const [activeIsFinal, setActiveIsFinal] = useState<boolean | undefined>();
const [activeId, setActiveId] = useState<UniqueIdentifier | null>(null);
const [sortHintColumnId, setSortHintColumnId] = useState<string | null>(null);
- const dragPreview = useDragPreview(project);
const { t } = useTranslation();
const { mutate: reorder, isPending: isReordering } = useMutation({
mutationFn: ({
@@ -169,14 +172,8 @@ function KanbanBoard({
dragPreview.clear();
};
- const isDropBlocked = () =>
- disableDragDrop ||
- isReordering ||
- queryClient.getQueryState(["tasks", project.id])?.fetchStatus ===
- "fetching";
-
const handleDragOver = ({ active, over }: DragOverEvent) => {
- if (!over || isDropBlocked()) {
+ if (!over || disableDragDrop) {
setSortHintColumnId(null);
dragPreview.clear();
return;
@@ -186,41 +183,68 @@ function KanbanBoard({
return;
}
setSortHintColumnId(
- findTaskColumn(project, over.id.toString())?.id ?? null,
+ findTaskColumn(queuedProject, over.id.toString())?.id ?? null,
);
};
const commitMove = (
activeId: string,
overId: string,
+ onSettled: () => void,
insertAfterTarget?: boolean,
) => {
- if (!project?.columns || isDropBlocked()) return;
+ if (!project?.columns || disableDragDrop) {
+ onSettled();
+ return;
+ }
const canonical = selectReorderBoard(
project.id,
activeId,
queryClient.getQueryData<ProjectWithTasks>(["tasks", project.id]),
storedProject,
);
- if (!canonical) return;
+ if (!canonical) {
+ onSettled();
+ return;
+ }
const moved =
insertAfterTarget === undefined
? moveBoardTask(canonical, activeId, overId, isAutomaticallySorted)
: moveBoardTask(canonical, activeId, overId, false, insertAfterTarget);
- if (!moved || !moved.tasks.length) return;
+ if (!moved || !moved.tasks.length) {
+ onSettled();
+ return;
+ }
for (const task of moved.tasks)
markBoardCacheChanged(queryClient, project.id, task.id);
setProject(moved.project);
queryClient.setQueryData(["tasks", project.id], moved.project);
- reorder({
- projectId: project.id,
- tasks: moved.tasks,
- expectedTasks: moved.expectedTasks,
- previousBoard: canonical,
- });
+ reorder(
+ {
+ projectId: project.id,
+ tasks: moved.tasks,
+ expectedTasks: moved.expectedTasks,
+ previousBoard: canonical,
+ },
+ { onSettled },
+ );
};
+ const { queueMove, pendingMoves } = useBoardMoveQueue({
+ projectId: project.id,
+ waiting: isReordering || isFetching,
+ disabled: disableDragDrop,
+ onMove: ({ activeId, overId, insertAfterTarget }, onSettled) =>
+ commitMove(activeId, overId, onSettled, insertAfterTarget),
+ onCancel: () => toast.error(t("tasks:board.reorderFailed")),
+ });
+ const queuedProject = useMemo(
+ () => previewBoardMoves(project, pendingMoves, isAutomaticallySorted),
+ [project, pendingMoves, isAutomaticallySorted],
+ );
+ const dragPreview = useDragPreview(queuedProject);
+
const handleDragEnd = ({ active, over }: DragEndEvent) => {
const activeId = active.id.toString();
const overId = over?.id.toString();
@@ -229,9 +253,11 @@ function KanbanBoard({
: null;
resetDrag();
if (!overId) return;
- if (placement)
- commitMove(activeId, placement.overId, placement.insertAfterTarget);
- else commitMove(activeId, overId);
+ queueMove({
+ activeId,
+ overId: placement?.overId ?? overId,
+ insertAfterTarget: placement?.insertAfterTarget,
+ });
};
useTaskViewShortcuts({
@@ -245,7 +271,7 @@ function KanbanBoard({
project,
enabled: activeId === null,
canMove: !disableDragDrop,
- onMove: (taskId, overId) => commitMove(taskId, overId),
+ onMove: (activeId, overId) => queueMove({ activeId, overId }),
});
if (!project?.columns) {
@@ -291,7 +317,7 @@ function KanbanBoard({
}
const activeTask = activeId
- ? project.columns
+ ? queuedProject.columns
.flatMap((col) => col.tasks)
.find((task) => task.id === activeId)
: null;
@@ -324,14 +350,13 @@ function KanbanBoard({
)}
>
<div className="flex h-full min-w-max gap-4 px-4 py-4 md:px-5">
- {(dragPreview.preview ?? project).columns.map((column) => (
+ {(dragPreview.preview ?? queuedProject).columns.map((column) => (
<div
key={column.id}
className="h-full max-w-96 min-w-[min(20rem,calc(100vw-4.5rem))] shrink-0 flex-1 snap-start"
>
<Column
column={column}
- activeTaskId={activeId?.toString() ?? null}
sortHint={
column.id === sortHintColumnId
? t("tasks:kanban.automaticallySortedHint", {
@@ -356,7 +381,12 @@ function KanbanBoard({
{activeTask ? (
<div className="rotate-1 scale-[1.03] shadow-lg transition-[rotate,scale] duration-150 ease-out starting:rotate-0 starting:scale-100 motion-reduce:transition-none">
<div className="ring-2 ring-ring/35 rounded-lg">
- <TaskCard task={activeTask} isFinalColumn={activeIsFinal} />
+ <TaskCardContent
+ task={activeTask}
+ isFinalColumn={activeIsFinal}
+ disableDragDrop
+ isDragging
+ />
</div>
</div>
) : null}
diff --git a/apps/web/src/components/kanban-board/preview-board-moves.ts b/apps/web/src/components/kanban-board/preview-board-moves.ts
new file mode 100644
index 000000000..d645f362d
--- /dev/null
+++ b/apps/web/src/components/kanban-board/preview-board-moves.ts
@@ -0,0 +1,21 @@
+import type { ProjectWithTasks } from "@/types/project";
+import { moveBoardTask } from "./move-task";
+import type { BoardMove } from "./use-board-move-queue";
+
+export function previewBoardMoves(
+ project: ProjectWithTasks,
+ moves: BoardMove[],
+ appendOnly: boolean,
+) {
+ return moves.reduce(
+ (board, move) =>
+ moveBoardTask(
+ board,
+ move.activeId,
+ move.overId,
+ appendOnly,
+ move.insertAfterTarget,
+ )?.project ?? board,
+ project,
+ );
+}
diff --git a/apps/web/src/components/kanban-board/task-card/index.tsx b/apps/web/src/components/kanban-board/task-card/index.tsx
index 7fc89360d..3bc3d8a88 100644
--- a/apps/web/src/components/kanban-board/task-card/index.tsx
+++ b/apps/web/src/components/kanban-board/task-card/index.tsx
@@ -67,7 +67,7 @@ function TaskCard({
if (event.target !== event.currentTarget) return;
setFocusedTask(isKeyboardFocus(event) ? task.id : null);
}}
- className="outline-none"
+ className="select-none outline-none"
>
<TaskCardContent
task={task}
diff --git a/apps/web/src/components/kanban-board/use-board-move-queue.test.ts b/apps/web/src/components/kanban-board/use-board-move-queue.test.ts
new file mode 100644
index 000000000..7a5e038ab
--- /dev/null
+++ b/apps/web/src/components/kanban-board/use-board-move-queue.test.ts
@@ -0,0 +1,106 @@
+import { act, renderHook } from "@testing-library/react";
+import { expect, it, vi } from "vite-plus/test";
+import { type BoardMove, useBoardMoveQueue } from "./use-board-move-queue";
+
+it("preserves the order and exact placement of quick follow-up drops", () => {
+ const onMove = vi.fn((_move: BoardMove, onSettled: () => void) =>
+ onSettled(),
+ );
+ const onCancel = vi.fn();
+ const { result, rerender } = renderHook(
+ ({ waiting }) =>
+ useBoardMoveQueue({
+ projectId: "p",
+ waiting,
+ disabled: false,
+ onMove,
+ onCancel,
+ }),
+ { initialProps: { waiting: true } },
+ );
+ const first = { activeId: "a", overId: "b", insertAfterTarget: false };
+ const second = { activeId: "c", overId: "d", insertAfterTarget: true };
+ act(() => {
+ result.current.queueMove(first);
+ result.current.queueMove(second);
+ });
+
+ expect(onMove).not.toHaveBeenCalled();
+ rerender({ waiting: false });
+ expect(onMove.mock.calls.map(([move]) => move)).toEqual([
+ { ...first, projectId: "p" },
+ { ...second, projectId: "p" },
+ ]);
+ expect(onCancel).not.toHaveBeenCalled();
+});
+
+it("waits for each save even before the mutation's pending state renders", () => {
+ const onMove = vi.fn();
+ const { result } = renderHook(() =>
+ useBoardMoveQueue({
+ projectId: "p",
+ waiting: false,
+ disabled: false,
+ onMove,
+ onCancel: vi.fn(),
+ }),
+ );
+ act(() => {
+ result.current.queueMove({ activeId: "a", overId: "b" });
+ result.current.queueMove({ activeId: "c", overId: "d" });
+ });
+ expect(onMove).toHaveBeenCalledOnce();
+ act(() => onMove.mock.calls[0][1]());
+ expect(onMove).toHaveBeenCalledTimes(2);
+});
+
+it("applies an idle drop synchronously before the drag preview is cleared", () => {
+ const onMove = vi.fn();
+ const { result } = renderHook(() =>
+ useBoardMoveQueue({
+ projectId: "p",
+ waiting: false,
+ disabled: false,
+ onMove,
+ onCancel: vi.fn(),
+ }),
+ );
+ act(() => {
+ result.current.queueMove({ activeId: "a", overId: "b" });
+ expect(onMove).toHaveBeenCalledOnce();
+ });
+});
+
+it.each(["disabled", "project"] as const)(
+ "reports and clears queued moves when %s changes",
+ (change) => {
+ const onMove = vi.fn();
+ const onCancel = vi.fn();
+ const { result, rerender } = renderHook(
+ ({ projectId, disabled, waiting }) =>
+ useBoardMoveQueue({
+ projectId,
+ disabled,
+ waiting,
+ onMove,
+ onCancel,
+ }),
+ {
+ initialProps: {
+ projectId: "p",
+ disabled: false,
+ waiting: true,
+ },
+ },
+ );
+ act(() => result.current.queueMove({ activeId: "a", overId: "b" }));
+ rerender({
+ projectId: change === "project" ? "other" : "p",
+ disabled: change === "disabled",
+ waiting: true,
+ });
+ expect(onCancel).toHaveBeenCalledOnce();
+ rerender({ projectId: "p", disabled: false, waiting: false });
+ expect(onMove).not.toHaveBeenCalled();
+ },
+);
diff --git a/apps/web/src/components/kanban-board/use-board-move-queue.ts b/apps/web/src/components/kanban-board/use-board-move-queue.ts
new file mode 100644
index 000000000..0e0002918
--- /dev/null
+++ b/apps/web/src/components/kanban-board/use-board-move-queue.ts
@@ -0,0 +1,63 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export type BoardMove = {
+ activeId: string;
+ overId: string;
+ insertAfterTarget?: boolean;
+};
+
+export function useBoardMoveQueue({
+ projectId,
+ waiting,
+ disabled,
+ onMove,
+ onCancel,
+}: {
+ projectId: string;
+ waiting: boolean;
+ disabled: boolean;
+ onMove: (move: BoardMove, onSettled: () => void) => void;
+ onCancel: () => void;
+}) {
+ const [queue, setQueue] = useState<Array<BoardMove & { projectId: string }>>(
+ [],
+ );
+ const processing = useRef(false);
+
+ const processMove = useCallback(
+ (move: BoardMove) => {
+ // Mutation pending state can lag the next queued drop.
+ processing.current = true;
+ onMove(move, () => {
+ processing.current = false;
+ setQueue((queue) => [...queue]);
+ });
+ },
+ [onMove],
+ );
+
+ useEffect(() => {
+ if (!queue.length) return;
+ if (disabled || queue[0].projectId !== projectId) {
+ setQueue([]);
+ onCancel();
+ return;
+ }
+ if (waiting || processing.current) return;
+ const [move, ...remaining] = queue;
+ setQueue(remaining);
+ processMove(move);
+ }, [queue, projectId, waiting, disabled, processMove, onCancel]);
+
+ const queueMove = (move: BoardMove) => {
+ if (!disabled) {
+ if (!waiting && !processing.current && !queue.length) {
+ processMove(move);
+ } else {
+ setQueue((queue) => [...queue, { ...move, projectId }]);
+ }
+ }
+ };
+
+ return { queueMove, pendingMoves: queue };
+}
diff --git a/apps/web/src/routes/_layout/_authenticated/dashboard/workspace/$workspaceId/project/$projectId/board.tsx b/apps/web/src/routes/_layout/_authenticated/dashboard/workspace/$workspaceId/project/$projectId/board.tsx
index 8a85a6644..7b09fda4a 100644
--- a/apps/web/src/routes/_layout/_authenticated/dashboard/workspace/$workspaceId/project/$projectId/board.tsx
+++ b/apps/web/src/routes/_layout/_authenticated/dashboard/workspace/$workspaceId/project/$projectId/board.tsx
@@ -85,6 +85,7 @@ function RouteComponent() {
data,
isError: boardError,
isFetching: boardFetching,
+ isSuccess: boardLoaded,
refetch: retryBoard,
} = useGetTasks(projectId);
const { project, setProject } = useProjectStore();
@@ -217,7 +218,7 @@ function RouteComponent() {
project={sortedProject}
disableCollectionActions={boardFetching || boardError}
disableDragDrop={
- boardFetching ||
+ (boardFetching && !boardLoaded) ||
boardError ||
(sort.field !== "position" &&
sort.field !== "number" &&