@tuturuuu/ui 0.17.0 → 0.19.0

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-drag-cache.ts

@@ -1,367 +0,0 @@
-import type { QueryClient } from '@tanstack/react-query';
-import type { Task } from '@tuturuuu/types/primitives/Task';
-import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
-import { MAX_SAFE_INTEGER_SORT } from '../kanban-constants';
-import type { DragCacheSnapshot, TaskSortKeyRepair } from './task-drag-types';
-import { getEffectiveTaskSortKey } from './task-sort-key';
-
-const SORT_KEY_BASE_UNIT = 1_000_000;
-const SORT_KEY_DEFAULT = SORT_KEY_BASE_UNIT * 1000;
-const SORT_KEY_MIN_GAP = 1000;
-
-type SortKeyPlanTask = Pick<
-  Task,
-  | 'id'
-  | 'is_personal_external'
-  | 'is_personal_external_default'
-  | 'personal_sort_key'
-  | 'sort_key'
->;
-
-function getTaskSortKeyInsertionContext({
-  activeTaskId,
-  orderedTasks,
-}: {
-  activeTaskId: string;
-  orderedTasks: SortKeyPlanTask[];
-}) {
-  const activeIndex = orderedTasks.findIndex(
-    (task) => task.id === activeTaskId
-  );
-  if (activeIndex === -1) {
-    return {
-      activeIndex,
-      nextSortKey: null,
-      previousSortKey: null,
-    };
-  }
-
-  const nextTask = orderedTasks[activeIndex + 1];
-  const previousTask = orderedTasks[activeIndex - 1];
-
-  return {
-    activeIndex,
-    nextSortKey: nextTask ? getEffectiveTaskSortKey(nextTask) : null,
-    previousSortKey: previousTask
-      ? getEffectiveTaskSortKey(previousTask)
-      : null,
-  };
-}
-
-function hasRepresentableSortKeyGap(
-  previousSortKey: number | null,
-  nextSortKey: number | null
-) {
-  if (previousSortKey === null) {
-    return nextSortKey === null || nextSortKey >= SORT_KEY_MIN_GAP;
-  }
-
-  if (nextSortKey === null) {
-    return true;
-  }
-
-  return nextSortKey - previousSortKey >= SORT_KEY_MIN_GAP;
-}
-
-function getRepairedSortKeyForIndex(index: number) {
-  return (index + 1) * SORT_KEY_BASE_UNIT;
-}
-
-function getDeterministicPreviewSortKey({
-  nextSortKey,
-  previousSortKey,
-}: {
-  nextSortKey: number | null;
-  previousSortKey: number | null;
-}) {
-  if (previousSortKey === null) {
-    if (nextSortKey === null) return SORT_KEY_DEFAULT;
-    if (nextSortKey <= 1) return SORT_KEY_DEFAULT;
-
-    const halfNext = Math.floor(nextSortKey / 2);
-
-    if (nextSortKey <= SORT_KEY_MIN_GAP) {
-      return Math.max(1, Math.min(halfNext, nextSortKey - 1));
-    }
-
-    return Math.max(
-      halfNext,
-      Math.min(SORT_KEY_BASE_UNIT, nextSortKey - SORT_KEY_MIN_GAP)
-    );
-  }
-
-  if (nextSortKey === null) {
-    return previousSortKey + SORT_KEY_BASE_UNIT;
-  }
-
-  const gap = nextSortKey - previousSortKey;
-
-  if (gap <= 1) {
-    return previousSortKey + SORT_KEY_BASE_UNIT;
-  }
-
-  return Math.floor((previousSortKey + nextSortKey) / 2);
-}
-
-function getPreviewSortKeyPlan({
-  activeTaskId,
-  orderedTasks,
-  targetListId,
-}: {
-  activeTaskId: string;
-  orderedTasks: SortKeyPlanTask[];
-  targetListId: string;
-}): {
-  previewSortKey: number;
-  repairedTaskSortKeys: TaskSortKeyRepair[];
-} {
-  const { activeIndex, nextSortKey, previousSortKey } =
-    getTaskSortKeyInsertionContext({
-      activeTaskId,
-      orderedTasks,
-    });
-
-  if (activeIndex === -1) {
-    return {
-      previewSortKey: MAX_SAFE_INTEGER_SORT,
-      repairedTaskSortKeys: [],
-    };
-  }
-
-  const previewSortKey = getDeterministicPreviewSortKey({
-    nextSortKey,
-    previousSortKey,
-  });
-  const effectiveOrderedTasks = orderedTasks.map((task) => ({
-    ...task,
-    effective_sort_key:
-      task.id === activeTaskId ? previewSortKey : getEffectiveTaskSortKey(task),
-  }));
-  const orderNeedsRepair = effectiveOrderedTasks.some((task, index) => {
-    if (
-      typeof task.effective_sort_key !== 'number' ||
-      !Number.isFinite(task.effective_sort_key)
-    ) {
-      return true;
-    }
-
-    const previousTask = effectiveOrderedTasks[index - 1];
-    if (!previousTask) return false;
-
-    if (
-      typeof previousTask.effective_sort_key !== 'number' ||
-      !Number.isFinite(previousTask.effective_sort_key)
-    ) {
-      return true;
-    }
-
-    return (
-      task.effective_sort_key - previousTask.effective_sort_key <
-      SORT_KEY_MIN_GAP
-    );
-  });
-
-  if (
-    !hasRepresentableSortKeyGap(previousSortKey, nextSortKey) ||
-    orderNeedsRepair
-  ) {
-    return {
-      previewSortKey: getRepairedSortKeyForIndex(activeIndex),
-      repairedTaskSortKeys: orderedTasks.map((task, index) => ({
-        listId: targetListId,
-        sortKey: getRepairedSortKeyForIndex(index),
-        taskId: task.id,
-      })),
-    };
-  }
-
-  return {
-    previewSortKey,
-    repairedTaskSortKeys: [],
-  };
-}
-
-export function getTaskDropPreviewCacheTasks({
-  activeTask,
-  localMutationAt = Date.now(),
-  orderedTasks,
-  tasks,
-  targetList,
-  targetListId,
-}: {
-  activeTask: Task;
-  localMutationAt?: number;
-  orderedTasks: Task[];
-  tasks: Task[] | undefined;
-  targetList: TaskList | undefined;
-  targetListId: string;
-}) {
-  if (!tasks) return { previewSortKey: null, tasks };
-
-  const { previewSortKey, repairedTaskSortKeys } = getPreviewSortKeyPlan({
-    activeTaskId: activeTask.id,
-    orderedTasks,
-    targetListId,
-  });
-  const repairedSortKeysByTaskId = new Map(
-    repairedTaskSortKeys.map((repair) => [repair.taskId, repair.sortKey])
-  );
-  const mutationTimestamp = new Date(localMutationAt).toISOString();
-  const targetIsCompleted = targetList?.status === 'done';
-  const targetIsTerminal = targetList?.status === 'closed';
-
-  return {
-    previewSortKey,
-    repairedTaskSortKeys,
-    tasks: tasks.map((task) =>
-      task.id === activeTask.id
-        ? ({
-            ...task,
-            list_id: targetListId,
-            sort_key: previewSortKey,
-            personal_sort_key: task.is_personal_external
-              ? previewSortKey
-              : task.personal_sort_key,
-            completed: targetIsCompleted,
-            completed_at: targetIsCompleted
-              ? (task.completed_at ?? mutationTimestamp)
-              : null,
-            closed_at: targetIsTerminal
-              ? (task.closed_at ?? mutationTimestamp)
-              : null,
-            _localMutationAt: localMutationAt,
-          } as Task & { _localMutationAt: number })
-        : repairedSortKeysByTaskId.has(task.id)
-          ? ({
-              ...task,
-              sort_key: repairedSortKeysByTaskId.get(task.id) ?? task.sort_key,
-              personal_sort_key: task.is_personal_external
-                ? (repairedSortKeysByTaskId.get(task.id) ??
-                  task.personal_sort_key)
-                : task.personal_sort_key,
-              _localMutationAt: localMutationAt,
-            } as Task & { _localMutationAt: number })
-          : task
-    ),
-  };
-}
-
-export function applyTaskDropPreviewToCache({
-  activeTask,
-  boardId,
-  orderedTasks,
-  queryClient,
-  snapshot,
-  targetList,
-  targetListId,
-}: {
-  activeTask: Task;
-  boardId: string | null;
-  orderedTasks: Task[];
-  queryClient: QueryClient;
-  snapshot: DragCacheSnapshot;
-  targetList: TaskList | undefined;
-  targetListId: string;
-}) {
-  if (!boardId) return null;
-
-  const localMutationAt = Date.now();
-  const previewTasks = getTaskDropPreviewCacheTasks({
-    activeTask,
-    localMutationAt,
-    orderedTasks,
-    tasks: snapshot.tasks,
-    targetList,
-    targetListId,
-  });
-  const previewFullTasks = getTaskDropPreviewCacheTasks({
-    activeTask,
-    localMutationAt,
-    orderedTasks,
-    tasks: snapshot.fullTasks,
-    targetList,
-    targetListId,
-  });
-
-  if (previewTasks.tasks) {
-    queryClient.setQueryData(['tasks', boardId], previewTasks.tasks);
-  }
-
-  if (previewFullTasks.tasks) {
-    queryClient.setQueryData(['tasks-full', boardId], previewFullTasks.tasks);
-  }
-
-  return {
-    localMutationAt,
-    previousFullTasks: snapshot.fullTasks,
-    previousTasks: snapshot.tasks,
-    previewSortKey: previewTasks.previewSortKey,
-    repairedTaskSortKeys: previewTasks.repairedTaskSortKeys,
-  };
-}
-
-export function hasTaskLocalMutationAt(
-  tasks: Task[] | undefined,
-  taskId: string,
-  localMutationAt: number
-) {
-  const task = tasks?.find((item) => item.id === taskId) as
-    | (Task & { _localMutationAt?: unknown })
-    | undefined;
-
-  return task?._localMutationAt === localMutationAt;
-}
-
-export function mergeTaskIntoBoardTaskCache(
-  currentTasks: Task[] | undefined,
-  nextTask: Task
-) {
-  const existingTasks = currentTasks ?? [];
-  let found = false;
-
-  const mergedTasks = existingTasks.map((task) => {
-    if (task.id !== nextTask.id) return task;
-    found = true;
-    return { ...task, ...nextTask } as Task;
-  });
-
-  return found ? mergedTasks : [...mergedTasks, nextTask];
-}
-
-export function setBoardTaskCache(
-  queryClient: QueryClient,
-  boardId: string,
-  nextTask: Task
-) {
-  queryClient.setQueryData(['tasks', boardId], (old: Task[] | undefined) =>
-    mergeTaskIntoBoardTaskCache(old, nextTask)
-  );
-
-  if (queryClient.getQueryData<Task[]>(['tasks-full', boardId])) {
-    queryClient.setQueryData(
-      ['tasks-full', boardId],
-      (old: Task[] | undefined) => mergeTaskIntoBoardTaskCache(old, nextTask)
-    );
-  }
-}
-
-export function mergePersonalPlacementMutationTask(
-  task: Task,
-  nextTask: Task & { _localMutationAt: number },
-  responseTask: Task | undefined,
-  isStagingTarget: boolean
-) {
-  return {
-    ...nextTask,
-    ...(responseTask ?? {}),
-    assignees: task.assignees,
-    labels: task.labels,
-    projects: task.projects,
-    list_id: responseTask?.list_id ?? nextTask.list_id,
-    sort_key: responseTask?.sort_key ?? nextTask.sort_key,
-    personal_sort_key:
-      responseTask?.personal_sort_key ?? nextTask.personal_sort_key,
-    is_personal_external_default: isStagingTarget,
-    _localMutationAt: nextTask._localMutationAt,
-  } as Task & { _localMutationAt: number };
-}

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-drag-geometry.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  getFrozenActiveRectFromDelta,
-  getTaskDropPositionFromRects,
-} from './task-drag-geometry';
-
-describe('task drag geometry', () => {
-  it('derives the active card rect from frozen drag-start top plus dnd delta', () => {
-    expect(
-      getFrozenActiveRectFromDelta({
-        deltaY: -72,
-        dragSession: {
-          activeInitialRect: { height: 118.4, top: 420 },
-          activeTaskId: 'task-4',
-          height: 118.4,
-          sourceInsertionIndex: 3,
-          sourceListId: 'list-1',
-        },
-        fallbackRect: { height: 20, top: 999 },
-      })
-    ).toEqual({ height: 118, top: 348 });
-  });
-
-  it('falls back to the supplied rect when no frozen drag session is available', () => {
-    expect(
-      getFrozenActiveRectFromDelta({
-        deltaY: 40,
-        fallbackRect: { height: 87.8, top: 120 },
-      })
-    ).toEqual({ height: 88, top: 120 });
-  });
-
-  it('prefers the translated active top while keeping the frozen active height', () => {
-    expect(
-      getFrozenActiveRectFromDelta({
-        deltaY: 0,
-        dragSession: {
-          activeInitialRect: { height: 118.4, top: 420 },
-          activeTaskId: 'task-4',
-          height: 118.4,
-          sourceInsertionIndex: 3,
-          sourceListId: 'list-1',
-        },
-        fallbackRect: { height: 20, top: 999 },
-        translatedRect: { height: 20, top: 310 },
-      })
-    ).toEqual({ height: 118, top: 310 });
-  });
-
-  it('keeps pointer y as the strongest before/after signal for non-preview fallback drops', () => {
-    expect(
-      getTaskDropPositionFromRects({
-        activeRect: { height: 120, top: 180 },
-        overRect: { height: 80, top: 100 },
-        pointerY: 120,
-      })
-    ).toBe('before');
-
-    expect(
-      getTaskDropPositionFromRects({
-        activeRect: { height: 80, top: 20 },
-        overRect: { height: 80, top: 100 },
-        pointerY: 170,
-      })
-    ).toBe('after');
-  });
-});

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-drag-geometry.ts

@@ -1,94 +0,0 @@
-import type {
-  DragSessionMetrics,
-  TaskDropPosition,
-  TaskRect,
-  VerticalRect,
-} from './task-drag-types';
-
-export function getRectCenterY(rect: VerticalRect) {
-  return rect.top + rect.height / 2;
-}
-
-export function getRectBottom(rect: VerticalRect) {
-  return rect.top + rect.height;
-}
-
-export function getStationaryTaskRects(
-  rects: TaskRect[],
-  activeTaskId: string
-) {
-  return [...rects]
-    .filter((rect) => rect.taskId !== activeTaskId && rect.height > 0)
-    .sort((a, b) => {
-      const indexA = a.originalIndex ?? Number.MAX_SAFE_INTEGER;
-      const indexB = b.originalIndex ?? Number.MAX_SAFE_INTEGER;
-
-      if (indexA !== indexB) {
-        return indexA - indexB;
-      }
-
-      return a.top - b.top;
-    });
-}
-
-export function getTaskDropPositionFromRects({
-  activeRect,
-  overRect,
-  pointerY,
-}: {
-  activeRect?: VerticalRect | null;
-  overRect?: VerticalRect | null;
-  pointerY?: number | null;
-}): TaskDropPosition {
-  if (!overRect) return 'before';
-
-  if (typeof pointerY === 'number') {
-    return pointerY >= overRect.top + overRect.height / 2 ? 'after' : 'before';
-  }
-
-  if (!activeRect) return 'before';
-
-  const activeCenterY = getRectCenterY(activeRect);
-  const overCenterY = getRectCenterY(overRect);
-
-  return activeCenterY >= overCenterY ? 'after' : 'before';
-}
-
-export function getFrozenActiveRectFromDelta({
-  deltaY,
-  dragSession,
-  fallbackRect,
-  translatedRect,
-}: {
-  deltaY?: number | null;
-  dragSession?: DragSessionMetrics | null;
-  fallbackRect?: VerticalRect | null;
-  translatedRect?: VerticalRect | null;
-}): VerticalRect | null {
-  const initialRect = dragSession?.activeInitialRect;
-  const frozenHeight = Math.max(
-    1,
-    Math.round(dragSession?.height || initialRect?.height || 0)
-  );
-
-  if (translatedRect) {
-    return {
-      height: frozenHeight || Math.max(1, Math.round(translatedRect.height)),
-      top: translatedRect.top,
-    };
-  }
-
-  if (initialRect && typeof deltaY === 'number' && Number.isFinite(deltaY)) {
-    return {
-      height: frozenHeight,
-      top: initialRect.top + deltaY,
-    };
-  }
-
-  if (!fallbackRect) return null;
-
-  return {
-    height: Math.max(1, Math.round(fallbackRect.height)),
-    top: fallbackRect.top,
-  };
-}

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-drag-order.ts

@@ -1,150 +0,0 @@
-import type { Task } from '@tuturuuu/types/primitives/Task';
-import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
-import type { DragPreviewPosition, TaskDropPosition } from './task-drag-types';
-import { compareTasksByEffectiveSortKey } from './task-sort-key';
-
-export function getNeighborTaskIds(tasks: Task[], taskId: string) {
-  const taskIndex = tasks.findIndex((task) => task.id === taskId);
-
-  if (taskIndex === -1) {
-    return {
-      previousTaskId: null,
-      nextTaskId: null,
-    };
-  }
-
-  return {
-    previousTaskId: tasks[taskIndex - 1]?.id ?? null,
-    nextTaskId: tasks[taskIndex + 1]?.id ?? null,
-  };
-}
-
-export function getTaskInsertionIndex({
-  overTaskId,
-  position,
-  tasks,
-}: {
-  overTaskId: string;
-  position: TaskDropPosition;
-  tasks: Pick<Task, 'id'>[];
-}) {
-  const overIndex = tasks.findIndex((task) => task.id === overTaskId);
-  if (overIndex === -1) return tasks.length;
-
-  return overIndex + (position === 'after' ? 1 : 0);
-}
-
-export function insertTaskAtDropPosition({
-  activeTask,
-  overTaskId,
-  position,
-  targetListTasks,
-}: {
-  activeTask: Task;
-  overTaskId: string;
-  position: TaskDropPosition;
-  targetListTasks: Task[];
-}) {
-  const tasksWithoutActive = targetListTasks.filter(
-    (task) => task.id !== activeTask.id
-  );
-  const insertionIndex = getTaskInsertionIndex({
-    overTaskId,
-    position,
-    tasks: tasksWithoutActive,
-  });
-
-  return [
-    ...tasksWithoutActive.slice(0, insertionIndex),
-    activeTask,
-    ...tasksWithoutActive.slice(insertionIndex),
-  ];
-}
-
-export function insertTaskAtInsertionIndex({
-  activeTask,
-  insertionIndex,
-  targetListTasks,
-}: {
-  activeTask: Task;
-  insertionIndex: number;
-  targetListTasks: Task[];
-}) {
-  const tasksWithoutActive = targetListTasks.filter(
-    (task) => task.id !== activeTask.id
-  );
-  const safeInsertionIndex = Math.max(
-    0,
-    Math.min(insertionIndex, tasksWithoutActive.length)
-  );
-
-  return [
-    ...tasksWithoutActive.slice(0, safeInsertionIndex),
-    activeTask,
-    ...tasksWithoutActive.slice(safeInsertionIndex),
-  ];
-}
-
-export function getProjectedTaskDropOrderFromPreview({
-  activeTask,
-  isCompletionList,
-  preview,
-  targetListTasks,
-}: {
-  activeTask: Task;
-  isCompletionList: boolean;
-  preview: DragPreviewPosition | null;
-  targetListTasks: Task[];
-}) {
-  const targetListTasksWithoutActive = targetListTasks.filter(
-    (task) => task.id !== activeTask.id
-  );
-
-  if (isCompletionList) {
-    return [activeTask, ...targetListTasksWithoutActive];
-  }
-
-  if (!preview) {
-    return [...targetListTasksWithoutActive, activeTask];
-  }
-
-  return insertTaskAtInsertionIndex({
-    activeTask,
-    insertionIndex: preview.insertionIndex,
-    targetListTasks,
-  });
-}
-
-export function sortTasksForList({
-  disableSort,
-  targetList,
-  tasks,
-}: {
-  disableSort: boolean;
-  targetList: TaskList | undefined;
-  tasks: Task[];
-}) {
-  return [...tasks].sort((a, b) => {
-    if (targetList?.status === 'done') {
-      const completionA = a.completed_at
-        ? new Date(a.completed_at).getTime()
-        : 0;
-      const completionB = b.completed_at
-        ? new Date(b.completed_at).getTime()
-        : 0;
-      return completionB - completionA;
-    }
-
-    if (targetList?.status === 'closed') {
-      const closedA = a.closed_at ? new Date(a.closed_at).getTime() : 0;
-      const closedB = b.closed_at ? new Date(b.closed_at).getTime() : 0;
-      return closedB - closedA;
-    }
-
-    if (!disableSort) {
-      return compareTasksByEffectiveSortKey(a, b);
-    }
-
-    return 0;
-  });
-}

package/src/components/ui/tu-do/boards/boardId/kanban/dnd/task-drag-pending.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  addPendingTaskIds,
-  getPendingTaskIdsForDrop,
-  removePendingTaskIds,
-} from './task-drag-pending';
-
-describe('task drag pending helpers', () => {
-  it('keeps the active task pending for a normal drop', () => {
-    expect(getPendingTaskIdsForDrop({ activeTaskId: 'task-1' })).toEqual([
-      'task-1',
-    ]);
-  });
-
-  it('includes repaired sort-key tasks without duplicating the active task', () => {
-    expect(
-      getPendingTaskIdsForDrop({
-        activeTaskId: 'task-1',
-        repairedTaskSortKeys: [
-          { listId: 'list-1', sortKey: 1_000_000, taskId: 'task-2' },
-          { listId: 'list-1', sortKey: 2_000_000, taskId: 'task-1' },
-          { listId: 'list-1', sortKey: 3_000_000, taskId: 'task-3' },
-        ],
-      })
-    ).toEqual(['task-1', 'task-2', 'task-3']);
-  });
-
-  it('adds and removes pending task ids immutably', () => {
-    const current = new Set(['task-1']);
-    const added = addPendingTaskIds(current, ['task-2', 'task-3']);
-    const removed = removePendingTaskIds(added, ['task-1', 'task-3']);
-
-    expect(Array.from(current)).toEqual(['task-1']);
-    expect(Array.from(added)).toEqual(['task-1', 'task-2', 'task-3']);
-    expect(Array.from(removed)).toEqual(['task-2']);
-  });
-});