@tuturuuu/ui 0.2.0 → 0.3.2

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

@@ -1,7 +1,7 @@
 import '@testing-library/jest-dom';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { act, render, screen, waitFor } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   getActiveBoardRefresh,
   setActiveBoardRefresh,
@@ -84,6 +84,10 @@ describe('BoardClient', () => {
     setActiveBoardRefresh(null);
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   it('loads dependent board data with the fetched board workspace id', async () => {
     const queryClient = new QueryClient({
       defaultOptions: {
@@ -149,4 +153,53 @@ describe('BoardClient', () => {
     });
     expect(revalidateLoadedListsMock).toHaveBeenCalledTimes(1);
   });
+
+  it('throttles focus-driven list revalidation for thirty seconds', async () => {
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(100_000);
+    const queryClient = new QueryClient({
+      defaultOptions: {
+        queries: {
+          retry: false,
+        },
+      },
+    });
+
+    render(
+      <QueryClientProvider client={queryClient}>
+        <BoardClient
+          boardId="board-1"
+          workspace={{ id: 'workspace-uuid', personal: false } as any}
+          currentUserId="user-1"
+        />
+      </QueryClientProvider>
+    );
+
+    expect(await screen.findByTestId('board-views')).toBeInTheDocument();
+
+    await act(async () => {
+      window.dispatchEvent(new Event('focus'));
+    });
+
+    await waitFor(() => {
+      expect(revalidateLoadedListsMock).toHaveBeenCalledTimes(1);
+    });
+
+    nowSpy.mockReturnValue(101_500);
+
+    await act(async () => {
+      window.dispatchEvent(new Event('focus'));
+    });
+
+    expect(revalidateLoadedListsMock).toHaveBeenCalledTimes(1);
+
+    nowSpy.mockReturnValue(130_000);
+
+    await act(async () => {
+      window.dispatchEvent(new Event('focus'));
+    });
+
+    await waitFor(() => {
+      expect(revalidateLoadedListsMock).toHaveBeenCalledTimes(2);
+    });
+  });
 });

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

@@ -135,6 +135,19 @@ const mockLists: TaskList[] = [
   },
 ];
 
+const closedList: TaskList = {
+  archived: false,
+  board_id: 'board-1',
+  color: 'PURPLE',
+  created_at: '2026-03-07T00:00:00.000Z',
+  creator_id: 'user-1',
+  deleted: false,
+  id: 'list-closed',
+  name: 'Closed',
+  position: 2,
+  status: 'closed',
+};
+
 const mockTasks: Task[] = [
   {
     assignees: [],
@@ -154,6 +167,7 @@ const mockTasks: Task[] = [
 const mockWorkspaceLabels: WorkspaceLabel[] = [];
 
 function renderBoardViews(overrides?: {
+  idleBottomIsland?: React.ReactNode;
   lists?: TaskList[];
   tasks?: Task[];
   workspace?: { id: string; personal: boolean };
@@ -176,6 +190,7 @@ function renderBoardViews(overrides?: {
           tasks={overrides?.tasks ?? mockTasks}
           workspace={(overrides?.workspace ?? mockWorkspace) as any}
           workspaceLabels={mockWorkspaceLabels}
+          idleBottomIsland={overrides?.idleBottomIsland}
         />
       </HotkeysProvider>
     </QueryClientProvider>
@@ -237,6 +252,51 @@ describe('BoardViews', () => {
     });
   });
 
+  it('toggles the idle bottom island around active kanban bulk selection', async () => {
+    renderBoardViews({
+      idleBottomIsland: <div data-testid="idle-bottom-island" />,
+    });
+
+    expect(screen.getByTestId('idle-bottom-island')).toBeInTheDocument();
+
+    act(() => {
+      kanbanBoardProps?.onBulkSelectionActiveChange?.(true);
+    });
+
+    expect(screen.queryByTestId('idle-bottom-island')).toBeNull();
+
+    act(() => {
+      kanbanBoardProps?.onBulkSelectionActiveChange?.(false);
+    });
+
+    expect(screen.getByTestId('idle-bottom-island')).toBeInTheDocument();
+  });
+
+  it('keeps the idle bottom island visible outside kanban view', async () => {
+    renderBoardViews({
+      idleBottomIsland: <div data-testid="idle-bottom-island" />,
+    });
+
+    act(() => {
+      kanbanBoardProps?.onBulkSelectionActiveChange?.(true);
+      boardHeaderProps?.onViewChange('list');
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('list-view')).toBeInTheDocument();
+    });
+    expect(screen.getByTestId('idle-bottom-island')).toBeInTheDocument();
+
+    act(() => {
+      boardHeaderProps?.onViewChange('timeline');
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('timeline-view')).toBeInTheDocument();
+    });
+    expect(screen.getByTestId('idle-bottom-island')).toBeInTheDocument();
+  });
+
   it('creates a task from the first visible list with the board filters when pressing C', () => {
     renderBoardViews();
 
@@ -358,6 +418,63 @@ describe('BoardViews', () => {
     });
   });
 
+  it('collapses closed task lists by default', () => {
+    renderBoardViews({
+      lists: [...mockLists, closedList],
+    });
+
+    expect(
+      kanbanBoardProps?.lists.find((list) => list.id === 'list-closed')
+    ).toEqual(
+      expect.objectContaining({
+        is_collapsed: true,
+        status: 'closed',
+      })
+    );
+  });
+
+  it('persists the collapsed closed task list state per board and list', async () => {
+    window.localStorage.setItem(
+      'task-board-closed-list-collapsed:board-1:list-closed',
+      'false'
+    );
+
+    renderBoardViews({
+      lists: [...mockLists, closedList],
+    });
+
+    await waitFor(() => {
+      expect(
+        kanbanBoardProps?.lists.find((list) => list.id === 'list-closed')
+      ).toEqual(
+        expect.objectContaining({
+          is_collapsed: false,
+          status: 'closed',
+        })
+      );
+    });
+
+    act(() => {
+      kanbanBoardProps?.onTaskListCollapsedChange?.('list-closed', true);
+    });
+
+    await waitFor(() => {
+      expect(
+        window.localStorage.getItem(
+          'task-board-closed-list-collapsed:board-1:list-closed'
+        )
+      ).toBe('true');
+      expect(
+        kanbanBoardProps?.lists.find((list) => list.id === 'list-closed')
+      ).toEqual(
+        expect.objectContaining({
+          is_collapsed: true,
+          status: 'closed',
+        })
+      );
+    });
+  });
+
   it('excludes deleted lists from active board views and create shortcuts', () => {
     const listsWithDeletedFirst: TaskList[] = [
       {
@@ -500,6 +617,47 @@ describe('BoardViews', () => {
     });
   });
 
+  it('uses server-side search counts to hide task lists without matching tasks', async () => {
+    listWorkspaceTasksMock.mockImplementation(async (_workspaceId, options) => {
+      if (options?.includeListCounts) {
+        return {
+          listCounts: [{ count: 1, list_id: 'list-1' }],
+          tasks: [],
+        };
+      }
+
+      return { tasks: [mockTasks[0]!] };
+    });
+
+    renderBoardViews();
+
+    act(() => {
+      boardHeaderProps?.onFiltersChange({
+        ...boardHeaderProps.filters,
+        estimationRange: { max: 5, min: 2 },
+        searchQuery: 'TIMELINE',
+      });
+    });
+
+    await waitFor(() => {
+      expect(listWorkspaceTasksMock).toHaveBeenCalledWith(
+        'ws-1',
+        expect.objectContaining({
+          boardId: 'board-1',
+          estimationMax: 5,
+          estimationMin: 2,
+          includeListCounts: true,
+          limit: 0,
+          q: 'TIMELINE',
+        })
+      );
+    });
+
+    await waitFor(() => {
+      expect(kanbanBoardProps?.lists).toEqual([mockLists[0]]);
+    });
+  });
+
   it('does not auto-load progressive list pages for server-backed source scopes', async () => {
     progressivePagination = {
       'list-1': {

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

@@ -52,17 +52,20 @@ const {
 
 vi.mock('@tuturuuu/internal-api', () => ({
   getCurrentUserProfile: mockGetCurrentUserProfile,
-  listWorkspaceLabels: mockListWorkspaceLabels,
-  listWorkspaceMembers: mockListWorkspaceMembers,
 }));
 
 vi.mock('@tuturuuu/internal-api/tasks', () => ({
   getCurrentUserTask: mockGetCurrentUserTask,
   getWorkspaceTask: mockGetWorkspaceTask,
+  listWorkspaceLabels: mockListWorkspaceLabels,
   listWorkspaceTaskProjectsByIds: mockListWorkspaceTaskProjectsByIds,
   resolveTaskProjectWorkspaceId: mockResolveTaskProjectWorkspaceId,
 }));
 
+vi.mock('@tuturuuu/internal-api/workspaces', () => ({
+  listWorkspaceMembers: mockListWorkspaceMembers,
+}));
+
 vi.mock('@tuturuuu/supabase/next/client', () => ({
   createClient: vi.fn(() => ({
     auth: {

package/src/components/ui/tu-do/shared/board-client.tsx

@@ -14,7 +14,7 @@ import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
 import { useBoardRealtime } from '@tuturuuu/ui/hooks/useBoardRealtime';
 import { useWorkspaceLabels } from '@tuturuuu/utils/task-helper';
 import { useRouter } from 'next/navigation';
-import { useCallback, useEffect, useMemo } from 'react';
+import { type ReactNode, useCallback, useEffect, useMemo } from 'react';
 import {
   BoardBroadcastProvider,
   type BoardRefreshOptions,
@@ -26,16 +26,20 @@ import { ProgressiveLoaderProvider } from './progressive-loader-context';
 import { dispatchRecentSidebarVisit } from './recent-sidebar-events';
 import { useProgressiveBoardLoader } from './use-progressive-board-loader';
 
+const BOARD_REVALIDATE_COOLDOWN_MS = 30_000;
+
 interface Props {
   boardId: string;
   workspace: Workspace;
   workspaceTier?: WorkspaceProductTier | null;
   currentUserId?: string;
   routePrefix?: string;
+  idleBottomIsland?: ReactNode;
 }
 
 export function BoardClient({
   boardId,
+  idleBottomIsland,
   workspace,
   workspaceTier,
   currentUserId,
@@ -100,7 +104,12 @@ export function BoardClient({
 
     const revalidateLoadedLists = () => {
       const now = Date.now();
-      if (isRevalidating || now - lastRevalidateAt < 1500) return;
+      if (
+        isRevalidating ||
+        now - lastRevalidateAt < BOARD_REVALIDATE_COOLDOWN_MS
+      ) {
+        return;
+      }
 
       isRevalidating = true;
       lastRevalidateAt = now;
@@ -261,6 +270,7 @@ export function BoardClient({
           workspaceLabels={workspaceLabels}
           currentUserId={currentUserId}
           canManageBoard={canManageBoard}
+          idleBottomIsland={idleBottomIsland}
         />
       </ProgressiveLoaderProvider>
     </BoardBroadcastProvider>