@tuturuuu/ui 0.2.0 → 0.3.2

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/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-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');
+  });
 });

package/src/hooks/__tests__/use-task-actions.test.tsx

@@ -1081,6 +1081,45 @@ describe('useTaskActions', () => {
         priority: 'high',
       });
     });
+
+    it('keeps priority updates single-target when the context task is not selected', async () => {
+      const task2: Task = { ...mockTask, id: 'task-2', name: 'Task 2' };
+      const unselectedContextTask: Task = {
+        ...mockTask,
+        id: 'task-3',
+        name: 'Task 3',
+      };
+      queryClient.setQueryData(
+        ['tasks', 'board-1'],
+        [mockTask, task2, unselectedContextTask]
+      );
+
+      const { result } = renderHook(
+        () =>
+          useTaskActions({
+            task: unselectedContextTask,
+            boardId: 'board-1',
+            targetCompletionList: mockCompletionList,
+            targetClosedList: mockClosedList,
+            availableLists: mockAvailableLists,
+            onUpdate: vi.fn(),
+            setIsLoading: vi.fn(),
+            setMenuOpen: vi.fn(),
+            selectedTasks: new Set(['task-1', 'task-2']),
+            isMultiSelectMode: true,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.handlePriorityChange('high');
+      });
+
+      expect(mockUpdateWorkspaceTask).toHaveBeenCalledTimes(1);
+      expect(mockUpdateWorkspaceTask).toHaveBeenCalledWith('ws-1', 'task-3', {
+        priority: 'high',
+      });
+    });
   });
 
   describe('updateEstimationPoints', () => {
@@ -1276,6 +1315,85 @@ describe('useTaskActions', () => {
         end_date: expect.any(String),
       });
     });
+
+    it('delegates selected-card custom dates to the bulk updater', async () => {
+      const task2: Task = { ...mockTask, id: 'task-2', name: 'Task 2' };
+      queryClient.setQueryData(['tasks', 'board-1'], [mockTask, task2]);
+
+      const bulkUpdateCustomDueDate = vi.fn().mockResolvedValue(undefined);
+      const testDate = new Date('2024-01-01T00:00:00');
+
+      const { result } = renderHook(
+        () =>
+          useTaskActions({
+            task: mockTask,
+            boardId: 'board-1',
+            targetCompletionList: mockCompletionList,
+            targetClosedList: mockClosedList,
+            availableLists: mockAvailableLists,
+            onUpdate: vi.fn(),
+            setIsLoading: vi.fn(),
+            setMenuOpen: vi.fn(),
+            setCustomDateDialogOpen: vi.fn(),
+            selectedTasks: new Set(['task-1', 'task-2']),
+            isMultiSelectMode: true,
+            bulkUpdateCustomDueDate,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.handleCustomDateChange(testDate);
+      });
+
+      expect(bulkUpdateCustomDueDate).toHaveBeenCalledWith(testDate);
+      expect(mockUpdateWorkspaceTask).not.toHaveBeenCalled();
+    });
+
+    it('keeps custom date updates single-target when the context task is not selected', async () => {
+      const task2: Task = { ...mockTask, id: 'task-2', name: 'Task 2' };
+      const unselectedContextTask: Task = {
+        ...mockTask,
+        id: 'task-3',
+        name: 'Task 3',
+      };
+      queryClient.setQueryData(
+        ['tasks', 'board-1'],
+        [mockTask, task2, unselectedContextTask]
+      );
+
+      const bulkUpdateCustomDueDate = vi.fn().mockResolvedValue(undefined);
+      const testDate = new Date('2024-01-01T00:00:00');
+
+      const { result } = renderHook(
+        () =>
+          useTaskActions({
+            task: unselectedContextTask,
+            boardId: 'board-1',
+            targetCompletionList: mockCompletionList,
+            targetClosedList: mockClosedList,
+            availableLists: mockAvailableLists,
+            onUpdate: vi.fn(),
+            setIsLoading: vi.fn(),
+            setMenuOpen: vi.fn(),
+            setCustomDateDialogOpen: vi.fn(),
+            selectedTasks: new Set(['task-1', 'task-2']),
+            isMultiSelectMode: true,
+            bulkUpdateCustomDueDate,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.handleCustomDateChange(testDate);
+      });
+
+      expect(bulkUpdateCustomDueDate).not.toHaveBeenCalled();
+      expect(mockUpdateWorkspaceTask).toHaveBeenCalledTimes(1);
+      expect(mockUpdateWorkspaceTask).toHaveBeenCalledWith('ws-1', 'task-3', {
+        end_date: expect.any(String),
+      });
+    });
   });
 
   describe('handleToggleAssignee', () => {

package/src/hooks/__tests__/use-user-config.test.tsx

@@ -0,0 +1,65 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useUserBooleanConfig } from '../use-user-config';
+
+const { mockGetUserConfig, mockUpdateUserConfig } = vi.hoisted(() => ({
+  mockGetUserConfig: vi.fn(),
+  mockUpdateUserConfig: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getUserConfig: (...args: unknown[]) => mockGetUserConfig(...args),
+  updateUserConfig: (...args: unknown[]) => mockUpdateUserConfig(...args),
+}));
+
+function createWrapper() {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+    );
+  };
+}
+
+describe('useUserBooleanConfig', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('uses the requested boolean default while the config is loading', () => {
+    mockGetUserConfig.mockReturnValue(new Promise(() => {}));
+
+    const { result } = renderHook(
+      () => useUserBooleanConfig('EXPAND_SETTINGS_ACCORDIONS', true),
+      { wrapper: createWrapper() }
+    );
+
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.value).toBe(true);
+  });
+
+  it('lets a saved false value override a default true value after loading', async () => {
+    mockGetUserConfig.mockResolvedValue({ value: 'false' });
+
+    const { result } = renderHook(
+      () => useUserBooleanConfig('EXPAND_SETTINGS_ACCORDIONS', true),
+      { wrapper: createWrapper() }
+    );
+
+    expect(result.current.value).toBe(true);
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.value).toBe(false);
+    });
+  });
+});

package/src/hooks/__tests__/use-workspace-presence.test.tsx

@@ -20,7 +20,7 @@ vi.mock('@tuturuuu/supabase/next/client', () => ({
   createClient: createClientMock,
 }));
 
-vi.mock('@tuturuuu/internal-api', () => ({
+vi.mock('@tuturuuu/internal-api/users', () => ({
   getCurrentUserProfile: getCurrentUserProfileMock,
 }));