@tuturuuu/ui 0.8.0 → 0.10.0

package/src/components/ui/tu-do/shared/task-cache-patches.ts

@@ -0,0 +1,394 @@
+import type { QueryClient, QueryKey } from '@tanstack/react-query';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+
+type WorkspaceTaskCache = {
+  task?: Task | null;
+};
+
+type MyTasksCache = {
+  overdue?: Task[];
+  today?: Task[];
+  upcoming?: Task[];
+  completed?: Task[];
+};
+
+type MyCompletedTasksCache = {
+  pages?: Array<{
+    completed?: Task[];
+  }>;
+};
+
+export type VisibleTaskCacheSnapshot = {
+  boardTaskEntries: [QueryKey, Task[] | undefined][];
+  taskEntries: [QueryKey, Task | undefined][];
+  workspaceTaskEntries: [QueryKey, WorkspaceTaskCache | undefined][];
+  myTasksEntries: [QueryKey, MyTasksCache | undefined][];
+  myCompletedTaskEntries: [QueryKey, MyCompletedTasksCache | undefined][];
+};
+
+function isBoardTaskQuery(queryKey: QueryKey, boardId: string) {
+  return (
+    Array.isArray(queryKey) &&
+    (queryKey[0] === 'tasks' || queryKey[0] === 'tasks-full') &&
+    queryKey[1] === boardId
+  );
+}
+
+function isTaskDetailQuery(queryKey: QueryKey, taskIds: Set<string>) {
+  return (
+    Array.isArray(queryKey) &&
+    queryKey[0] === 'task' &&
+    typeof queryKey[1] === 'string' &&
+    taskIds.has(queryKey[1])
+  );
+}
+
+function isWorkspaceTaskQuery(queryKey: QueryKey, taskIds: Set<string>) {
+  return (
+    Array.isArray(queryKey) &&
+    queryKey[0] === 'workspaceTask' &&
+    typeof queryKey[2] === 'string' &&
+    taskIds.has(queryKey[2])
+  );
+}
+
+function patchTaskArray<T extends { id?: string }>(
+  tasks: T[] | undefined,
+  taskIds: Set<string>,
+  updater: (task: Task) => Task
+): T[] | undefined {
+  if (!tasks) return tasks;
+
+  let changed = false;
+  const nextTasks = tasks.map((task) => {
+    if (!task.id || !taskIds.has(task.id)) {
+      return task;
+    }
+
+    const updatedTask = updater(task as unknown as Task) as unknown as T;
+    if (updatedTask !== task) {
+      changed = true;
+    }
+
+    return updatedTask;
+  });
+
+  return changed ? nextTasks : tasks;
+}
+
+function restoreTaskArrayFromSnapshot<T extends { id?: string }>(
+  currentTasks: T[] | undefined,
+  previousTasks: T[] | undefined,
+  taskIds: Set<string>
+): T[] | undefined {
+  if (!currentTasks || !previousTasks) return currentTasks;
+
+  const previousById = new Map(
+    previousTasks
+      .filter((task) => task.id && taskIds.has(task.id))
+      .map((task) => [task.id, task])
+  );
+  if (previousById.size === 0) return currentTasks;
+
+  let changed = false;
+  const restoredTasks = currentTasks.map((task) => {
+    if (!task.id) return task;
+    const previousTask = previousById.get(task.id);
+    if (!previousTask) return task;
+
+    changed = true;
+    return previousTask;
+  });
+
+  return changed ? restoredTasks : currentTasks;
+}
+
+function patchMyTasksCache(
+  cache: MyTasksCache | undefined,
+  taskIds: Set<string>,
+  updater: (task: Task) => Task
+) {
+  if (!cache) return cache;
+
+  return {
+    ...cache,
+    overdue: patchTaskArray(cache.overdue, taskIds, updater) ?? cache.overdue,
+    today: patchTaskArray(cache.today, taskIds, updater) ?? cache.today,
+    upcoming:
+      patchTaskArray(cache.upcoming, taskIds, updater) ?? cache.upcoming,
+    completed:
+      patchTaskArray(cache.completed, taskIds, updater) ?? cache.completed,
+  };
+}
+
+function patchMyCompletedTasksCache(
+  cache: MyCompletedTasksCache | undefined,
+  taskIds: Set<string>,
+  updater: (task: Task) => Task
+) {
+  if (!cache?.pages) return cache;
+
+  return {
+    ...cache,
+    pages: cache.pages.map((page) => ({
+      ...page,
+      completed:
+        patchTaskArray(page.completed, taskIds, updater) ?? page.completed,
+    })),
+  };
+}
+
+function restoreMyTasksCacheFromSnapshot(
+  current: MyTasksCache | undefined,
+  previous: MyTasksCache | undefined,
+  taskIds: Set<string>
+) {
+  if (!current || !previous) return current;
+
+  return {
+    ...current,
+    overdue:
+      restoreTaskArrayFromSnapshot(
+        current.overdue,
+        previous.overdue,
+        taskIds
+      ) ?? current.overdue,
+    today:
+      restoreTaskArrayFromSnapshot(current.today, previous.today, taskIds) ??
+      current.today,
+    upcoming:
+      restoreTaskArrayFromSnapshot(
+        current.upcoming,
+        previous.upcoming,
+        taskIds
+      ) ?? current.upcoming,
+    completed:
+      restoreTaskArrayFromSnapshot(
+        current.completed,
+        previous.completed,
+        taskIds
+      ) ?? current.completed,
+  };
+}
+
+function restoreMyCompletedTasksCacheFromSnapshot(
+  current: MyCompletedTasksCache | undefined,
+  previous: MyCompletedTasksCache | undefined,
+  taskIds: Set<string>
+) {
+  if (!current?.pages || !previous?.pages) return current;
+
+  return {
+    ...current,
+    pages: current.pages.map((page, index) => ({
+      ...page,
+      completed:
+        restoreTaskArrayFromSnapshot(
+          page.completed,
+          previous.pages?.[index]?.completed,
+          taskIds
+        ) ?? page.completed,
+    })),
+  };
+}
+
+export function getTaskFromVisibleCaches({
+  queryClient,
+  boardId,
+  taskId,
+  fallback,
+}: {
+  queryClient: QueryClient;
+  boardId: string;
+  taskId: string;
+  fallback?: Task;
+}): Task | undefined {
+  const taskDetail = queryClient.getQueryData<Task>(['task', taskId]);
+  if (taskDetail) return taskDetail;
+
+  const workspaceTaskEntries = queryClient.getQueriesData<WorkspaceTaskCache>({
+    predicate: (query) =>
+      isWorkspaceTaskQuery(query.queryKey, new Set([taskId])),
+  });
+  for (const [, entry] of workspaceTaskEntries) {
+    if (entry?.task) return entry.task;
+  }
+
+  const boardTaskEntries = queryClient.getQueriesData<Task[]>({
+    predicate: (query) => isBoardTaskQuery(query.queryKey, boardId),
+  });
+  for (const [, tasks] of boardTaskEntries) {
+    const task = tasks?.find((entry) => entry.id === taskId);
+    if (task) return task;
+  }
+
+  return fallback;
+}
+
+export function patchTasksInVisibleCaches({
+  queryClient,
+  boardId,
+  taskIds,
+  updater,
+}: {
+  queryClient: QueryClient;
+  boardId: string;
+  taskIds: string[];
+  updater: (task: Task) => Task;
+}) {
+  const taskIdSet = new Set(taskIds);
+  if (taskIdSet.size === 0) return;
+
+  queryClient.setQueriesData<Task[]>(
+    {
+      predicate: (query) => isBoardTaskQuery(query.queryKey, boardId),
+    },
+    (old) => patchTaskArray(old, taskIdSet, updater)
+  );
+
+  queryClient.setQueriesData<Task>(
+    {
+      predicate: (query) => isTaskDetailQuery(query.queryKey, taskIdSet),
+    },
+    (old) => (old ? updater(old) : old)
+  );
+
+  queryClient.setQueriesData<WorkspaceTaskCache>(
+    {
+      predicate: (query) => isWorkspaceTaskQuery(query.queryKey, taskIdSet),
+    },
+    (old) =>
+      old?.task
+        ? {
+            ...old,
+            task: updater(old.task),
+          }
+        : old
+  );
+
+  queryClient.setQueriesData<MyTasksCache>({ queryKey: ['my-tasks'] }, (old) =>
+    patchMyTasksCache(old, taskIdSet, updater)
+  );
+
+  queryClient.setQueriesData<MyCompletedTasksCache>(
+    { queryKey: ['my-completed-tasks'] },
+    (old) => patchMyCompletedTasksCache(old, taskIdSet, updater)
+  );
+}
+
+export function patchTaskInVisibleCaches({
+  queryClient,
+  boardId,
+  taskId,
+  updater,
+}: {
+  queryClient: QueryClient;
+  boardId: string;
+  taskId: string;
+  updater: (task: Task) => Task;
+}) {
+  patchTasksInVisibleCaches({
+    queryClient,
+    boardId,
+    taskIds: [taskId],
+    updater,
+  });
+}
+
+export function snapshotVisibleTaskCaches(
+  queryClient: QueryClient,
+  boardId: string,
+  taskIds: string[]
+): VisibleTaskCacheSnapshot {
+  const taskIdSet = new Set(taskIds);
+
+  return {
+    boardTaskEntries: queryClient.getQueriesData<Task[]>({
+      predicate: (query) => isBoardTaskQuery(query.queryKey, boardId),
+    }),
+    taskEntries: queryClient.getQueriesData<Task>({
+      predicate: (query) => isTaskDetailQuery(query.queryKey, taskIdSet),
+    }),
+    workspaceTaskEntries: queryClient.getQueriesData<WorkspaceTaskCache>({
+      predicate: (query) => isWorkspaceTaskQuery(query.queryKey, taskIdSet),
+    }),
+    myTasksEntries: queryClient.getQueriesData<MyTasksCache>({
+      queryKey: ['my-tasks'],
+    }),
+    myCompletedTaskEntries: queryClient.getQueriesData<MyCompletedTasksCache>({
+      queryKey: ['my-completed-tasks'],
+    }),
+  };
+}
+
+export function restoreVisibleTaskCaches(
+  queryClient: QueryClient,
+  snapshot: VisibleTaskCacheSnapshot
+) {
+  for (const [queryKey, data] of snapshot.boardTaskEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+
+  for (const [queryKey, data] of snapshot.taskEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+
+  for (const [queryKey, data] of snapshot.workspaceTaskEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+
+  for (const [queryKey, data] of snapshot.myTasksEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+
+  for (const [queryKey, data] of snapshot.myCompletedTaskEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+}
+
+export function restoreTasksFromVisibleCacheSnapshot({
+  queryClient,
+  snapshot,
+  taskIds,
+}: {
+  queryClient: QueryClient;
+  snapshot: VisibleTaskCacheSnapshot;
+  taskIds: string[];
+}) {
+  const taskIdSet = new Set(taskIds);
+  if (taskIdSet.size === 0) return;
+
+  for (const [queryKey, previousTasks] of snapshot.boardTaskEntries) {
+    queryClient.setQueryData<Task[]>(queryKey, (currentTasks) =>
+      restoreTaskArrayFromSnapshot(currentTasks, previousTasks, taskIdSet)
+    );
+  }
+
+  for (const [queryKey, previousTask] of snapshot.taskEntries) {
+    if (!Array.isArray(queryKey) || typeof queryKey[1] !== 'string') continue;
+    if (!taskIdSet.has(queryKey[1])) continue;
+    queryClient.setQueryData(queryKey, previousTask);
+  }
+
+  for (const [queryKey, previousEntry] of snapshot.workspaceTaskEntries) {
+    if (!Array.isArray(queryKey) || typeof queryKey[2] !== 'string') continue;
+    if (!taskIdSet.has(queryKey[2])) continue;
+    queryClient.setQueryData(queryKey, previousEntry);
+  }
+
+  for (const [queryKey, previousEntry] of snapshot.myTasksEntries) {
+    queryClient.setQueryData<MyTasksCache>(queryKey, (currentEntry) =>
+      restoreMyTasksCacheFromSnapshot(currentEntry, previousEntry, taskIdSet)
+    );
+  }
+
+  for (const [queryKey, previousEntry] of snapshot.myCompletedTaskEntries) {
+    queryClient.setQueryData<MyCompletedTasksCache>(queryKey, (currentEntry) =>
+      restoreMyCompletedTasksCacheFromSnapshot(
+        currentEntry,
+        previousEntry,
+        taskIdSet
+      )
+    );
+  }
+}

package/src/components/ui/tu-do/shared/task-dialog-manager.tsx

@@ -189,6 +189,8 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
             taskWsId: state.taskWsId,
             taskWorkspacePersonal: state.taskWorkspacePersonal,
             taskWorkspaceTier: state.taskWorkspaceTier,
+            canUseBoardAssignees: state.canUseBoardAssignees,
+            assigneeMemberSource: state.assigneeMemberSource,
           });
           return;
         }
@@ -210,6 +212,8 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
             taskWsId: currentTaskWsId,
             taskWorkspacePersonal: state.taskWorkspacePersonal,
             taskWorkspaceTier: state.taskWorkspaceTier,
+            canUseBoardAssignees: state.canUseBoardAssignees,
+            assigneeMemberSource: state.assigneeMemberSource,
           });
           return;
         }
@@ -223,8 +227,10 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
       openTask,
       openTaskById,
       queryClient,
+      state.assigneeMemberSource,
       state.availableLists,
       state.boardId,
+      state.canUseBoardAssignees,
       state.task?.id,
       state.taskWorkspacePersonal,
       state.taskWorkspaceTier,
@@ -238,9 +244,17 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
       return openTaskById(taskId, {
         taskWsId: wsId,
         taskWorkspacePersonal: isPersonalWorkspace,
+        canUseBoardAssignees: state.canUseBoardAssignees,
+        assigneeMemberSource: state.assigneeMemberSource,
       });
     },
-    [isPersonalWorkspace, openTaskById, wsId]
+    [
+      isPersonalWorkspace,
+      openTaskById,
+      state.assigneeMemberSource,
+      state.canUseBoardAssignees,
+      wsId,
+    ]
   );
 
   useEffect(() => {
@@ -388,10 +402,14 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
       taskWsId: state.taskWsId,
       taskWorkspacePersonal: state.taskWorkspacePersonal,
       taskWorkspaceTier: state.taskWorkspaceTier,
+      canUseBoardAssignees: state.canUseBoardAssignees,
+      assigneeMemberSource: state.assigneeMemberSource,
       initialSharedContext: state.initialSharedContext,
     });
   }, [
     openTaskById,
+    state.assigneeMemberSource,
+    state.canUseBoardAssignees,
     state.initialSharedContext,
     state.availableLists,
     state.boardId,
@@ -539,6 +557,8 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
       taskLoadError={state.taskLoadError}
       taskHydrationVersion={state.taskHydrationVersion}
       isPersonalWorkspace={isPersonalWorkspace}
+      canUseBoardAssignees={state.canUseBoardAssignees}
+      assigneeMemberSource={state.assigneeMemberSource}
       parentTaskId={state.parentTaskId}
       parentTaskName={state.parentTaskName}
       pendingRelationship={state.pendingRelationship}

package/src/components/ui/tu-do/shared/task-edit-dialog/components/quick-settings-popover.tsx

@@ -28,6 +28,8 @@ function updateBodyFadeAttribute(enabled: boolean) {
 interface QuickSettingsPopoverProps {
   /** Whether the workspace is personal (forces auto-assign to true) */
   isPersonalWorkspace?: boolean;
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
 }
 
 /**
@@ -36,6 +38,8 @@ interface QuickSettingsPopoverProps {
  */
 export function QuickSettingsPopover({
   isPersonalWorkspace = false,
+  open,
+  onOpenChange,
 }: QuickSettingsPopoverProps) {
   const t = useTranslations('settings.tasks');
   const tCommon = useTranslations('common');
@@ -96,7 +100,7 @@ export function QuickSettingsPopover({
     : (settings?.task_auto_assign_to_self ?? false);
 
   return (
-    <Popover>
+    <Popover open={open} onOpenChange={onOpenChange}>
       <Tooltip>
         <TooltipTrigger asChild>
           <PopoverTrigger asChild>

package/src/components/ui/tu-do/shared/task-edit-dialog/components/task-dialog-header.tsx

@@ -16,7 +16,7 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '@tuturuuu/ui/tooltip';
 import { cn } from '@tuturuuu/utils/format';
 import { getTicketIdentifier } from '@tuturuuu/utils/task-helper';
 import { useTranslations } from 'next-intl';
-import type { ReactNode } from 'react';
+import { type ReactNode, useState } from 'react';
 import { TaskViewerAvatarsComponent } from '../../user-presence-avatars';
 import { TaskDialogActions } from '../task-dialog-actions';
 import type {
@@ -268,6 +268,19 @@ export function TaskDialogHeader({
   onScrollToUserCursor,
 }: TaskDialogHeaderProps) {
   const t = useTranslations();
+  const [activeHeaderOverlay, setActiveHeaderOverlay] = useState<
+    'quick-settings' | 'more-menu' | null
+  >(null);
+
+  const setHeaderOverlayOpen = (
+    overlay: 'quick-settings' | 'more-menu',
+    open: boolean
+  ) => {
+    setActiveHeaderOverlay((currentOverlay) => {
+      if (open) return overlay;
+      return currentOverlay === overlay ? null : currentOverlay;
+    });
+  };
 
   // Use custom headerInfo if provided, otherwise generate from task context
   const resolvedHeaderInfo =
@@ -452,7 +465,13 @@ export function TaskDialogHeader({
 
         {/* Quick Settings */}
         {!controlsDisabled && (
-          <QuickSettingsPopover isPersonalWorkspace={isPersonalWorkspace} />
+          <QuickSettingsPopover
+            isPersonalWorkspace={isPersonalWorkspace}
+            open={activeHeaderOverlay === 'quick-settings'}
+            onOpenChange={(open) =>
+              setHeaderOverlayOpen('quick-settings', open)
+            }
+          />
         )}
 
         <TaskDialogActions
@@ -471,6 +490,10 @@ export function TaskDialogHeader({
           onOpenShareDialog={onOpenShareDialog}
           disabled={disabled}
           controlsDisabled={controlsDisabled}
+          moreMenuOpen={activeHeaderOverlay === 'more-menu'}
+          onMoreMenuOpenChange={(open) =>
+            setHeaderOverlayOpen('more-menu', open)
+          }
         />
 
         {/* Hide save button in edit mode when realtime is enabled (either cursors or Yjs sync) */}

package/src/components/ui/tu-do/shared/task-edit-dialog/components/task-list-selector.tsx

@@ -21,6 +21,8 @@ interface TaskListSelectorProps {
   availableLists: TaskList[];
   disabled?: boolean;
   compact?: boolean;
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
   onListChange: (listId: string) => void;
 }
 
@@ -31,11 +33,15 @@ export function TaskListSelector({
   availableLists,
   disabled = false,
   compact = false,
+  open,
+  onOpenChange,
   onListChange,
 }: TaskListSelectorProps) {
   const t = useTranslations();
-  const [isPopoverOpen, setIsPopoverOpen] = useState(false);
+  const [uncontrolledPopoverOpen, setUncontrolledPopoverOpen] = useState(false);
   const [isCreateListDialogOpen, setIsCreateListDialogOpen] = useState(false);
+  const isPopoverOpen = open ?? uncontrolledPopoverOpen;
+  const setIsPopoverOpen = onOpenChange ?? setUncontrolledPopoverOpen;
 
   const statusLabels = useMemo(
     () => ({

package/src/components/ui/tu-do/shared/task-edit-dialog/field-diff-viewer.tsx

@@ -373,8 +373,9 @@ function DescriptionDiff({
     </>
   );
 
-  // If both exist and there are text changes, show the full diff viewer
-  if (hasSnapshot && hasCurrent && hasTextChanges) {
+  // Show the full viewer whenever either side has content so users can inspect
+  // content-only, empty/content, and structural editor changes.
+  if (hasSnapshot || hasCurrent || hasTextChanges) {
     return (
       <div className="text-sm">
         <div className="flex items-center gap-2">