@tuturuuu/ui 0.0.4 → 0.2.0

package/src/components/ui/text-editor/__tests__/task-mention-chip.test.tsx

@@ -0,0 +1,476 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { TaskMentionChip } from '../task-mention-chip';
+
+const mocks = vi.hoisted(() => ({
+  getCurrentUserTask: vi.fn(),
+  listWorkspaceTasks: vi.fn(),
+  toastError: vi.fn(),
+  toastSuccess: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/internal-api', () => ({
+  cleanupWorkspaceTaskMentions: vi.fn(),
+  listWorkspaceTaskLists: vi.fn(),
+  listWorkspaceTaskProjects: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/internal-api/tasks', () => ({
+  getCurrentUserTask: mocks.getCurrentUserTask,
+  listWorkspaceTasks: mocks.listWorkspaceTasks,
+}));
+
+vi.mock('@tuturuuu/ui/hooks/use-workspace-members', () => ({
+  useWorkspaceMembers: () => ({ data: [], isLoading: false }),
+}));
+
+vi.mock('@tuturuuu/utils/task-helper', () => ({
+  useBoardConfig: () => ({ data: undefined }),
+  useWorkspaceLabels: () => ({ data: [], isLoading: false }),
+}));
+
+vi.mock('../../../../hooks/use-dom-resolved-theme', () => ({
+  useDomResolvedTheme: () => 'light',
+}));
+
+vi.mock('../../../../hooks/use-task-actions', () => ({
+  useTaskActions: () => ({
+    handleMoveToCompletion: vi.fn(),
+    handleMoveToClose: vi.fn(),
+    handleDelete: vi.fn(),
+    handleMoveToList: vi.fn(),
+    handleDueDateChange: vi.fn(),
+    handlePriorityChange: vi.fn(),
+    updateEstimationPoints: vi.fn(),
+    handleCustomDateChange: vi.fn(),
+    handleToggleAssignee: vi.fn(),
+  }),
+}));
+
+vi.mock('../../tu-do/hooks/useTaskCardRelationships', () => ({
+  useTaskCardRelationships: () => ({
+    parentTask: null,
+    childTasks: [],
+    blocking: [],
+    blockedBy: [],
+    relatedTasks: [],
+    setParentTask: vi.fn(),
+    removeParentTask: vi.fn(),
+    addBlockingTask: vi.fn(),
+    removeBlockingTask: vi.fn(),
+    addBlockedByTask: vi.fn(),
+    removeBlockedByTask: vi.fn(),
+    addRelatedTask: vi.fn(),
+    removeRelatedTask: vi.fn(),
+    isSaving: false,
+    savingTaskId: null,
+  }),
+}));
+
+vi.mock('../../tu-do/hooks/useTaskLabelManagement', () => ({
+  useTaskLabelManagement: () => ({
+    toggleTaskLabel: vi.fn(),
+    createNewLabel: vi.fn(),
+    newLabelName: '',
+    setNewLabelName: vi.fn(),
+    newLabelColor: 'BLUE',
+    setNewLabelColor: vi.fn(),
+    creatingLabel: false,
+  }),
+}));
+
+vi.mock('../../tu-do/hooks/useTaskProjectManagement', () => ({
+  useTaskProjectManagement: () => ({
+    toggleTaskProject: vi.fn(),
+    newProjectName: '',
+    setNewProjectName: vi.fn(),
+    creatingProject: false,
+    createNewProject: vi.fn(),
+  }),
+}));
+
+vi.mock('../../sonner', () => ({
+  toast: {
+    error: mocks.toastError,
+    success: mocks.toastSuccess,
+  },
+}));
+
+function createTestQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+}
+
+function renderWithQueryClient(
+  children: ReactNode,
+  queryClient = createTestQueryClient()
+) {
+  return render(
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+}
+
+describe('TaskMentionChip', () => {
+  beforeEach(() => {
+    mocks.getCurrentUserTask.mockRejectedValue(new Error('Task not found'));
+    mocks.listWorkspaceTasks.mockResolvedValue({ tasks: [] });
+    window.history.pushState({}, '', '/ws-1/tasks/boards/board-1');
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('lets unresolved task mention clicks reach the editor instead of trapping them', async () => {
+    const editorClick = vi.fn();
+
+    renderWithQueryClient(
+      <div onClick={editorClick}>
+        <TaskMentionChip entityId="missing-task-id" displayNumber="3" />
+      </div>
+    );
+
+    await waitFor(() => {
+      expect(mocks.getCurrentUserTask).toHaveBeenCalledWith('missing-task-id');
+    });
+
+    const chip = screen.getByText('#3').closest('[data-mention="true"]');
+    expect(chip).not.toBeNull();
+
+    const clickAllowed = fireEvent.click(chip!);
+
+    expect(clickAllowed).toBe(true);
+    expect(editorClick).toHaveBeenCalledTimes(1);
+    expect(mocks.toastError).not.toHaveBeenCalled();
+  });
+
+  it('repairs stale mention IDs by resolving the visible task identifier in the current board', async () => {
+    const resolvedTask = {
+      assignees: [],
+      board_id: 'board-1',
+      display_number: 3,
+      id: 'live-task-id',
+      labels: [],
+      list_id: 'list-1',
+      name: 'Complete Team Charter V1.0',
+      projects: [],
+      ticket_prefix: null,
+    };
+    const onResolvedTaskMention = vi.fn();
+
+    mocks.getCurrentUserTask.mockImplementation(async (taskId: string) => {
+      if (taskId === 'stale-task-id') {
+        throw new Error('Task not found');
+      }
+
+      return {
+        availableLists: [],
+        task: resolvedTask,
+        taskWorkspacePersonal: false,
+        taskWorkspaceTier: 'FREE',
+        taskWsId: 'ws-1',
+      };
+    });
+    mocks.listWorkspaceTasks.mockResolvedValue({ tasks: [resolvedTask] });
+
+    renderWithQueryClient(
+      <TaskMentionChip
+        entityId="stale-task-id"
+        displayNumber="3"
+        subtitle="Complete Team Charter V1.0"
+        onResolvedTaskMention={onResolvedTaskMention}
+      />
+    );
+
+    await waitFor(() => {
+      expect(mocks.listWorkspaceTasks).toHaveBeenCalledWith(
+        'ws-1',
+        expect.objectContaining({
+          boardId: 'board-1',
+          identifier: '3',
+        })
+      );
+    });
+
+    await waitFor(() => {
+      expect(onResolvedTaskMention).toHaveBeenCalledWith(
+        expect.objectContaining({
+          displayName: '3',
+          entityId: 'live-task-id',
+          subtitle: 'Complete Team Charter V1.0',
+        })
+      );
+    });
+
+    expect(
+      screen
+        .getByText('#3')
+        .closest('[data-mention="true"]')
+        ?.getAttribute('data-entity-id')
+    ).toBe('live-task-id');
+    expect(screen.getByText('Complete Team Charter V1.0')).toBeInTheDocument();
+  });
+
+  it('does not reuse stale mention fallback cache across board contexts', async () => {
+    const boardOneTask = {
+      assignees: [],
+      board_id: 'board-1',
+      display_number: 3,
+      id: 'board-one-task-id',
+      labels: [],
+      list_id: 'list-1',
+      name: 'Board one task',
+      projects: [],
+      ticket_prefix: null,
+    };
+    const boardTwoTask = {
+      assignees: [],
+      board_id: 'board-2',
+      display_number: 4,
+      id: 'board-two-task-id',
+      labels: [],
+      list_id: 'list-2',
+      name: 'Board two task',
+      projects: [],
+      ticket_prefix: null,
+    };
+    const queryClient = createTestQueryClient();
+    const firstResolved = vi.fn();
+    const secondResolved = vi.fn();
+
+    mocks.getCurrentUserTask.mockImplementation(async (taskId: string) => {
+      if (taskId === 'stale-task-id') {
+        throw new Error('Task not found');
+      }
+
+      const task =
+        taskId === boardOneTask.id
+          ? boardOneTask
+          : taskId === boardTwoTask.id
+            ? boardTwoTask
+            : null;
+
+      if (!task) {
+        throw new Error('Task not found');
+      }
+
+      return {
+        availableLists: [],
+        task,
+        taskWorkspacePersonal: false,
+        taskWorkspaceTier: 'FREE',
+        taskWsId: 'ws-1',
+      };
+    });
+    mocks.listWorkspaceTasks.mockImplementation(
+      async (_wsId: string, params: { boardId?: string }) => ({
+        tasks: params.boardId === 'board-2' ? [boardTwoTask] : [boardOneTask],
+      })
+    );
+
+    const firstRender = renderWithQueryClient(
+      <TaskMentionChip
+        entityId="stale-task-id"
+        displayNumber="3"
+        subtitle="Board one task"
+        onResolvedTaskMention={firstResolved}
+      />,
+      queryClient
+    );
+
+    await waitFor(() => {
+      expect(firstResolved).toHaveBeenCalledWith(
+        expect.objectContaining({ entityId: boardOneTask.id })
+      );
+    });
+
+    firstRender.unmount();
+    window.history.pushState({}, '', '/ws-1/tasks/boards/board-2');
+
+    renderWithQueryClient(
+      <TaskMentionChip
+        entityId="stale-task-id"
+        displayNumber="4"
+        subtitle="Board two task"
+        onResolvedTaskMention={secondResolved}
+      />,
+      queryClient
+    );
+
+    await waitFor(() => {
+      expect(mocks.listWorkspaceTasks).toHaveBeenCalledWith(
+        'ws-1',
+        expect.objectContaining({
+          boardId: 'board-2',
+          identifier: '4',
+        })
+      );
+    });
+    await waitFor(() => {
+      expect(secondResolved).toHaveBeenCalledWith(
+        expect.objectContaining({ entityId: boardTwoTask.id })
+      );
+    });
+    expect(secondResolved).not.toHaveBeenCalledWith(
+      expect.objectContaining({ entityId: boardOneTask.id })
+    );
+  });
+
+  it('ignores untrusted mention workspace when repairing stale task mentions', async () => {
+    const resolvedTask = {
+      assignees: [],
+      board_id: 'board-1',
+      display_number: 7,
+      id: 'source-task-id',
+      labels: [],
+      list_id: 'list-1',
+      name: 'Cross workspace task',
+      projects: [],
+      ticket_prefix: null,
+    };
+    const onResolvedTaskMention = vi.fn();
+
+    window.history.pushState({}, '', '/route-ws/tasks/boards/board-1');
+    mocks.getCurrentUserTask.mockImplementation(async (taskId: string) => {
+      if (taskId === 'stale-task-id') {
+        throw new Error('Task not found');
+      }
+
+      return {
+        availableLists: [],
+        task: resolvedTask,
+        taskWorkspacePersonal: false,
+        taskWorkspaceTier: 'FREE',
+        taskWsId: 'route-ws',
+      };
+    });
+    mocks.listWorkspaceTasks.mockResolvedValue({ tasks: [resolvedTask] });
+
+    renderWithQueryClient(
+      <TaskMentionChip
+        entityId="stale-task-id"
+        displayNumber="7"
+        subtitle="Cross workspace task"
+        workspaceId="source-ws"
+        onResolvedTaskMention={onResolvedTaskMention}
+      />
+    );
+
+    await waitFor(() => {
+      expect(mocks.listWorkspaceTasks).toHaveBeenCalledWith(
+        'route-ws',
+        expect.objectContaining({
+          boardId: 'board-1',
+          identifier: '7',
+        })
+      );
+    });
+
+    await waitFor(() => {
+      expect(onResolvedTaskMention).toHaveBeenCalledWith(
+        expect.objectContaining({
+          entityId: 'source-task-id',
+          workspaceId: 'route-ws',
+        })
+      );
+    });
+  });
+
+  it('does not rewrite stale mentions to tasks from another workspace', async () => {
+    const resolvedTask = {
+      assignees: [],
+      board_id: 'board-1',
+      display_number: 8,
+      id: 'source-task-id',
+      labels: [],
+      list_id: 'list-1',
+      name: 'Source workspace task',
+      projects: [],
+      ticket_prefix: null,
+    };
+    const onResolvedTaskMention = vi.fn();
+
+    window.history.pushState({}, '', '/route-ws/tasks/boards/board-1');
+    mocks.getCurrentUserTask.mockImplementation(async (taskId: string) => {
+      if (taskId === 'stale-task-id') {
+        throw new Error('Task not found');
+      }
+
+      return {
+        availableLists: [],
+        task: resolvedTask,
+        taskWorkspacePersonal: false,
+        taskWorkspaceTier: 'FREE',
+        taskWsId: 'source-ws',
+      };
+    });
+    mocks.listWorkspaceTasks.mockResolvedValue({ tasks: [resolvedTask] });
+
+    renderWithQueryClient(
+      <TaskMentionChip
+        entityId="stale-task-id"
+        displayNumber="8"
+        subtitle="Source workspace task"
+        onResolvedTaskMention={onResolvedTaskMention}
+      />
+    );
+
+    await waitFor(() => {
+      expect(mocks.getCurrentUserTask).toHaveBeenCalledWith('source-task-id');
+    });
+
+    expect(onResolvedTaskMention).not.toHaveBeenCalled();
+  });
+
+  it('uses the server-returned workspace for resolved cross-workspace task mentions', async () => {
+    const resolvedTask = {
+      assignees: [],
+      board_id: 'source-board',
+      display_number: 9,
+      id: 'source-task-id',
+      labels: [],
+      list_id: 'list-1',
+      name: 'Trusted cross workspace task',
+      projects: [],
+      ticket_prefix: null,
+    };
+
+    window.history.pushState({}, '', '/route-ws/tasks/boards/board-1');
+    mocks.getCurrentUserTask.mockResolvedValue({
+      availableLists: [],
+      task: resolvedTask,
+      taskWorkspacePersonal: false,
+      taskWorkspaceTier: 'FREE',
+      taskWsId: 'source-ws',
+    });
+
+    renderWithQueryClient(
+      <TaskMentionChip
+        entityId="source-task-id"
+        displayNumber="9"
+        subtitle="Trusted cross workspace task"
+        workspaceId="source-ws"
+      />
+    );
+
+    await waitFor(() => {
+      expect(mocks.getCurrentUserTask).toHaveBeenCalledWith('source-task-id');
+    });
+
+    expect(mocks.listWorkspaceTasks).not.toHaveBeenCalled();
+    expect(
+      screen.getByText('Trusted cross workspace task')
+    ).toBeInTheDocument();
+  });
+});

package/src/components/ui/text-editor/__tests__/text-replacements.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+import {
+  getNormalizedCursorPosition,
+  normalizeLiveTextReplacements,
+  normalizeTextReplacements,
+} from '../text-replacements';
+
+describe('text replacements', () => {
+  it('normalizes common ASCII shortcuts', () => {
+    expect(
+      normalizeTextReplacements(
+        'a -> b <- c <-> d --> e ---> f <-- g <--- h <--> i <---> j >= k <= l != m +- n ... (tm) (c) (r) --'
+      )
+    ).toBe('a → b ← c ↔ d ⟶ e ⟶ f ⟵ g ⟵ h ⟷ i ⟷ j ≥ k ≤ l ≠ m ± n … ™ © ® –');
+  });
+
+  it('keeps ambiguous trailing prefixes raw while typing', () => {
+    expect(normalizeLiveTextReplacements('<-')).toBe('<-');
+    expect(normalizeLiveTextReplacements('<--')).toBe('<--');
+    expect(normalizeLiveTextReplacements('--')).toBe('--');
+  });
+
+  it('converts longer arrow forms once they become unambiguous', () => {
+    expect(normalizeLiveTextReplacements('<->')).toBe('↔');
+    expect(normalizeLiveTextReplacements('-->')).toBe('⟶');
+    expect(normalizeLiveTextReplacements('--->')).toBe('⟶');
+    expect(normalizeLiveTextReplacements('<-->')).toBe('⟷');
+    expect(normalizeLiveTextReplacements('<--->')).toBe('⟷');
+  });
+
+  it('calculates cursor position after normalization', () => {
+    expect(getNormalizedCursorPosition('abc -> def', 6)).toBe(5);
+    expect(getNormalizedCursorPosition('hello...', 8)).toBe(6);
+    expect(getNormalizedCursorPosition('foo (tm)', 8)).toBe(5);
+    expect(
+      getNormalizedCursorPosition('<-> hello', 3, normalizeLiveTextReplacements)
+    ).toBe(1);
+  });
+});