@tuturuuu/ui 0.8.0 → 0.10.0

package/src/components/ui/tu-do/boards/boardId/task-board-server-page.test.tsx

@@ -72,16 +72,18 @@ const BOARD_ID = '11111111-1111-1111-1111-111111111111';
 
 type BoardClientElement = ReactElement<{
   currentUserId?: string;
+  rootLoading?: boolean;
   workspace: unknown;
   workspaceTier: unknown;
 }>;
 
-function renderServerPage() {
+function renderServerPage(options?: { rootLoading?: boolean }) {
   return TaskBoardServerPage({
     params: Promise.resolve({
       boardId: BOARD_ID,
       wsId: 'ws-1',
     }),
+    rootLoading: options?.rootLoading,
   }) as Promise<BoardClientElement>;
 }
 
@@ -111,6 +113,28 @@ describe('TaskBoardServerPage', () => {
     expect(mocks.getWorkspace).not.toHaveBeenCalled();
   });
 
+  it('treats invalid board routes as not found instead of crashing the server render', async () => {
+    mocks.getWorkspaceTaskBoard.mockRejectedValue(
+      new mocks.InternalApiError('Invalid workspace or board ID', 400)
+    );
+
+    await expect(renderServerPage()).rejects.toThrow('NEXT_NOT_FOUND');
+
+    expect(mocks.getWorkspace).not.toHaveBeenCalled();
+  });
+
+  it('keeps unexpected board loader failures visible', async () => {
+    mocks.getWorkspaceTaskBoard.mockRejectedValue(
+      new mocks.InternalApiError('Failed to load task board', 500)
+    );
+
+    await expect(renderServerPage()).rejects.toThrow(
+      'Failed to load task board'
+    );
+
+    expect(mocks.getWorkspace).not.toHaveBeenCalled();
+  });
+
   it('uses a minimal workspace shell for board guests', async () => {
     mocks.getWorkspaceTaskBoard.mockResolvedValue({
       board: {
@@ -134,10 +158,10 @@ describe('TaskBoardServerPage', () => {
     expect(element.props.currentUserId).toBe('user-1');
   });
 
-  it('loads the full member workspace only after board access succeeds', async () => {
+  it('loads the full member workspace from the resolved board workspace', async () => {
     const workspace = {
       creator_id: 'creator-1',
-      id: 'ws-1',
+      id: 'ws-board',
       joined: true,
       name: 'Member Workspace',
       personal: false,
@@ -147,18 +171,39 @@ describe('TaskBoardServerPage', () => {
       board: {
         access_type: 'member',
         id: BOARD_ID,
-        ws_id: 'ws-1',
+        ws_id: 'ws-board',
       },
     });
     mocks.getWorkspace.mockResolvedValue(workspace);
 
     const element = await renderServerPage();
 
-    expect(mocks.getWorkspace).toHaveBeenCalledWith('ws-1', {
+    expect(mocks.getWorkspace).toHaveBeenCalledWith('ws-board', {
       useAdmin: true,
     });
     expect(element.type).toBe(mocks.BoardClient);
     expect(element.props.workspace).toBe(workspace);
     expect(element.props.workspaceTier).toBe('FREE');
   });
+
+  it('passes full-bleed loading through to the board client when requested', async () => {
+    const workspace = {
+      id: 'ws-board',
+      joined: true,
+      personal: false,
+      tier: 'FREE',
+    };
+    mocks.getWorkspaceTaskBoard.mockResolvedValue({
+      board: {
+        access_type: 'member',
+        id: BOARD_ID,
+        ws_id: 'ws-board',
+      },
+    });
+    mocks.getWorkspace.mockResolvedValue(workspace);
+
+    const element = await renderServerPage({ rootLoading: true });
+
+    expect(element.props.rootLoading).toBe(true);
+  });
 });

package/src/components/ui/tu-do/boards/boardId/task-board-server-page.tsx

@@ -14,6 +14,7 @@ import { getWorkspace } from '@tuturuuu/utils/workspace-helper';
 import { headers } from 'next/headers';
 import { notFound, redirect } from 'next/navigation';
 import type { ReactNode } from 'react';
+import type { ViewType } from '../../shared/board-views';
 
 interface Props {
   params: Promise<{
@@ -22,7 +23,9 @@ interface Props {
   }>;
   /** Route prefix for tasks URLs. Defaults to '/tasks' (web app). Set to '' for satellite apps. */
   routePrefix?: string;
+  defaultView?: ViewType;
   idleBottomIsland?: ReactNode;
+  rootLoading?: boolean;
 }
 
 type AuthorizedWorkspace = Workspace & {
@@ -53,7 +56,10 @@ async function getAuthorizedBoard(wsId: string, boardId: string) {
   } catch (error) {
     if (
       error instanceof InternalApiError &&
-      (error.status === 401 || error.status === 403 || error.status === 404)
+      (error.status === 400 ||
+        error.status === 401 ||
+        error.status === 403 ||
+        error.status === 404)
     ) {
       return null;
     }
@@ -68,9 +74,11 @@ async function getAuthorizedBoard(wsId: string, boardId: string) {
  * Used by both apps/web and apps/tasks.
  */
 export default async function TaskBoardServerPage({
+  defaultView,
   idleBottomIsland,
   params,
   routePrefix = '/tasks',
+  rootLoading = false,
 }: Props) {
   const { wsId: id, boardId } = await params;
 
@@ -82,7 +90,7 @@ export default async function TaskBoardServerPage({
 
   const isMemberBoardAccess = board.access_type === 'member';
   const workspace = isMemberBoardAccess
-    ? await getWorkspace(id, { useAdmin: true })
+    ? await getWorkspace(board.ws_id, { useAdmin: true })
     : createBoardGuestWorkspace(board.ws_id);
   if (!workspace) notFound();
 
@@ -92,8 +100,10 @@ export default async function TaskBoardServerPage({
       workspace={workspace}
       workspaceTier={workspace.tier ?? null}
       currentUserId={user.id}
+      defaultView={defaultView}
       routePrefix={routePrefix}
       idleBottomIsland={idleBottomIsland}
+      rootLoading={rootLoading}
     />
   );
 }

package/src/components/ui/tu-do/boards/boardId/task-card/measured-task-card.tsx

@@ -1,7 +1,7 @@
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import type { TaskList } from '@tuturuuu/types/primitives/TaskList';
 import { type MouseEvent, useEffect, useRef } from 'react';
-import { TaskCard } from './task-card';
+import { TaskCard, type TaskCardAssigneeMemberSource } from './task-card';
 
 interface MeasuredTaskCardProps {
   task: Task;
@@ -13,6 +13,8 @@ interface MeasuredTaskCardProps {
   isSelected: boolean;
   isMultiSelectMode?: boolean;
   isPersonalWorkspace?: boolean;
+  canUseBoardAssignees?: boolean;
+  assigneeMemberSource?: TaskCardAssigneeMemberSource;
   onSelect?: (taskId: string, event: MouseEvent) => void;
   onClearSelection?: () => void;
   suppressSortableTransform?: boolean;
@@ -21,6 +23,7 @@ interface MeasuredTaskCardProps {
   optimisticUpdateInProgress?: Set<string>;
   selectedTasks?: Set<string>;
   bulkUpdateCustomDueDate?: (date: Date | null) => Promise<void>;
+  readOnly?: boolean;
 }
 
 export function MeasuredTaskCard({
@@ -33,6 +36,8 @@ export function MeasuredTaskCard({
   isSelected,
   isMultiSelectMode,
   isPersonalWorkspace,
+  canUseBoardAssignees,
+  assigneeMemberSource,
   onSelect,
   onClearSelection,
   suppressSortableTransform,
@@ -41,6 +46,7 @@ export function MeasuredTaskCard({
   optimisticUpdateInProgress,
   selectedTasks,
   bulkUpdateCustomDueDate,
+  readOnly = false,
 }: MeasuredTaskCardProps) {
   const ref = useRef<HTMLDivElement | null>(null);
   const onHeightRef = useRef(onHeight);
@@ -97,12 +103,15 @@ export function MeasuredTaskCard({
         isSelected={isSelected}
         isMultiSelectMode={isMultiSelectMode}
         isPersonalWorkspace={isPersonalWorkspace}
+        canUseBoardAssignees={canUseBoardAssignees}
+        assigneeMemberSource={assigneeMemberSource}
         onSelect={onSelect}
         onClearSelection={onClearSelection}
         suppressSortableTransform={suppressSortableTransform}
         optimisticUpdateInProgress={optimisticUpdateInProgress}
         selectedTasks={selectedTasks}
         bulkUpdateCustomDueDate={bulkUpdateCustomDueDate}
+        readOnly={readOnly}
       />
     </div>
   );

package/src/components/ui/tu-do/boards/boardId/task-card/task-card-comparator.ts

@@ -25,6 +25,7 @@ export function areTaskCardPropsEqual(
   next: TaskCardProps
 ) {
   if (prev.isOverlay !== next.isOverlay) return false;
+  if (prev.readOnly !== next.readOnly) return false;
   if (prev.isSelected !== next.isSelected) return false;
   if (prev.isMultiSelectMode !== next.isMultiSelectMode) return false;
   if (
@@ -36,6 +37,8 @@ export function areTaskCardPropsEqual(
   }
   if (prev.boardId !== next.boardId) return false;
   if (prev.workspaceId !== next.workspaceId) return false;
+  if (prev.deadlineContext !== next.deadlineContext) return false;
+  if (prev.deadlineNow !== next.deadlineNow) return false;
   if (prev.dragDisabled !== next.dragDisabled) return false;
   if (prev.sortableId !== next.sortableId) return false;
   if (prev.suppressSortableTransform !== next.suppressSortableTransform) {

package/src/components/ui/tu-do/boards/boardId/task-card/task-card-open-options.test.ts

@@ -75,6 +75,8 @@ describe('getTaskCardHydratingOpenOptions', () => {
       ],
       taskWsId: 'source-workspace',
       taskWorkspacePersonal: false,
+      canUseBoardAssignees: true,
+      assigneeMemberSource: 'workspace',
       initialSharedContext: {
         boardConfig: {
           id: 'source-board',
@@ -118,10 +120,28 @@ describe('getTaskCardHydratingOpenOptions', () => {
       availableLists: [list],
       taskWsId: 'workspace-1',
       taskWorkspacePersonal: true,
+      canUseBoardAssignees: false,
+      assigneeMemberSource: undefined,
       initialSharedContext: undefined,
     });
   });
 
+  it('can keep assignees enabled for shared personal board tasks', () => {
+    expect(
+      getTaskCardHydratingOpenOptions({
+        task,
+        boardId: 'board-1',
+        availableLists: [list],
+        canUseBoardAssignees: true,
+        effectiveWorkspaceId: 'workspace-1',
+        isPersonalWorkspace: true,
+      })
+    ).toMatchObject({
+      canUseBoardAssignees: true,
+      taskWorkspacePersonal: true,
+    });
+  });
+
   it('treats source metadata as an external task snapshot', () => {
     expect(
       isExternalTaskSnapshot({

package/src/components/ui/tu-do/boards/boardId/task-card/task-card-open-options.ts

@@ -6,6 +6,8 @@ interface TaskCardOpenOptionsInput {
   task: Task;
   boardId: string;
   availableLists?: TaskList[];
+  assigneeMemberSource?: 'workspace' | 'board' | 'workspace-and-board';
+  canUseBoardAssignees?: boolean;
   effectiveWorkspaceId?: string;
   isPersonalWorkspace: boolean;
 }
@@ -96,6 +98,8 @@ export function getTaskCardHydratingOpenOptions({
   task,
   boardId,
   availableLists,
+  assigneeMemberSource,
+  canUseBoardAssignees,
   effectiveWorkspaceId,
   isPersonalWorkspace,
 }: TaskCardOpenOptionsInput) {
@@ -110,6 +114,9 @@ export function getTaskCardHydratingOpenOptions({
     ...task,
     list_id: task.source_list_id ?? task.list_id,
   };
+  const sourceBoardAssigneesEnabled = sourceWorkspaceId
+    ? true
+    : !isPersonalWorkspace;
 
   return {
     initialTask,
@@ -122,6 +129,9 @@ export function getTaskCardHydratingOpenOptions({
           : availableLists,
     taskWsId: sourceWorkspaceId ?? effectiveWorkspaceId,
     taskWorkspacePersonal: sourceWorkspaceId ? false : isPersonalWorkspace,
+    canUseBoardAssignees: canUseBoardAssignees ?? sourceBoardAssigneesEnabled,
+    assigneeMemberSource:
+      assigneeMemberSource ?? (sourceWorkspaceId ? 'workspace' : undefined),
     initialSharedContext,
   };
 }