@tuturuuu/ui 0.1.0 → 0.3.1

package/src/components/ui/tu-do/shared/list-view.tsx

@@ -42,6 +42,7 @@ import {
   DropdownMenuSubTrigger,
   DropdownMenuTrigger,
 } from '@tuturuuu/ui/dropdown-menu';
+import { useUserBooleanConfig } from '@tuturuuu/ui/hooks/use-user-config';
 import { Separator } from '@tuturuuu/ui/separator';
 import {
   Table,
@@ -53,7 +54,6 @@ import {
 } from '@tuturuuu/ui/table';
 import { TooltipProvider } from '@tuturuuu/ui/tooltip';
 import { cn } from '@tuturuuu/utils/format';
-import { isTaskBoardResolvedStatus } from '@tuturuuu/utils/task-list-status';
 import { format, isPast, isToday, isTomorrow } from 'date-fns';
 import { enUS, vi } from 'date-fns/locale';
 import Image from 'next/image';
@@ -69,6 +69,10 @@ import {
   type ListViewSortOrder,
   sortListViewTasks,
 } from './list-view-sorting';
+import {
+  shouldShowTaskDueDate,
+  TASKS_SHOW_REVIEW_DUE_DATES_CONFIG_ID,
+} from './task-due-date-visibility';
 import { TaskRowActionsMenu } from './task-row-actions-menu';
 
 interface Props {
@@ -114,6 +118,10 @@ export function ListView({
   const queryClient = useQueryClient();
   const { resolvedTheme } = useTheme();
   const isDark = resolvedTheme === 'dark';
+  const { value: showReviewDueDates } = useUserBooleanConfig(
+    TASKS_SHOW_REVIEW_DUE_DATES_CONFIG_ID,
+    false
+  );
   const [localTasks, setLocalTasks] = useState<Task[]>(tasks);
   const [sortField, setSortField] = useState<ListViewSortField>('created_at');
   const [sortOrder, setSortOrder] = useState<ListViewSortOrder>('desc');
@@ -474,15 +482,17 @@ export function ListView({
               <TableBody>
                 {displayedTasks.map((task) => {
                   const taskList = getTaskList(task);
-                  const taskIsInResolvedList = isTaskBoardResolvedStatus(
-                    taskList?.status
-                  );
+                  const taskDueDateVisible = shouldShowTaskDueDate({
+                    completedAt: task.completed_at,
+                    closedAt: task.closed_at,
+                    dueDate: task.end_date,
+                    listStatus: taskList?.status,
+                    showReviewDueDates,
+                  });
                   const taskIsPastDue = Boolean(
                     task.end_date &&
                       isPast(new Date(task.end_date)) &&
-                      !task.closed_at &&
-                      !task.completed_at &&
-                      !taskIsInResolvedList
+                      taskDueDateVisible
                   );
                   const isExternalSource = Boolean(
                     task.source_board_id && task.source_board_id !== boardId
@@ -656,7 +666,7 @@ export function ListView({
                       )}
                       {columnVisibility.end_date && (
                         <TableCell className="px-2 py-0">
-                          {task.end_date && !taskIsInResolvedList && (
+                          {taskDueDateVisible && task.end_date && (
                             <div className="flex items-center gap-1.5">
                               <span
                                 className={cn(

package/src/components/ui/tu-do/shared/task-due-date-visibility.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import {
+  shouldShowTaskDueDate,
+  shouldShowTaskStartDate,
+} from './task-due-date-visibility';
+
+describe('task due date visibility', () => {
+  it('shows due dates for active workflow tasks', () => {
+    expect(
+      shouldShowTaskDueDate({
+        dueDate: '2026-06-08T00:00:00.000Z',
+        listStatus: 'active',
+        showReviewDueDates: false,
+      })
+    ).toBe(true);
+  });
+
+  it('hides review due dates by default', () => {
+    expect(
+      shouldShowTaskDueDate({
+        dueDate: '2026-06-08T00:00:00.000Z',
+        listStatus: 'review',
+        showReviewDueDates: false,
+      })
+    ).toBe(false);
+  });
+
+  it('shows review due dates when the setting is enabled', () => {
+    expect(
+      shouldShowTaskDueDate({
+        dueDate: '2026-06-08T00:00:00.000Z',
+        listStatus: 'review',
+        showReviewDueDates: true,
+      })
+    ).toBe(true);
+  });
+
+  it('keeps terminal and completed tasks hidden', () => {
+    expect(
+      shouldShowTaskDueDate({
+        dueDate: '2026-06-08T00:00:00.000Z',
+        listStatus: 'done',
+        showReviewDueDates: true,
+      })
+    ).toBe(false);
+    expect(
+      shouldShowTaskDueDate({
+        closedAt: '2026-06-08T00:00:00.000Z',
+        dueDate: '2026-06-08T00:00:00.000Z',
+        listStatus: 'active',
+        showReviewDueDates: true,
+      })
+    ).toBe(false);
+    expect(
+      shouldShowTaskDueDate({
+        completedAt: '2026-06-08T00:00:00.000Z',
+        dueDate: '2026-06-08T00:00:00.000Z',
+        listStatus: 'review',
+        showReviewDueDates: true,
+      })
+    ).toBe(false);
+  });
+
+  it('does not use the review due-date setting for start dates', () => {
+    expect(
+      shouldShowTaskStartDate({
+        listStatus: 'review',
+        startDate: '2026-06-08T00:00:00.000Z',
+      })
+    ).toBe(false);
+  });
+});

package/src/components/ui/tu-do/shared/task-due-date-visibility.ts

@@ -0,0 +1,38 @@
+import type { TaskBoardStatus } from '@tuturuuu/types/primitives/TaskBoard';
+import { isTaskBoardTerminalStatus } from '@tuturuuu/utils/task-list-status';
+
+export const TASKS_SHOW_REVIEW_DUE_DATES_CONFIG_ID =
+  'TASKS_SHOW_REVIEW_DUE_DATES';
+
+export function shouldShowTaskDueDate({
+  completedAt,
+  closedAt,
+  dueDate,
+  listStatus,
+  showReviewDueDates,
+}: {
+  completedAt?: string | null;
+  closedAt?: string | null;
+  dueDate?: string | null;
+  listStatus?: TaskBoardStatus | string | null;
+  showReviewDueDates: boolean;
+}) {
+  if (!dueDate || completedAt || closedAt) return false;
+  if (listStatus === 'review') return showReviewDueDates;
+  return !isTaskBoardTerminalStatus(listStatus);
+}
+
+export function shouldShowTaskStartDate({
+  completedAt,
+  closedAt,
+  listStatus,
+  startDate,
+}: {
+  completedAt?: string | null;
+  closedAt?: string | null;
+  listStatus?: TaskBoardStatus | string | null;
+  startDate?: string | null;
+}) {
+  if (!startDate || completedAt || closedAt) return false;
+  return listStatus !== 'review' && !isTaskBoardTerminalStatus(listStatus);
+}

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/__tests__/use-task-realtime-sync.test.tsx

@@ -90,29 +90,48 @@ describe('useTaskRealtimeSync', () => {
     );
   });
 
-  it('applies a matching task upsert to the open dialog state', () => {
+  it('refetches a matching task upsert before applying open dialog state', async () => {
     const start = '2026-05-22T01:00:00.000Z';
     const end = '2026-05-22T02:00:00.000Z';
     const props = makeProps();
 
+    taskApiMocks.getWorkspaceTask.mockResolvedValueOnce({
+      task: {
+        id: 'task-1',
+        name: 'Server task',
+        priority: 'high',
+        start_date: start,
+        end_date: end,
+        estimation_points: 5,
+        list_id: 'list-2',
+      },
+    });
+
     renderHook(() => useTaskRealtimeSync(props), { wrapper });
 
     act(() => {
       boardRealtimeMocks.onTaskChange?.(
         {
           id: 'task-1',
-          name: 'Remote task',
-          priority: 'high',
-          start_date: start,
-          end_date: end,
-          estimation_points: 5,
-          list_id: 'list-2',
+          name: 'Untrusted broadcast task',
+          priority: 'critical',
+          start_date: '2026-05-23T01:00:00.000Z',
+          end_date: '2026-05-23T02:00:00.000Z',
+          estimation_points: 8,
+          list_id: 'list-3',
         } as Task,
         'UPDATE'
       );
     });
 
-    expect(props.setName).toHaveBeenCalledWith('Remote task');
+    await waitFor(() => {
+      expect(props.setName).toHaveBeenCalledWith('Server task');
+    });
+    expect(taskApiMocks.getWorkspaceTask).toHaveBeenCalledWith(
+      'ws-1',
+      'task-1'
+    );
+    expect(props.setName).not.toHaveBeenCalledWith('Untrusted broadcast task');
     expect(props.setPriority).toHaveBeenCalledWith('high');
     expect(props.setStartDate).toHaveBeenCalledWith(new Date(start));
     expect(props.setEndDate).toHaveBeenCalledWith(new Date(end));
@@ -137,10 +156,13 @@ describe('useTaskRealtimeSync', () => {
     expect(props.setSelectedListId).not.toHaveBeenCalled();
   });
 
-  it('does not overwrite a local pending title edit', () => {
+  it('does not overwrite a local pending title edit', async () => {
     const props = makeProps({
       pendingNameRef: { current: 'Local draft title' },
     });
+    taskApiMocks.getWorkspaceTask.mockResolvedValueOnce({
+      task: { id: 'task-1', name: 'Remote title' },
+    });
 
     renderHook(() => useTaskRealtimeSync(props), { wrapper });
 
@@ -151,6 +173,12 @@ describe('useTaskRealtimeSync', () => {
       );
     });
 
+    await waitFor(() => {
+      expect(taskApiMocks.getWorkspaceTask).toHaveBeenCalledWith(
+        'ws-1',
+        'task-1'
+      );
+    });
     expect(props.setName).not.toHaveBeenCalled();
   });
 

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-mutations.ts

@@ -1,7 +1,7 @@
 import { useQueryClient } from '@tanstack/react-query';
 import {
   type TaskSchedulingUpdatePayload,
-  updateTaskSchedulingSettings,
+  updateCurrentUserTaskSchedulingSettings,
 } from '@tuturuuu/internal-api';
 import type { TaskPriority } from '@tuturuuu/types/primitives/Priority';
 import type { CalendarHoursType } from '@tuturuuu/types/primitives/Task';
@@ -482,7 +482,10 @@ export function useTaskMutations({
           auto_schedule: settings.autoSchedule,
         };
 
-        await updateTaskSchedulingSettings(wsId, taskId, schedulingPayload);
+        await updateCurrentUserTaskSchedulingSettings(
+          taskId,
+          schedulingPayload
+        );
 
         // Keep any related query data consistent
         queryClient.invalidateQueries({
@@ -519,7 +522,7 @@ export function useTaskMutations({
         setSchedulingSaving(false);
       }
     },
-    [isCreateMode, taskId, queryClient, toast, triggerRefresh, wsId]
+    [isCreateMode, taskId, queryClient, toast, triggerRefresh]
   );
 
   return {

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-realtime-sync.ts

@@ -93,6 +93,7 @@ export function useTaskRealtimeSync({
   const endDateRef = useRef(endDate);
   const estimationPointsRef = useRef(estimationPoints);
   const selectedListIdRef = useRef(selectedListId);
+  const taskRequestTokenRef = useRef(0);
   const relationsRequestTokenRef = useRef(0);
 
   nameRef.current = name;
@@ -105,7 +106,7 @@ export function useTaskRealtimeSync({
   const realtimeActive =
     !isCreateMode && isOpen && realtimeEnabled && !!taskId && !disabled;
 
-  const fetchTaskRelations = useCallback(async () => {
+  const fetchLatestTask = useCallback(async () => {
     if (!taskId) return null;
 
     try {
@@ -127,25 +128,96 @@ export function useTaskRealtimeSync({
         staleTime: 0,
       });
 
-      const relationshipProjectIds =
-        routeTask.task.project_ids ??
-        routeTask.task.projects?.map((project) => project.id) ??
-        [];
-
-      const filteredProjects = (routeTask.task.projects ?? []).filter(
-        (project) => relationshipProjectIds.includes(project.id)
-      );
-
-      return {
-        labels: routeTask.task.labels ?? [],
-        assignees: routeTask.task.assignees ?? [],
-        projects: filteredProjects,
-      };
+      return routeTask.task;
     } catch {
       return null;
     }
   }, [queryClient, taskId, taskWorkspaceId, wsId]);
 
+  const applyLatestTaskFields = useCallback(async () => {
+    if (!realtimeActive || !taskId) return;
+
+    taskRequestTokenRef.current += 1;
+    const token = taskRequestTokenRef.current;
+    const task = await fetchLatestTask();
+
+    if (token !== taskRequestTokenRef.current || !task || task.id !== taskId) {
+      return;
+    }
+
+    if (
+      hasOwn(task, 'name') &&
+      typeof task.name === 'string' &&
+      !pendingNameRef.current &&
+      task.name !== nameRef.current
+    ) {
+      setName(task.name);
+    }
+
+    if (hasOwn(task, 'priority') && task.priority !== priorityRef.current) {
+      setPriority(task.priority ?? null);
+    }
+
+    if (hasOwn(task, 'start_date')) {
+      const nextStartDate = toDate(task.start_date);
+      if (!datesMatch(startDateRef.current, nextStartDate)) {
+        setStartDate(nextStartDate);
+      }
+    }
+
+    if (hasOwn(task, 'end_date')) {
+      const nextEndDate = toDate(task.end_date);
+      if (!datesMatch(endDateRef.current, nextEndDate)) {
+        setEndDate(nextEndDate);
+      }
+    }
+
+    if (
+      hasOwn(task, 'estimation_points') &&
+      task.estimation_points !== estimationPointsRef.current
+    ) {
+      setEstimationPoints(task.estimation_points ?? null);
+    }
+
+    if (
+      hasOwn(task, 'list_id') &&
+      typeof task.list_id === 'string' &&
+      task.list_id !== selectedListIdRef.current
+    ) {
+      setSelectedListId(task.list_id);
+    }
+  }, [
+    fetchLatestTask,
+    pendingNameRef,
+    realtimeActive,
+    setEndDate,
+    setEstimationPoints,
+    setName,
+    setPriority,
+    setSelectedListId,
+    setStartDate,
+    taskId,
+  ]);
+
+  const fetchTaskRelations = useCallback(async () => {
+    const task = await fetchLatestTask();
+
+    if (!task) return null;
+
+    const relationshipProjectIds =
+      task.project_ids ?? task.projects?.map((project) => project.id) ?? [];
+
+    const filteredProjects = (task.projects ?? []).filter((project) =>
+      relationshipProjectIds.includes(project.id)
+    );
+
+    return {
+      labels: task.labels ?? [],
+      assignees: task.assignees ?? [],
+      projects: filteredProjects,
+    };
+  }, [fetchLatestTask]);
+
   const applyLatestRelations = useCallback(async () => {
     if (!realtimeActive) return;
 
@@ -175,62 +247,9 @@ export function useTaskRealtimeSync({
       )
         return;
 
-      if (
-        hasOwn(updatedTask, 'name') &&
-        typeof updatedTask.name === 'string' &&
-        !pendingNameRef.current &&
-        updatedTask.name !== nameRef.current
-      ) {
-        setName(updatedTask.name);
-      }
-
-      if (
-        hasOwn(updatedTask, 'priority') &&
-        updatedTask.priority !== priorityRef.current
-      ) {
-        setPriority(updatedTask.priority ?? null);
-      }
-
-      if (hasOwn(updatedTask, 'start_date')) {
-        const nextStartDate = toDate(updatedTask.start_date);
-        if (!datesMatch(startDateRef.current, nextStartDate)) {
-          setStartDate(nextStartDate);
-        }
-      }
-
-      if (hasOwn(updatedTask, 'end_date')) {
-        const nextEndDate = toDate(updatedTask.end_date);
-        if (!datesMatch(endDateRef.current, nextEndDate)) {
-          setEndDate(nextEndDate);
-        }
-      }
-
-      if (
-        hasOwn(updatedTask, 'estimation_points') &&
-        updatedTask.estimation_points !== estimationPointsRef.current
-      ) {
-        setEstimationPoints(updatedTask.estimation_points ?? null);
-      }
-
-      if (
-        hasOwn(updatedTask, 'list_id') &&
-        typeof updatedTask.list_id === 'string' &&
-        updatedTask.list_id !== selectedListIdRef.current
-      ) {
-        setSelectedListId(updatedTask.list_id);
-      }
+      void applyLatestTaskFields();
     },
-    [
-      pendingNameRef,
-      realtimeActive,
-      setEndDate,
-      setEstimationPoints,
-      setName,
-      setPriority,
-      setSelectedListId,
-      setStartDate,
-      taskId,
-    ]
+    [applyLatestTaskFields, realtimeActive, taskId]
   );
 
   const handleTaskRelationsChange = useCallback(

package/src/components/ui/tu-do/shared/task-edit-dialog/hooks/use-task-save.ts

@@ -2,7 +2,7 @@
 
 import type { QueryClient } from '@tanstack/react-query';
 import type { Editor, JSONContent } from '@tiptap/react';
-import { updateTaskSchedulingSettings } from '@tuturuuu/internal-api';
+import { updateCurrentUserTaskSchedulingSettings } from '@tuturuuu/internal-api';
 import type { WorkspaceTaskUpdatePayload } from '@tuturuuu/internal-api/tasks';
 import { createWorkspaceTaskRelationship } from '@tuturuuu/internal-api/tasks';
 import { createClient } from '@tuturuuu/supabase/next/client';
@@ -975,7 +975,7 @@ async function handleCreateTask({
 
     if (hasAnySchedulingValue) {
       try {
-        await updateTaskSchedulingSettings(wsId, newTask.id, {
+        await updateCurrentUserTaskSchedulingSettings(newTask.id, {
           total_duration: totalDuration,
           is_splittable: isSplittable,
           min_split_duration_minutes: minSplitDurationMinutes,

package/src/components/ui/tu-do/shared/task-row-actions-menu.tsx

@@ -38,6 +38,7 @@ import {
   TaskDueDateMenu,
   TaskMoveMenu,
   TaskPriorityMenu,
+  TaskSchedulingMenu,
 } from '../boards/boardId/menus';
 import { useTaskDialog } from '../hooks/useTaskDialog';
 import { useTasksHref } from '../tasks-route-context';
@@ -87,6 +88,7 @@ export function TaskRowActionsMenu({
 }: TaskRowActionsMenuProps) {
   const t = useTranslations('common');
   const tTasks = useTranslations('ws-tasks');
+  const taskBoardT = useTranslations();
   const tasksHref = useTasksHref();
   const { openTask } = useTaskDialog();
   const [internalOpen, setInternalOpen] = useState(false);
@@ -287,6 +289,37 @@ export function TaskRowActionsMenu({
               }}
             />
           )}
+          {taskList?.status !== 'documents' && (
+            <TaskSchedulingMenu
+              task={task}
+              boardId={boardId}
+              isLoading={isLoading}
+              onUpdate={onUpdate}
+              onClose={() => setMenuOpen(false)}
+              translations={{
+                schedule: taskBoardT('ws-task-boards.dialog.schedule'),
+                estimatedDuration: taskBoardT(
+                  'ws-task-boards.dialog.estimated_duration'
+                ),
+                h: taskBoardT('ws-task-boards.dialog.h'),
+                m: taskBoardT('ws-task-boards.dialog.m'),
+                splittable: taskBoardT('ws-task-boards.dialog.splittable'),
+                minSplit: taskBoardT('ws-task-boards.dialog.min_split'),
+                maxSplit: taskBoardT('ws-task-boards.dialog.max_split'),
+                hourType: taskBoardT('ws-task-boards.dialog.hour_type'),
+                workHours: taskBoardT('ws-task-boards.dialog.work_hours'),
+                meetingHours: taskBoardT('ws-task-boards.dialog.meeting_hours'),
+                personalHours: taskBoardT(
+                  'ws-task-boards.dialog.personal_hours'
+                ),
+                autoSchedule: taskBoardT('ws-task-boards.dialog.auto_schedule'),
+                save: t('save'),
+                clear: t('clear'),
+                saved: t('saved'),
+                error: t('error'),
+              }}
+            />
+          )}
           {canUseCurrentBoardLists && (
             <TaskMoveMenu
               currentListId={task.list_id}

package/src/hooks/__tests__/use-calendar-readonly.test.tsx

@@ -1,17 +1,26 @@
-import { renderHook } from '@testing-library/react';
+import { act, renderHook } from '@testing-library/react';
+import type { CalendarEvent } from '@tuturuuu/types/primitives/calendar-event';
 import type { ReactNode } from 'react';
-import { describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { CalendarProvider, useCalendar } from '../use-calendar';
 
+const calendarMockState = vi.hoisted(() => ({
+  events: [] as CalendarEvent[],
+}));
+
 // Mock useCalendarSync
 vi.mock('../use-calendar-sync', () => ({
   useCalendarSync: () => ({
-    events: [],
+    events: calendarMockState.events,
     refresh: vi.fn(),
   }),
 }));
 
 describe('CalendarProvider Read-Only Mode', () => {
+  beforeEach(() => {
+    calendarMockState.events = [];
+  });
+
   const mockUseQuery = vi
     .fn()
     .mockReturnValue({ data: null, isLoading: false });
@@ -87,4 +96,66 @@ describe('CalendarProvider Read-Only Mode', () => {
     // If it doesn't throw, it's fine (it just exits early with a warning)
     expect(true).toBe(true);
   });
+
+  it('opens preview for existing event clicks and editor from Edit action', () => {
+    calendarMockState.events = [
+      {
+        id: 'event-1',
+        title: 'Design review',
+        start_at: '2026-06-08T09:00:00.000Z',
+        end_at: '2026-06-08T10:00:00.000Z',
+        ws_id: 'workspace-1',
+      },
+    ];
+
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <CalendarProvider
+        ws={{ id: 'workspace-1', name: 'Workspace' } as any}
+        useQuery={mockUseQuery}
+        useQueryClient={mockUseQueryClient}
+      >
+        {children}
+      </CalendarProvider>
+    );
+
+    const { result } = renderHook(() => useCalendar(), { wrapper });
+
+    act(() => {
+      result.current.openModal('event-1');
+    });
+
+    expect(result.current.isPreviewOpen).toBe(true);
+    expect(result.current.previewEvent?.id).toBe('event-1');
+    expect(result.current.isModalOpen).toBe(false);
+
+    act(() => {
+      result.current.openEventEditor('event-1');
+    });
+
+    expect(result.current.isPreviewOpen).toBe(false);
+    expect(result.current.isModalOpen).toBe(true);
+    expect(result.current.activeEvent?.id).toBe('event-1');
+  });
+
+  it('opens the editor directly for create flows', () => {
+    const wrapper = ({ children }: { children: ReactNode }) => (
+      <CalendarProvider
+        ws={{ id: 'workspace-1', name: 'Workspace' } as any}
+        useQuery={mockUseQuery}
+        useQueryClient={mockUseQueryClient}
+      >
+        {children}
+      </CalendarProvider>
+    );
+
+    const { result } = renderHook(() => useCalendar(), { wrapper });
+
+    act(() => {
+      result.current.openModal(undefined, 'event');
+    });
+
+    expect(result.current.isPreviewOpen).toBe(false);
+    expect(result.current.isModalOpen).toBe(true);
+    expect(result.current.activeEvent?.id).toBe('new');
+  });
 });