@tuturuuu/ui 0.9.0 → 0.11.0

package/src/components/ui/tu-do/shared/__tests__/board-header.test.tsx

@@ -382,6 +382,44 @@ describe('BoardHeader', () => {
     ).not.toBeInTheDocument();
   });
 
+  it('shows presence avatars for workspace boards', () => {
+    renderBoardHeader();
+
+    expect(screen.getByTestId('board-user-presence')).toBeInTheDocument();
+  });
+
+  it('hides presence avatars for unshared personal boards', () => {
+    renderBoardHeader({
+      isPersonalWorkspace: true,
+    });
+
+    expect(screen.queryByTestId('board-user-presence')).not.toBeInTheDocument();
+  });
+
+  it('shows presence avatars for personal boards shared with guests', () => {
+    renderBoardHeader({
+      board: {
+        ...mockBoard,
+        has_guest_access: true,
+      },
+      isPersonalWorkspace: true,
+    });
+
+    expect(screen.getByTestId('board-user-presence')).toBeInTheDocument();
+  });
+
+  it('shows presence avatars for direct board guest access', () => {
+    renderBoardHeader({
+      board: {
+        ...mockBoard,
+        access_type: 'guest',
+      },
+      isPersonalWorkspace: true,
+    });
+
+    expect(screen.getByTestId('board-user-presence')).toBeInTheDocument();
+  });
+
   it('updates status, view, and sort through combobox controls', () => {
     const onFiltersChange = vi.fn();
     const onListStatusFilterChange = vi.fn();

package/src/components/ui/tu-do/shared/__tests__/board-switcher.test.tsx

@@ -7,7 +7,7 @@ import { BoardSwitcher } from '../board-switcher';
 const {
   createWorkspaceTaskBoardMock,
   isTaskRememberLastBoardEnabledMock,
-  listWorkspaceTaskBoardsMock,
+  listCurrentUserTaskBoardsMock,
   pushMock,
   rememberLastBoardConfig,
   updateUserWorkspaceConfigMock,
@@ -17,7 +17,7 @@ const {
   isTaskRememberLastBoardEnabledMock: vi.fn(
     (value: string | null | undefined) => value !== 'false'
   ),
-  listWorkspaceTaskBoardsMock: vi.fn(),
+  listCurrentUserTaskBoardsMock: vi.fn(),
   pushMock: vi.fn(),
   rememberLastBoardConfig: {
     value: 'true' as string | null | undefined,
@@ -32,7 +32,14 @@ let comboboxProps:
       creatingText?: string;
       onChange: (value: string) => void;
       onCreate?: (value: string) => Promise<{ label: string; value: string }>;
-      options: Array<{ icon?: unknown; label: string; value: string }>;
+      options: Array<{
+        badge?: unknown;
+        description?: string;
+        group?: string;
+        icon?: unknown;
+        label: string;
+        value: string;
+      }>;
       searchPlaceholder?: string;
       selected?: string;
       showSelectedIcon?: boolean;
@@ -43,9 +50,9 @@ vi.mock('@tuturuuu/internal-api/tasks', () => ({
   createWorkspaceTaskBoard: (
     ...args: Parameters<typeof createWorkspaceTaskBoardMock>
   ) => createWorkspaceTaskBoardMock(...args),
-  listWorkspaceTaskBoards: (
-    ...args: Parameters<typeof listWorkspaceTaskBoardsMock>
-  ) => listWorkspaceTaskBoardsMock(...args),
+  listCurrentUserTaskBoards: (
+    ...args: Parameters<typeof listCurrentUserTaskBoardsMock>
+  ) => listCurrentUserTaskBoardsMock(...args),
 }));
 
 vi.mock('@tuturuuu/internal-api/users', () => ({
@@ -150,15 +157,25 @@ describe('BoardSwitcher', () => {
     vi.clearAllMocks();
     comboboxProps = undefined;
     rememberLastBoardConfig.value = 'true';
-    listWorkspaceTaskBoardsMock.mockResolvedValue({
+    listCurrentUserTaskBoardsMock.mockResolvedValue({
       boards: [
         {
+          access_type: 'member',
           archived_at: null,
           created_at: '2026-06-01T00:00:00.000Z',
           deleted_at: null,
           icon: null,
           id: 'board-2',
           name: 'Roadmap',
+          ticket_prefix: null,
+          workspace: {
+            avatar_url: null,
+            id: 'ws-1',
+            logo_url: null,
+            name: 'Current Workspace',
+            personal: false,
+          },
+          ws_id: 'ws-1',
         },
       ],
     });
@@ -188,6 +205,12 @@ describe('BoardSwitcher', () => {
     });
     expect(comboboxProps?.showSelectedIcon).toBeUndefined();
     expect(comboboxProps?.options.some((option) => option.icon)).toBe(true);
+    const activeBoardOption = comboboxProps?.options.find(
+      (option) => option.value === 'board-2'
+    );
+    expect(activeBoardOption?.badge).toBeUndefined();
+    expect(activeBoardOption?.description).toBeUndefined();
+    expect(activeBoardOption?.group).toBe('Current Workspace');
 
     fireEvent.click(screen.getByTestId('board-combobox'));
 
@@ -205,6 +228,69 @@ describe('BoardSwitcher', () => {
     });
   });
 
+  it('orders current workspace boards first and switches across workspaces without updating defaults', async () => {
+    listCurrentUserTaskBoardsMock.mockResolvedValue({
+      boards: [
+        {
+          access_type: 'member',
+          archived_at: null,
+          created_at: '2026-06-01T00:00:00.000Z',
+          deleted_at: null,
+          icon: null,
+          id: 'board-2',
+          name: 'External Roadmap',
+          ticket_prefix: null,
+          workspace: {
+            avatar_url: null,
+            id: 'ws-2',
+            logo_url: null,
+            name: 'Other Workspace',
+            personal: false,
+          },
+          ws_id: 'ws-2',
+        },
+        {
+          access_type: 'member',
+          archived_at: null,
+          created_at: '2026-06-01T00:00:00.000Z',
+          deleted_at: null,
+          icon: null,
+          id: 'board-current-secondary',
+          name: 'Current Roadmap',
+          ticket_prefix: null,
+          workspace: {
+            avatar_url: null,
+            id: 'ws-1',
+            logo_url: null,
+            name: 'Current Workspace',
+            personal: false,
+          },
+          ws_id: 'ws-1',
+        },
+      ],
+    });
+
+    renderBoardSwitcher();
+
+    await waitFor(() => {
+      expect(comboboxProps?.options.map((option) => option.value)).toEqual([
+        'board-1',
+        'board-current-secondary',
+        'board-2',
+      ]);
+    });
+    expect(comboboxProps?.options[2]).toMatchObject({
+      group: 'Other Workspace',
+      label: 'External Roadmap',
+      value: 'board-2',
+    });
+
+    fireEvent.click(screen.getByTestId('board-combobox'));
+
+    expect(pushMock).toHaveBeenCalledWith('/ws-2/tasks/boards/board-2');
+    expect(updateUserWorkspaceConfigMock).not.toHaveBeenCalled();
+  });
+
   it('navigates without updating the default board when board memory is disabled', async () => {
     rememberLastBoardConfig.value = 'false';
     renderBoardSwitcher();
@@ -219,6 +305,41 @@ describe('BoardSwitcher', () => {
     expect(updateUserWorkspaceConfigMock).not.toHaveBeenCalled();
   });
 
+  it('hides board creation for guest-only board access', async () => {
+    listCurrentUserTaskBoardsMock.mockResolvedValue({
+      boards: [
+        {
+          access_type: 'guest',
+          archived_at: null,
+          created_at: '2026-06-01T00:00:00.000Z',
+          deleted_at: null,
+          guest_permission: 'edit',
+          icon: null,
+          id: 'board-1',
+          name: 'Tasks',
+          ticket_prefix: null,
+          workspace: {
+            avatar_url: null,
+            guest_products: ['tasks'],
+            id: 'ws-1',
+            logo_url: null,
+            name: 'Shared Workspace',
+            personal: false,
+          },
+          ws_id: 'ws-1',
+        },
+      ],
+    });
+
+    renderBoardSwitcher();
+
+    await waitFor(() => {
+      expect(comboboxProps?.createText).toBeUndefined();
+      expect(comboboxProps?.creatingText).toBeUndefined();
+      expect(comboboxProps?.onCreate).toBeUndefined();
+    });
+  });
+
   it('creates a new board from the picker and opens it', async () => {
     createWorkspaceTaskBoardMock.mockResolvedValue({
       board: {

package/src/components/ui/tu-do/shared/__tests__/board-views.test.tsx

@@ -33,6 +33,11 @@ let kanbanBoardProps:
 let listViewProps:
   | React.ComponentProps<typeof import('../list-view')['ListView']>
   | undefined;
+let timelineBoardProps:
+  | React.ComponentProps<
+      typeof import('../../boards/boardId/timeline-board')['TimelineBoard']
+    >
+  | undefined;
 
 vi.mock('next-intl', () => ({
   useTranslations: () => (key: string) => key,
@@ -129,7 +134,10 @@ vi.mock('../list-view', () => ({
 }));
 
 vi.mock('../../boards/boardId/timeline-board', () => ({
-  TimelineBoard: () => <div data-testid="timeline-view">Timeline</div>,
+  TimelineBoard: (props: any) => {
+    timelineBoardProps = props;
+    return <div data-testid="timeline-view">Timeline</div>;
+  },
 }));
 
 const mockBoard = {
@@ -246,6 +254,7 @@ describe('BoardViews', () => {
     boardHeaderProps = undefined;
     kanbanBoardProps = undefined;
     listViewProps = undefined;
+    timelineBoardProps = undefined;
     createTaskMock.mockReset();
     loadListPageMock.mockReset();
     progressivePagination = {};
@@ -305,6 +314,61 @@ describe('BoardViews', () => {
     expect(listWorkspaceTasksMock).not.toHaveBeenCalled();
   });
 
+  it('enables assignees for personal boards that have guest access', async () => {
+    renderBoardViews({
+      board: {
+        ...mockBoard,
+        has_guest_access: true,
+      },
+      workspace: { id: 'ws-1', personal: true },
+    });
+
+    expect(kanbanBoardProps?.canUseBoardAssignees).toBe(true);
+    expect(kanbanBoardProps?.assigneeMemberSource).toBe('board');
+
+    await act(async () => {
+      boardHeaderProps?.onViewChange('list');
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('list-view')).toBeInTheDocument();
+    });
+    expect(listViewProps?.canUseBoardAssignees).toBe(true);
+    expect(listViewProps?.assigneeMemberSource).toBe('board');
+
+    await act(async () => {
+      boardHeaderProps?.onViewChange('timeline');
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('timeline-view')).toBeInTheDocument();
+    });
+    expect(timelineBoardProps?.canUseBoardAssignees).toBe(true);
+    expect(timelineBoardProps?.assigneeMemberSource).toBe('board');
+  });
+
+  it('keeps assignees hidden for unshared personal boards', () => {
+    renderBoardViews({
+      workspace: { id: 'ws-1', personal: true },
+    });
+
+    expect(kanbanBoardProps?.canUseBoardAssignees).toBe(false);
+    expect(kanbanBoardProps?.assigneeMemberSource).toBe('workspace');
+  });
+
+  it('merges workspace and board assignee sources for team boards that have guest access', () => {
+    renderBoardViews({
+      board: {
+        ...mockBoard,
+        has_guest_access: true,
+      },
+      workspace: { id: 'ws-1', personal: false },
+    });
+
+    expect(kanbanBoardProps?.canUseBoardAssignees).toBe(true);
+    expect(kanbanBoardProps?.assigneeMemberSource).toBe('workspace-and-board');
+  });
+
   it('renders board-scoped drafts and recycle bin views from the header mode switcher', async () => {
     renderBoardViews();
 
@@ -526,7 +590,7 @@ describe('BoardViews', () => {
     );
   });
 
-  it('expands the virtual external task list by default when assigned external tasks exist', () => {
+  it('collapses the virtual external task list by default even when assigned external tasks exist', () => {
     renderBoardViews({
       workspace: {
         ...mockWorkspace,
@@ -549,7 +613,7 @@ describe('BoardViews', () => {
     expect(kanbanBoardProps?.lists[0]).toEqual(
       expect.objectContaining({
         id: 'personal-external-staging:board-1',
-        is_external_collapsed: false,
+        is_external_collapsed: true,
         is_external_staging: true,
       })
     );
@@ -648,10 +712,10 @@ describe('BoardViews', () => {
     });
   });
 
-  it('persists deadline section collapse state per board and section', async () => {
+  it('collapses deadline sections by default and persists per board and section', async () => {
     window.localStorage.setItem(
       'task-board-deadline-section-collapsed:board-1:overdue',
-      'true'
+      'false'
     );
 
     renderBoardViews();
@@ -659,14 +723,14 @@ describe('BoardViews', () => {
     await waitFor(() => {
       expect(kanbanBoardProps?.deadlineSectionsCollapsed).toEqual(
         expect.objectContaining({
-          overdue: true,
-          upcoming: false,
+          overdue: false,
+          upcoming: true,
         })
       );
     });
 
     act(() => {
-      kanbanBoardProps?.onDeadlineSectionCollapsedChange?.('upcoming', true);
+      kanbanBoardProps?.onDeadlineSectionCollapsedChange?.('upcoming', false);
     });
 
     await waitFor(() => {
@@ -674,13 +738,96 @@ describe('BoardViews', () => {
         window.localStorage.getItem(
           'task-board-deadline-section-collapsed:board-1:upcoming'
         )
-      ).toBe('true');
+      ).toBe('false');
       expect(kanbanBoardProps?.deadlineSectionsCollapsed).toEqual(
         expect.objectContaining({
+          overdue: false,
+          upcoming: false,
+        })
+      );
+    });
+  });
+
+  it('does not force pinned special task lists to stay expanded', async () => {
+    getUserWorkspaceConfigMock.mockImplementation(
+      (_workspaceId: string, configId: string) =>
+        Promise.resolve({
+          value:
+            configId === 'TASK_BOARD_PINNED_SPECIAL_LISTS'
+              ? JSON.stringify([
+                  'external_tasks',
+                  'closed_tasks',
+                  'overdue',
+                  'upcoming',
+                ])
+              : null,
+        })
+    );
+
+    renderBoardViews({
+      lists: [...mockLists, closedList],
+      workspace: {
+        ...mockWorkspace,
+        personal: true,
+      },
+    });
+
+    await waitFor(() => {
+      expect(kanbanBoardProps?.specialTaskListPins).toEqual(
+        expect.objectContaining({
+          closed_tasks: true,
+          external_tasks: true,
           overdue: true,
           upcoming: true,
         })
       );
+      expect(kanbanBoardProps?.lists[0]).toEqual(
+        expect.objectContaining({
+          is_external_collapsed: true,
+          is_external_staging: true,
+        })
+      );
+      expect(
+        kanbanBoardProps?.lists.find((list) => list.id === 'list-closed')
+      ).toEqual(
+        expect.objectContaining({
+          is_collapsed: true,
+          status: 'closed',
+        })
+      );
+      expect(kanbanBoardProps?.deadlineSectionsCollapsed).toEqual(
+        expect.objectContaining({
+          overdue: true,
+          upcoming: true,
+        })
+      );
+    });
+
+    act(() => {
+      kanbanBoardProps?.onExternalTasksCollapsedChange?.(false);
+      kanbanBoardProps?.onTaskListCollapsedChange?.('list-closed', false);
+      kanbanBoardProps?.onDeadlineSectionCollapsedChange?.('overdue', false);
+    });
+
+    await waitFor(() => {
+      expect(kanbanBoardProps?.lists[0]).toEqual(
+        expect.objectContaining({
+          is_external_collapsed: false,
+        })
+      );
+      expect(
+        kanbanBoardProps?.lists.find((list) => list.id === 'list-closed')
+      ).toEqual(
+        expect.objectContaining({
+          is_collapsed: false,
+        })
+      );
+      expect(kanbanBoardProps?.deadlineSectionsCollapsed).toEqual(
+        expect.objectContaining({
+          overdue: false,
+          upcoming: true,
+        })
+      );
     });
   });
 
@@ -987,6 +1134,72 @@ describe('BoardViews', () => {
     });
   });
 
+  it('uses the route default view instead of stale local My Tasks config', async () => {
+    window.localStorage.setItem(
+      getBoardConfigKey(mockBoard.id),
+      JSON.stringify({
+        currentView: 'my_tasks',
+        filters: {
+          assignees: [],
+          dueDateRange: null,
+          estimationRange: null,
+          includeMyTasks: false,
+          includeUnassigned: false,
+          labels: [],
+          priorities: [],
+          projects: [],
+          sourceBoardIds: [],
+          sourceScope: 'all_visible',
+          sourceWorkspaceIds: [],
+        },
+        listStatusFilter: 'all',
+      })
+    );
+    window.history.replaceState({}, '', '/ws-1/tasks/boards/board-1');
+
+    renderBoardViews({ props: { defaultView: 'kanban' } });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('kanban-view')).toBeInTheDocument();
+    });
+    expect(screen.queryByTestId('my-tasks-view')).not.toBeInTheDocument();
+  });
+
+  it('lets an explicit URL view override the route default view', async () => {
+    window.localStorage.setItem(
+      getBoardConfigKey(mockBoard.id),
+      JSON.stringify({
+        currentView: 'timeline',
+        filters: {
+          assignees: [],
+          dueDateRange: null,
+          estimationRange: null,
+          includeMyTasks: false,
+          includeUnassigned: false,
+          labels: [],
+          priorities: [],
+          projects: [],
+          sourceBoardIds: [],
+          sourceScope: 'all_visible',
+          sourceWorkspaceIds: [],
+        },
+        listStatusFilter: 'all',
+      })
+    );
+    window.history.replaceState(
+      {},
+      '',
+      '/ws-1/tasks/boards/board-1?view=my_tasks'
+    );
+
+    renderBoardViews({ props: { defaultView: 'kanban' } });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('my-tasks-view')).toBeInTheDocument();
+    });
+    expect(screen.queryByTestId('kanban-view')).not.toBeInTheDocument();
+  });
+
   it('ignores board hotkeys while typing in an input', async () => {
     renderBoardViews();
     const input = screen.getByTestId('board-header-input');

package/src/components/ui/tu-do/shared/__tests__/task-board-loading-state.test.tsx

@@ -10,8 +10,66 @@ describe('TaskBoardLoadingState', () => {
     expect(screen.getByTestId('task-board-loading-state')).toHaveClass(
       '-m-4',
       'h-[calc(100dvh+2rem)]',
+      'w-[calc(100%+2rem)]',
       'bg-transparent'
     );
     expect(screen.getByTestId('kanban-skeleton')).toHaveClass('bg-transparent');
+    expect(screen.getByTestId('kanban-skeleton-frame')).toHaveClass(
+      'py-2',
+      'pl-2',
+      'pr-0'
+    );
+    expect(screen.getByTestId('kanban-skeleton-frame')).not.toHaveClass('p-2');
+    expect(
+      screen.queryByTestId('task-board-header-skeleton')
+    ).not.toBeInTheDocument();
+  });
+
+  it('keeps embedded loading skeletons constrained to the parent width', () => {
+    render(<TaskBoardLoadingState />);
+
+    expect(screen.getByTestId('task-board-loading-state')).toHaveClass(
+      'w-full',
+      'h-[calc(100dvh-1rem)]'
+    );
+    expect(screen.getByTestId('task-board-loading-state')).not.toHaveClass(
+      '-m-4',
+      'w-[calc(100%+2rem)]'
+    );
+    expect(screen.getByTestId('kanban-skeleton-frame')).toHaveClass('p-2');
+    expect(
+      screen.queryByTestId('task-board-header-skeleton')
+    ).not.toBeInTheDocument();
+  });
+
+  it('can include the board header skeleton above the kanban skeleton', () => {
+    render(<TaskBoardLoadingState root showHeader />);
+
+    expect(screen.getByTestId('task-board-loading-state')).toHaveClass(
+      '-m-4',
+      'h-[calc(100dvh+2rem)]',
+      'w-[calc(100%+2rem)]',
+      'flex',
+      'flex-col'
+    );
+    expect(screen.getByTestId('task-board-header-skeleton')).toHaveAttribute(
+      'aria-hidden',
+      'true'
+    );
+    expect(screen.getByTestId('task-board-header-skeleton')).toHaveClass(
+      'border-b',
+      'px-2',
+      'pt-2',
+      'pb-2'
+    );
+    expect(screen.getByTestId('task-board-header-skeleton')).not.toHaveClass(
+      '-mt-2'
+    );
+    expect(screen.getByTestId('task-board-loading-body')).toHaveClass(
+      'min-h-0',
+      'flex-1',
+      'overflow-hidden'
+    );
+    expect(screen.getByTestId('kanban-skeleton')).toBeInTheDocument();
   });
 });