@tuturuuu/ui 0.9.0 → 0.11.0

package/src/components/ui/tu-do/shared/task-cache-patches.ts

@@ -0,0 +1,394 @@
+import type { QueryClient, QueryKey } from '@tanstack/react-query';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+
+type WorkspaceTaskCache = {
+  task?: Task | null;
+};
+
+type MyTasksCache = {
+  overdue?: Task[];
+  today?: Task[];
+  upcoming?: Task[];
+  completed?: Task[];
+};
+
+type MyCompletedTasksCache = {
+  pages?: Array<{
+    completed?: Task[];
+  }>;
+};
+
+export type VisibleTaskCacheSnapshot = {
+  boardTaskEntries: [QueryKey, Task[] | undefined][];
+  taskEntries: [QueryKey, Task | undefined][];
+  workspaceTaskEntries: [QueryKey, WorkspaceTaskCache | undefined][];
+  myTasksEntries: [QueryKey, MyTasksCache | undefined][];
+  myCompletedTaskEntries: [QueryKey, MyCompletedTasksCache | undefined][];
+};
+
+function isBoardTaskQuery(queryKey: QueryKey, boardId: string) {
+  return (
+    Array.isArray(queryKey) &&
+    (queryKey[0] === 'tasks' || queryKey[0] === 'tasks-full') &&
+    queryKey[1] === boardId
+  );
+}
+
+function isTaskDetailQuery(queryKey: QueryKey, taskIds: Set<string>) {
+  return (
+    Array.isArray(queryKey) &&
+    queryKey[0] === 'task' &&
+    typeof queryKey[1] === 'string' &&
+    taskIds.has(queryKey[1])
+  );
+}
+
+function isWorkspaceTaskQuery(queryKey: QueryKey, taskIds: Set<string>) {
+  return (
+    Array.isArray(queryKey) &&
+    queryKey[0] === 'workspaceTask' &&
+    typeof queryKey[2] === 'string' &&
+    taskIds.has(queryKey[2])
+  );
+}
+
+function patchTaskArray<T extends { id?: string }>(
+  tasks: T[] | undefined,
+  taskIds: Set<string>,
+  updater: (task: Task) => Task
+): T[] | undefined {
+  if (!tasks) return tasks;
+
+  let changed = false;
+  const nextTasks = tasks.map((task) => {
+    if (!task.id || !taskIds.has(task.id)) {
+      return task;
+    }
+
+    const updatedTask = updater(task as unknown as Task) as unknown as T;
+    if (updatedTask !== task) {
+      changed = true;
+    }
+
+    return updatedTask;
+  });
+
+  return changed ? nextTasks : tasks;
+}
+
+function restoreTaskArrayFromSnapshot<T extends { id?: string }>(
+  currentTasks: T[] | undefined,
+  previousTasks: T[] | undefined,
+  taskIds: Set<string>
+): T[] | undefined {
+  if (!currentTasks || !previousTasks) return currentTasks;
+
+  const previousById = new Map(
+    previousTasks
+      .filter((task) => task.id && taskIds.has(task.id))
+      .map((task) => [task.id, task])
+  );
+  if (previousById.size === 0) return currentTasks;
+
+  let changed = false;
+  const restoredTasks = currentTasks.map((task) => {
+    if (!task.id) return task;
+    const previousTask = previousById.get(task.id);
+    if (!previousTask) return task;
+
+    changed = true;
+    return previousTask;
+  });
+
+  return changed ? restoredTasks : currentTasks;
+}
+
+function patchMyTasksCache(
+  cache: MyTasksCache | undefined,
+  taskIds: Set<string>,
+  updater: (task: Task) => Task
+) {
+  if (!cache) return cache;
+
+  return {
+    ...cache,
+    overdue: patchTaskArray(cache.overdue, taskIds, updater) ?? cache.overdue,
+    today: patchTaskArray(cache.today, taskIds, updater) ?? cache.today,
+    upcoming:
+      patchTaskArray(cache.upcoming, taskIds, updater) ?? cache.upcoming,
+    completed:
+      patchTaskArray(cache.completed, taskIds, updater) ?? cache.completed,
+  };
+}
+
+function patchMyCompletedTasksCache(
+  cache: MyCompletedTasksCache | undefined,
+  taskIds: Set<string>,
+  updater: (task: Task) => Task
+) {
+  if (!cache?.pages) return cache;
+
+  return {
+    ...cache,
+    pages: cache.pages.map((page) => ({
+      ...page,
+      completed:
+        patchTaskArray(page.completed, taskIds, updater) ?? page.completed,
+    })),
+  };
+}
+
+function restoreMyTasksCacheFromSnapshot(
+  current: MyTasksCache | undefined,
+  previous: MyTasksCache | undefined,
+  taskIds: Set<string>
+) {
+  if (!current || !previous) return current;
+
+  return {
+    ...current,
+    overdue:
+      restoreTaskArrayFromSnapshot(
+        current.overdue,
+        previous.overdue,
+        taskIds
+      ) ?? current.overdue,
+    today:
+      restoreTaskArrayFromSnapshot(current.today, previous.today, taskIds) ??
+      current.today,
+    upcoming:
+      restoreTaskArrayFromSnapshot(
+        current.upcoming,
+        previous.upcoming,
+        taskIds
+      ) ?? current.upcoming,
+    completed:
+      restoreTaskArrayFromSnapshot(
+        current.completed,
+        previous.completed,
+        taskIds
+      ) ?? current.completed,
+  };
+}
+
+function restoreMyCompletedTasksCacheFromSnapshot(
+  current: MyCompletedTasksCache | undefined,
+  previous: MyCompletedTasksCache | undefined,
+  taskIds: Set<string>
+) {
+  if (!current?.pages || !previous?.pages) return current;
+
+  return {
+    ...current,
+    pages: current.pages.map((page, index) => ({
+      ...page,
+      completed:
+        restoreTaskArrayFromSnapshot(
+          page.completed,
+          previous.pages?.[index]?.completed,
+          taskIds
+        ) ?? page.completed,
+    })),
+  };
+}
+
+export function getTaskFromVisibleCaches({
+  queryClient,
+  boardId,
+  taskId,
+  fallback,
+}: {
+  queryClient: QueryClient;
+  boardId: string;
+  taskId: string;
+  fallback?: Task;
+}): Task | undefined {
+  const taskDetail = queryClient.getQueryData<Task>(['task', taskId]);
+  if (taskDetail) return taskDetail;
+
+  const workspaceTaskEntries = queryClient.getQueriesData<WorkspaceTaskCache>({
+    predicate: (query) =>
+      isWorkspaceTaskQuery(query.queryKey, new Set([taskId])),
+  });
+  for (const [, entry] of workspaceTaskEntries) {
+    if (entry?.task) return entry.task;
+  }
+
+  const boardTaskEntries = queryClient.getQueriesData<Task[]>({
+    predicate: (query) => isBoardTaskQuery(query.queryKey, boardId),
+  });
+  for (const [, tasks] of boardTaskEntries) {
+    const task = tasks?.find((entry) => entry.id === taskId);
+    if (task) return task;
+  }
+
+  return fallback;
+}
+
+export function patchTasksInVisibleCaches({
+  queryClient,
+  boardId,
+  taskIds,
+  updater,
+}: {
+  queryClient: QueryClient;
+  boardId: string;
+  taskIds: string[];
+  updater: (task: Task) => Task;
+}) {
+  const taskIdSet = new Set(taskIds);
+  if (taskIdSet.size === 0) return;
+
+  queryClient.setQueriesData<Task[]>(
+    {
+      predicate: (query) => isBoardTaskQuery(query.queryKey, boardId),
+    },
+    (old) => patchTaskArray(old, taskIdSet, updater)
+  );
+
+  queryClient.setQueriesData<Task>(
+    {
+      predicate: (query) => isTaskDetailQuery(query.queryKey, taskIdSet),
+    },
+    (old) => (old ? updater(old) : old)
+  );
+
+  queryClient.setQueriesData<WorkspaceTaskCache>(
+    {
+      predicate: (query) => isWorkspaceTaskQuery(query.queryKey, taskIdSet),
+    },
+    (old) =>
+      old?.task
+        ? {
+            ...old,
+            task: updater(old.task),
+          }
+        : old
+  );
+
+  queryClient.setQueriesData<MyTasksCache>({ queryKey: ['my-tasks'] }, (old) =>
+    patchMyTasksCache(old, taskIdSet, updater)
+  );
+
+  queryClient.setQueriesData<MyCompletedTasksCache>(
+    { queryKey: ['my-completed-tasks'] },
+    (old) => patchMyCompletedTasksCache(old, taskIdSet, updater)
+  );
+}
+
+export function patchTaskInVisibleCaches({
+  queryClient,
+  boardId,
+  taskId,
+  updater,
+}: {
+  queryClient: QueryClient;
+  boardId: string;
+  taskId: string;
+  updater: (task: Task) => Task;
+}) {
+  patchTasksInVisibleCaches({
+    queryClient,
+    boardId,
+    taskIds: [taskId],
+    updater,
+  });
+}
+
+export function snapshotVisibleTaskCaches(
+  queryClient: QueryClient,
+  boardId: string,
+  taskIds: string[]
+): VisibleTaskCacheSnapshot {
+  const taskIdSet = new Set(taskIds);
+
+  return {
+    boardTaskEntries: queryClient.getQueriesData<Task[]>({
+      predicate: (query) => isBoardTaskQuery(query.queryKey, boardId),
+    }),
+    taskEntries: queryClient.getQueriesData<Task>({
+      predicate: (query) => isTaskDetailQuery(query.queryKey, taskIdSet),
+    }),
+    workspaceTaskEntries: queryClient.getQueriesData<WorkspaceTaskCache>({
+      predicate: (query) => isWorkspaceTaskQuery(query.queryKey, taskIdSet),
+    }),
+    myTasksEntries: queryClient.getQueriesData<MyTasksCache>({
+      queryKey: ['my-tasks'],
+    }),
+    myCompletedTaskEntries: queryClient.getQueriesData<MyCompletedTasksCache>({
+      queryKey: ['my-completed-tasks'],
+    }),
+  };
+}
+
+export function restoreVisibleTaskCaches(
+  queryClient: QueryClient,
+  snapshot: VisibleTaskCacheSnapshot
+) {
+  for (const [queryKey, data] of snapshot.boardTaskEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+
+  for (const [queryKey, data] of snapshot.taskEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+
+  for (const [queryKey, data] of snapshot.workspaceTaskEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+
+  for (const [queryKey, data] of snapshot.myTasksEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+
+  for (const [queryKey, data] of snapshot.myCompletedTaskEntries) {
+    queryClient.setQueryData(queryKey, data);
+  }
+}
+
+export function restoreTasksFromVisibleCacheSnapshot({
+  queryClient,
+  snapshot,
+  taskIds,
+}: {
+  queryClient: QueryClient;
+  snapshot: VisibleTaskCacheSnapshot;
+  taskIds: string[];
+}) {
+  const taskIdSet = new Set(taskIds);
+  if (taskIdSet.size === 0) return;
+
+  for (const [queryKey, previousTasks] of snapshot.boardTaskEntries) {
+    queryClient.setQueryData<Task[]>(queryKey, (currentTasks) =>
+      restoreTaskArrayFromSnapshot(currentTasks, previousTasks, taskIdSet)
+    );
+  }
+
+  for (const [queryKey, previousTask] of snapshot.taskEntries) {
+    if (!Array.isArray(queryKey) || typeof queryKey[1] !== 'string') continue;
+    if (!taskIdSet.has(queryKey[1])) continue;
+    queryClient.setQueryData(queryKey, previousTask);
+  }
+
+  for (const [queryKey, previousEntry] of snapshot.workspaceTaskEntries) {
+    if (!Array.isArray(queryKey) || typeof queryKey[2] !== 'string') continue;
+    if (!taskIdSet.has(queryKey[2])) continue;
+    queryClient.setQueryData(queryKey, previousEntry);
+  }
+
+  for (const [queryKey, previousEntry] of snapshot.myTasksEntries) {
+    queryClient.setQueryData<MyTasksCache>(queryKey, (currentEntry) =>
+      restoreMyTasksCacheFromSnapshot(currentEntry, previousEntry, taskIdSet)
+    );
+  }
+
+  for (const [queryKey, previousEntry] of snapshot.myCompletedTaskEntries) {
+    queryClient.setQueryData<MyCompletedTasksCache>(queryKey, (currentEntry) =>
+      restoreMyCompletedTasksCacheFromSnapshot(
+        currentEntry,
+        previousEntry,
+        taskIdSet
+      )
+    );
+  }
+}

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

@@ -189,6 +189,8 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
             taskWsId: state.taskWsId,
             taskWorkspacePersonal: state.taskWorkspacePersonal,
             taskWorkspaceTier: state.taskWorkspaceTier,
+            canUseBoardAssignees: state.canUseBoardAssignees,
+            assigneeMemberSource: state.assigneeMemberSource,
           });
           return;
         }
@@ -210,6 +212,8 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
             taskWsId: currentTaskWsId,
             taskWorkspacePersonal: state.taskWorkspacePersonal,
             taskWorkspaceTier: state.taskWorkspaceTier,
+            canUseBoardAssignees: state.canUseBoardAssignees,
+            assigneeMemberSource: state.assigneeMemberSource,
           });
           return;
         }
@@ -223,8 +227,10 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
       openTask,
       openTaskById,
       queryClient,
+      state.assigneeMemberSource,
       state.availableLists,
       state.boardId,
+      state.canUseBoardAssignees,
       state.task?.id,
       state.taskWorkspacePersonal,
       state.taskWorkspaceTier,
@@ -238,9 +244,17 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
       return openTaskById(taskId, {
         taskWsId: wsId,
         taskWorkspacePersonal: isPersonalWorkspace,
+        canUseBoardAssignees: state.canUseBoardAssignees,
+        assigneeMemberSource: state.assigneeMemberSource,
       });
     },
-    [isPersonalWorkspace, openTaskById, wsId]
+    [
+      isPersonalWorkspace,
+      openTaskById,
+      state.assigneeMemberSource,
+      state.canUseBoardAssignees,
+      wsId,
+    ]
   );
 
   useEffect(() => {
@@ -388,10 +402,14 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
       taskWsId: state.taskWsId,
       taskWorkspacePersonal: state.taskWorkspacePersonal,
       taskWorkspaceTier: state.taskWorkspaceTier,
+      canUseBoardAssignees: state.canUseBoardAssignees,
+      assigneeMemberSource: state.assigneeMemberSource,
       initialSharedContext: state.initialSharedContext,
     });
   }, [
     openTaskById,
+    state.assigneeMemberSource,
+    state.canUseBoardAssignees,
     state.initialSharedContext,
     state.availableLists,
     state.boardId,
@@ -539,6 +557,8 @@ export function TaskDialogManager({ wsId }: { wsId: string }) {
       taskLoadError={state.taskLoadError}
       taskHydrationVersion={state.taskHydrationVersion}
       isPersonalWorkspace={isPersonalWorkspace}
+      canUseBoardAssignees={state.canUseBoardAssignees}
+      assigneeMemberSource={state.assigneeMemberSource}
       parentTaskId={state.parentTaskId}
       parentTaskName={state.parentTaskName}
       pendingRelationship={state.pendingRelationship}

package/src/components/ui/tu-do/shared/task-edit-dialog/components/quick-settings-popover.tsx

@@ -28,6 +28,8 @@ function updateBodyFadeAttribute(enabled: boolean) {
 interface QuickSettingsPopoverProps {
   /** Whether the workspace is personal (forces auto-assign to true) */
   isPersonalWorkspace?: boolean;
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
 }
 
 /**
@@ -36,6 +38,8 @@ interface QuickSettingsPopoverProps {
  */
 export function QuickSettingsPopover({
   isPersonalWorkspace = false,
+  open,
+  onOpenChange,
 }: QuickSettingsPopoverProps) {
   const t = useTranslations('settings.tasks');
   const tCommon = useTranslations('common');
@@ -96,7 +100,7 @@ export function QuickSettingsPopover({
     : (settings?.task_auto_assign_to_self ?? false);
 
   return (
-    <Popover>
+    <Popover open={open} onOpenChange={onOpenChange}>
       <Tooltip>
         <TooltipTrigger asChild>
           <PopoverTrigger asChild>

package/src/components/ui/tu-do/shared/task-edit-dialog/components/task-description-editor.tsx

@@ -54,6 +54,7 @@ export interface TaskDescriptionEditorProps {
   onImageUpload?: (file: File) => Promise<string>;
   onEditorReady: (editor: Editor) => void;
   onConvertToTask?: () => void | Promise<void>;
+  onDescriptionSnapshotChange?: (description: JSONContent | null) => void;
   onDescriptionStorageLengthChange: (storageLength: number) => void;
   descriptionStorageLength: number;
   descriptionPercentLeft: number;
@@ -109,6 +110,7 @@ export function TaskDescriptionEditor({
   onImageUpload,
   onEditorReady,
   onConvertToTask,
+  onDescriptionSnapshotChange,
   onDescriptionStorageLengthChange,
   descriptionStorageLength,
   descriptionPercentLeft,
@@ -290,6 +292,7 @@ export function TaskDescriptionEditor({
           content={description}
           onChange={setDescription}
           onImmediateChange={(nextDescription) => {
+            onDescriptionSnapshotChange?.(nextDescription);
             if (allowYjsSync) {
               setDescription(nextDescription);
             }

package/src/components/ui/tu-do/shared/task-edit-dialog/components/task-dialog-header.tsx

@@ -16,7 +16,7 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '@tuturuuu/ui/tooltip';
 import { cn } from '@tuturuuu/utils/format';
 import { getTicketIdentifier } from '@tuturuuu/utils/task-helper';
 import { useTranslations } from 'next-intl';
-import type { ReactNode } from 'react';
+import { type ReactNode, useState } from 'react';
 import { TaskViewerAvatarsComponent } from '../../user-presence-avatars';
 import { TaskDialogActions } from '../task-dialog-actions';
 import type {
@@ -268,6 +268,19 @@ export function TaskDialogHeader({
   onScrollToUserCursor,
 }: TaskDialogHeaderProps) {
   const t = useTranslations();
+  const [activeHeaderOverlay, setActiveHeaderOverlay] = useState<
+    'quick-settings' | 'more-menu' | null
+  >(null);
+
+  const setHeaderOverlayOpen = (
+    overlay: 'quick-settings' | 'more-menu',
+    open: boolean
+  ) => {
+    setActiveHeaderOverlay((currentOverlay) => {
+      if (open) return overlay;
+      return currentOverlay === overlay ? null : currentOverlay;
+    });
+  };
 
   // Use custom headerInfo if provided, otherwise generate from task context
   const resolvedHeaderInfo =
@@ -452,7 +465,13 @@ export function TaskDialogHeader({
 
         {/* Quick Settings */}
         {!controlsDisabled && (
-          <QuickSettingsPopover isPersonalWorkspace={isPersonalWorkspace} />
+          <QuickSettingsPopover
+            isPersonalWorkspace={isPersonalWorkspace}
+            open={activeHeaderOverlay === 'quick-settings'}
+            onOpenChange={(open) =>
+              setHeaderOverlayOpen('quick-settings', open)
+            }
+          />
         )}
 
         <TaskDialogActions
@@ -471,6 +490,10 @@ export function TaskDialogHeader({
           onOpenShareDialog={onOpenShareDialog}
           disabled={disabled}
           controlsDisabled={controlsDisabled}
+          moreMenuOpen={activeHeaderOverlay === 'more-menu'}
+          onMoreMenuOpenChange={(open) =>
+            setHeaderOverlayOpen('more-menu', open)
+          }
         />
 
         {/* Hide save button in edit mode when realtime is enabled (either cursors or Yjs sync) */}

package/src/components/ui/tu-do/shared/task-edit-dialog/components/task-list-selector.tsx

@@ -21,6 +21,8 @@ interface TaskListSelectorProps {
   availableLists: TaskList[];
   disabled?: boolean;
   compact?: boolean;
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
   onListChange: (listId: string) => void;
 }
 
@@ -31,11 +33,15 @@ export function TaskListSelector({
   availableLists,
   disabled = false,
   compact = false,
+  open,
+  onOpenChange,
   onListChange,
 }: TaskListSelectorProps) {
   const t = useTranslations();
-  const [isPopoverOpen, setIsPopoverOpen] = useState(false);
+  const [uncontrolledPopoverOpen, setUncontrolledPopoverOpen] = useState(false);
   const [isCreateListDialogOpen, setIsCreateListDialogOpen] = useState(false);
+  const isPopoverOpen = open ?? uncontrolledPopoverOpen;
+  const setIsPopoverOpen = onOpenChange ?? setUncontrolledPopoverOpen;
 
   const statusLabels = useMemo(
     () => ({

package/src/components/ui/tu-do/shared/task-edit-dialog/description-versions.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildRecoverableTaskDescriptionVersions,
+  extractRecoverableTaskDescriptionValue,
+} from './description-versions';
+
+const makeDoc = (text: string) =>
+  JSON.stringify({
+    type: 'doc',
+    content: [
+      {
+        type: 'paragraph',
+        content: [{ type: 'text', text }],
+      },
+    ],
+  });
+
+describe('task description tracked versions', () => {
+  it('does not treat null, empty docs, or legacy placeholders as recoverable', () => {
+    expect(extractRecoverableTaskDescriptionValue(null)).toBeNull();
+    expect(extractRecoverableTaskDescriptionValue('')).toBeNull();
+    expect(extractRecoverableTaskDescriptionValue('has_content')).toBeNull();
+    expect(
+      extractRecoverableTaskDescriptionValue(
+        JSON.stringify({
+          type: 'doc',
+          content: [{ type: 'paragraph' }],
+        })
+      )
+    ).toBeNull();
+  });
+
+  it('normalizes plain text and serialized TipTap content', () => {
+    const plain = extractRecoverableTaskDescriptionValue('Plain description');
+    const serialized = extractRecoverableTaskDescriptionValue(
+      makeDoc('Serialized description')
+    );
+
+    expect(plain?.description).toContain('Plain description');
+    expect(plain?.previewText).toBe('Plain description');
+    expect(serialized?.description).toContain('Serialized description');
+    expect(serialized?.previewText).toBe('Serialized description');
+  });
+
+  it('prefers the previous value from the latest wipe entry', () => {
+    const versions = buildRecoverableTaskDescriptionVersions([
+      {
+        id: 'older',
+        changed_at: '2026-06-25T10:00:00.000Z',
+        change_type: 'field_updated',
+        field_name: 'description',
+        old_value: makeDoc('Older version'),
+        new_value: makeDoc('Intermediate version'),
+      },
+      {
+        id: 'wipe',
+        changed_at: '2026-06-26T10:00:00.000Z',
+        change_type: 'field_updated',
+        field_name: 'description',
+        old_value: makeDoc('Latest real version'),
+        new_value: null,
+      },
+    ]);
+
+    expect(versions[0]?.historyId).toBe('wipe');
+    expect(versions[0]?.source).toBe('old_value');
+    expect(versions[0]?.reason).toBe('before_clear');
+    expect(versions[0]?.previewText).toBe('Latest real version');
+  });
+
+  it('dedupes identical canonical descriptions while keeping newest first', () => {
+    const duplicated = makeDoc('Same description');
+    const versions = buildRecoverableTaskDescriptionVersions([
+      {
+        id: 'newer',
+        changed_at: '2026-06-26T10:00:00.000Z',
+        change_type: 'field_updated',
+        field_name: 'description',
+        old_value: makeDoc('Different description'),
+        new_value: duplicated,
+      },
+      {
+        id: 'older',
+        changed_at: '2026-06-25T10:00:00.000Z',
+        change_type: 'field_updated',
+        field_name: 'description',
+        old_value: duplicated,
+        new_value: duplicated,
+      },
+    ]);
+
+    expect(versions.map((version) => version.previewText)).toEqual([
+      'Same description',
+      'Different description',
+    ]);
+  });
+});