@exegia/corpora-ui 2.0.0 → 3.1.0

package/src/components/composed/chat/__tests__/composer-attachments.test.tsx

@@ -1,101 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { act, fireEvent, render, screen } from "@testing-library/react"
-import { Provider } from "jotai"
-import userEvent from "@testing-library/user-event"
-
-import { Composer, type TComposerAttachment } from "../composer"
-
-const SEED: TComposerAttachment[] = [
-  { id: "a", kind: "document", title: "Q3.pdf", meta: "PDF" },
-  { id: "b", kind: "image", title: "IMG.jpg" },
-]
-
-describe("Composer attachments", () => {
-  test("renders the tray, removes a chip and sends with ⌘↵", async () => {
-    const onSubmit = mock(() => {})
-    render(
-      <Provider>
-        <Composer
-          attachments={SEED}
-          defaultValue="hello"
-          onSubmit={onSubmit}
-          safetyNote={null}
-        />
-      </Provider>
-    )
-    // The tray seeds from a passive effect; flush the re-render it schedules.
-    await act(async () => {})
-    expect(screen.getAllByRole("button", { name: "Remove" }).length).toBe(2)
-    fireEvent.click(screen.getAllByRole("button", { name: "Remove" })[0])
-    expect(screen.queryByText("Q3.pdf")).toBeNull()
-
-    fireEvent.keyDown(screen.getByRole("textbox", { name: "Message" }), {
-      key: "Enter",
-      metaKey: true,
-    })
-    expect(onSubmit).toHaveBeenCalledTimes(1)
-    const [draft, , attachments] = onSubmit.mock.calls[0] as unknown as [
-      string,
-      string,
-      TComposerAttachment[],
-    ]
-    expect(draft).toBe("hello")
-    expect(attachments.map((a) => a.id)).toEqual(["b"])
-  })
-
-  test("empty tray renders no tray row", () => {
-    const { container } = render(
-      <Provider>
-        <Composer safetyNote={null} />
-      </Provider>
-    )
-    expect(container.querySelector('[data-slot="composer-tray"]')).toBeNull()
-  })
-
-  test("selects local files and submits an attachment-only message once", async () => {
-    const user = userEvent.setup()
-    const onSubmit = mock(() => {})
-    const onFilesChange = mock(() => {})
-    render(
-      <Provider>
-        <Composer onSubmit={onSubmit} onFilesChange={onFilesChange} />
-      </Provider>
-    )
-    const file = new File(["passage"], "passage.txt", { type: "text/plain" })
-    await user.upload(screen.getByLabelText("Attach files"), file)
-    expect(onFilesChange).toHaveBeenCalledWith([file])
-    expect(screen.getByText("passage.txt")).toBeDefined()
-    await user.click(screen.getByRole("button", { name: "Send message" }))
-    expect(onSubmit).toHaveBeenCalledWith("", "answer", [
-      expect.objectContaining({ file, title: "passage.txt" }),
-    ])
-    expect(screen.queryByText("passage.txt")).toBeNull()
-    expect(
-      screen
-        .getByRole("button", { name: "Send message" })
-        .hasAttribute("disabled")
-    ).toBe(true)
-  })
-
-  test("preserves image, video and audio file types when sending", async () => {
-    const user = userEvent.setup()
-    const onSubmit = mock(() => {})
-    render(
-      <Provider>
-        <Composer onSubmit={onSubmit} />
-      </Provider>
-    )
-    const files = [
-      new File(["image"], "scan.JPG"),
-      new File(["video"], "lecture.mp4", { type: "video/mp4" }),
-      new File(["audio"], "reading.m4a", { type: "audio/mp4" }),
-    ]
-    await user.upload(screen.getByLabelText("Attach files"), files)
-    await user.click(screen.getByRole("button", { name: "Send message" }))
-    expect(onSubmit).toHaveBeenCalledWith("", "answer", [
-      expect.objectContaining({ kind: "image", file: files[0] }),
-      expect.objectContaining({ kind: "media", audio: false, file: files[1] }),
-      expect.objectContaining({ kind: "media", audio: true, file: files[2] }),
-    ])
-  })
-})

package/src/components/composed/chat/__tests__/composer.test.tsx

@@ -1,248 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { act, fireEvent, render, screen } from "@testing-library/react"
-import userEvent from "@testing-library/user-event"
-import { Provider } from "jotai"
-
-import {
-  CommandMenu,
-  Composer,
-  SuggestedPrompts,
-  type IComposerSuggestionsProps,
-} from "../composer"
-import { SuggestedPrompt } from "@/components/composed/ai/suggested-prompt"
-
-describe("Composer", () => {
-  test("shows the prompt bar controls at rest and preserves keyboard sending", async () => {
-    const user = userEvent.setup()
-    const onSubmit = mock(() => {})
-    render(
-      <Provider>
-        <Composer
-          ComposerMenu={() => <CommandMenu items={[]} />}
-          onSubmit={onSubmit}
-          safetyNote={null}
-        />
-      </Provider>
-    )
-
-    expect(screen.queryByText("to send message")).toBeNull()
-    expect(
-      screen
-        .getByRole("button", { name: "Send message" })
-        .hasAttribute("disabled")
-    ).toBe(true)
-    expect(screen.getByRole("combobox", { name: "Choose model" })).toBeDefined()
-
-    const field = screen.getByRole("textbox", { name: "Message" })
-    await user.click(field)
-    expect(
-      await screen.findByRole("button", { name: "Send message" })
-    ).toBeDefined()
-    expect(screen.getByRole("button", { name: "Add attachment" })).toBeDefined()
-
-    await user.type(field, "Validate ¶12")
-    await user.keyboard("{Meta>}{Enter}{/Meta}")
-    expect(onSubmit).toHaveBeenCalledWith("Validate ¶12", "answer", [])
-  })
-
-  test("folds the suggested prompts behind the disclosure and routes a pick", async () => {
-    const user = userEvent.setup()
-    const onSelect = mock(() => {})
-    const Suggestions = (props: IComposerSuggestionsProps) => (
-      <SuggestedPrompts onOpenChange={props.onOpenChange} open={props.open}>
-        <SuggestedPrompt onSelect={onSelect}>Check ¶12</SuggestedPrompt>
-      </SuggestedPrompts>
-    )
-    render(
-      <Provider>
-        <Composer safetyNote={null} Suggestions={Suggestions} />
-      </Provider>
-    )
-
-    const trigger = screen.getByRole("button", { name: /Suggestions \(1\)/ })
-    expect(trigger.getAttribute("aria-expanded")).toBe("true")
-
-    await user.click(await screen.findByRole("button", { name: /Check ¶12/ }))
-    expect(onSelect).toHaveBeenCalledTimes(1)
-
-    // Only the disclosure state is asserted: the panel leaves through an
-    // AnimatePresence exit, and happy-dom's stubbed `Element.animate` never
-    // finishes it, so the row stays mounted here but not in a browser.
-    await user.click(trigger)
-    expect(trigger.getAttribute("aria-expanded")).toBe("false")
-  })
-
-  test("shows Stop while streaming and routes it to onStop", async () => {
-    const user = userEvent.setup()
-    const onStop = mock(() => {})
-    render(
-      <Provider>
-        <Composer expanded isStreaming onStop={onStop} safetyNote={null} />
-      </Provider>
-    )
-    await user.click(screen.getByRole("button", { name: "Stop" }))
-    expect(onStop).toHaveBeenCalledTimes(1)
-  })
-
-  test("filters commands and sources and inserts a keyboard selection without sending", async () => {
-    const user = userEvent.setup()
-    const onSubmit = mock(() => {})
-    const onCommand = mock(() => {})
-    const onSourceSelect = mock(() => {})
-    const command = {
-      id: "validate",
-      label: "/validate",
-      insertText: "/validate ",
-    }
-    const source = { id: "corpus", label: "Corpus", insertText: "@corpus " }
-    render(
-      <Provider>
-        <Composer
-          commands={[command, { id: "compare", label: "/compare" }]}
-          sources={[source]}
-          onSubmit={onSubmit}
-          onCommand={onCommand}
-          onSourceSelect={onSourceSelect}
-        />
-      </Provider>
-    )
-    const field = screen.getByRole("textbox", {
-      name: "Message",
-    }) as HTMLTextAreaElement
-    await user.type(field, "/val")
-    expect(
-      await screen.findByRole("option", { name: "/validate" })
-    ).toBeDefined()
-    expect(screen.queryByRole("option", { name: "/compare" })).toBeNull()
-    await user.keyboard("{Tab}")
-    expect(field.value).toBe("/validate ")
-    expect(onCommand).toHaveBeenCalledWith(command)
-    await user.type(field, "@cor")
-    await user.keyboard("{Enter}")
-    expect(field.value).toBe("/validate @corpus ")
-    expect(onSourceSelect).toHaveBeenCalledWith(source)
-    expect(onSubmit).not.toHaveBeenCalled()
-  })
-
-  test("changes the selected model through the picker", async () => {
-    const user = userEvent.setup()
-    const onModelChange = mock(() => {})
-    render(
-      <Provider>
-        <Composer
-          models={[
-            { id: "auto", label: "Auto" },
-            { id: "reasoning", label: "Reasoning" },
-          ]}
-          onModelChange={onModelChange}
-        />
-      </Provider>
-    )
-    await user.click(screen.getByRole("combobox", { name: "Choose model" }))
-    await user.click(await screen.findByRole("option", { name: "Reasoning" }))
-    expect(onModelChange).toHaveBeenCalledWith("reasoning")
-    expect(
-      screen.getByRole("combobox", { name: "Choose model" }).textContent
-    ).toContain("Reasoning")
-  })
-
-  test("keeps Shift+Enter and IME input from submitting and leaves controlled text to the parent", () => {
-    const onSubmit = mock(() => {})
-    const onValueChange = mock(() => {})
-    render(
-      <Provider>
-        <Composer
-          value="Controlled draft"
-          onSubmit={onSubmit}
-          onValueChange={onValueChange}
-        />
-      </Provider>
-    )
-    const field = screen.getByRole("textbox", {
-      name: "Message",
-    }) as HTMLTextAreaElement
-    fireEvent.keyDown(field, { key: "Enter", shiftKey: true })
-    fireEvent.keyDown(field, { key: "Enter", isComposing: true })
-    expect(onSubmit).not.toHaveBeenCalled()
-    fireEvent.keyDown(field, { key: "Enter" })
-    expect(onSubmit).toHaveBeenCalledWith("Controlled draft", "answer", [])
-    expect(field.value).toBe("Controlled draft")
-  })
-
-  test("dictation appends final results and is cancelled on send", async () => {
-    const original = Object.getOwnPropertyDescriptor(
-      window,
-      "SpeechRecognition"
-    )
-    const recognizers: MockRecognition[] = []
-    class MockRecognition {
-      continuous = false
-      interimResults = false
-      lang = ""
-      onresult:
-        | ((event: {
-            resultIndex: number
-            results: { isFinal: boolean; 0: { transcript: string } }[]
-          }) => void)
-        | null = null
-      onerror: ((event: { error: string }) => void) | null = null
-      onend: (() => void) | null = null
-      start = mock(() => {})
-      stop = mock(() => {})
-      abort = mock(() => {})
-      constructor() {
-        recognizers.push(this)
-      }
-    }
-    Object.defineProperty(window, "SpeechRecognition", {
-      configurable: true,
-      value: MockRecognition,
-    })
-    const onSubmit = mock(() => {})
-    const view = render(
-      <Provider>
-        <Composer defaultValue="Please" onSubmit={onSubmit} />
-      </Provider>
-    )
-    try {
-      fireEvent.click(screen.getByRole("button", { name: "Start dictation" }))
-      const recognizer = recognizers[0]
-      expect(recognizer!.start).toHaveBeenCalledTimes(1)
-      await act(async () => {
-        recognizer!.onresult?.({
-          resultIndex: 0,
-          results: [
-            { isFinal: false, 0: { transcript: "ignore" } },
-            { isFinal: true, 0: { transcript: "validate this" } },
-          ],
-        })
-      })
-      expect(
-        (
-          screen.getByRole("textbox", {
-            name: "Message",
-          }) as HTMLTextAreaElement
-        ).value
-      ).toBe("Please validate this")
-      fireEvent.click(screen.getByRole("button", { name: "Send message" }))
-      expect(onSubmit).toHaveBeenCalledWith(
-        "Please validate this",
-        "answer",
-        []
-      )
-      expect(recognizer!.abort).toHaveBeenCalledTimes(1)
-      expect(recognizer!.onresult).toBeNull()
-      expect(
-        (
-          screen.getByRole("textbox", {
-            name: "Message",
-          }) as HTMLTextAreaElement
-        ).value
-      ).toBe("")
-    } finally {
-      view.unmount()
-      if (original) Object.defineProperty(window, "SpeechRecognition", original)
-      else Reflect.deleteProperty(window, "SpeechRecognition")
-    }
-  })
-})

package/src/components/composed/chat/__tests__/flowchart.test.tsx

@@ -1,145 +0,0 @@
-import { afterEach, describe, expect, it, mock } from "bun:test"
-import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react"
-
-import { Flowchart, type TStepNode } from "../flowchart"
-
-const STEPS: TStepNode[] = [
-  { id: "a", row: 0, x: 0.5, w: 200, title: "A" },
-  { id: "b", row: 1, x: 0.5, w: 200, title: "B" },
-]
-
-afterEach(cleanup)
-
-describe("Flowchart", () => {
-  it("lays out the default steps and draws a connector", () => {
-    const { container } = render(<Flowchart.Root />)
-    expect(screen.getByText("Iliad corpus loaded")).toBeTruthy()
-    expect(screen.getByText("Text node")).toBeTruthy()
-    const path = container.querySelector("path[data-edge]")!
-    expect(path.getAttribute("d")).toMatch(/^M \d/)
-    const canvas = container.querySelector('[data-slot="flowchart"]') as HTMLElement
-    expect(parseFloat(canvas.style.minHeight)).toBeGreaterThan(0)
-  })
-
-  it("lights the connector when a step is selected", () => {
-    const { container } = render(<Flowchart.Root />)
-    const step = screen.getByRole("button", { name: /Iliad corpus loaded/ })
-    fireEvent.click(step)
-    expect(step.getAttribute("aria-pressed")).toBe("true")
-    expect(container.querySelector("path[data-edge]")!.getAttribute("stroke")).toContain("accent")
-  })
-
-  it("does not capture a stationary press away from the selection button", () => {
-    const { container } = render(<Flowchart.Root steps={STEPS} />)
-    const wrapper = container.querySelector('[data-node="a"]') as HTMLElement
-    const capture = mock(() => {})
-    wrapper.setPointerCapture = capture
-    const button = screen.getByRole("button", { name: "A" })
-    fireEvent.pointerDown(button, { button: 0, pointerId: 1, clientX: 20, clientY: 20 })
-    expect(capture).not.toHaveBeenCalled()
-    fireEvent.pointerUp(button, { pointerId: 1 })
-    fireEvent.click(button)
-    expect(button.getAttribute("aria-pressed")).toBe("true")
-  })
-
-  it("renders custom children and chains edges by default", () => {
-    const { container } = render(<Flowchart.Root steps={[{ ...STEPS[0], children: <em>custom</em> }, STEPS[1]]} />)
-    expect(screen.getByText("custom").tagName).toBe("EM")
-    expect(container.querySelector('path[data-edge="a->b"]')).toBeTruthy()
-  })
-
-  it("offers add child, duplicate and delete from the context menu, confirming orphans", async () => {
-    const onAdd = mock(() => {})
-    const onRemove = mock(() => {})
-    const onDuplicate = mock(() => {})
-    render(<Flowchart.Root steps={STEPS} onAdd={onAdd} onRemove={onRemove} onDuplicate={onDuplicate} />)
-    expect(screen.queryByRole("button", { name: /Add node/ })).toBeNull()
-    fireEvent.contextMenu(screen.getByRole("button", { name: "A" }))
-    fireEvent.click(await screen.findByRole("menuitem", { name: "Add child" }))
-    expect(onAdd).toHaveBeenCalledWith("a", "bottom")
-    fireEvent.contextMenu(screen.getByRole("button", { name: "B" }))
-    fireEvent.click(await screen.findByRole("menuitem", { name: "Duplicate" }))
-    expect(onDuplicate).toHaveBeenCalledWith("b")
-    // leaf: removed outright
-    fireEvent.contextMenu(screen.getByRole("button", { name: "B" }))
-    fireEvent.click(await screen.findByRole("menuitem", { name: "Delete" }))
-    expect(onRemove).toHaveBeenCalledWith("b")
-    // parent: asks first
-    fireEvent.contextMenu(screen.getByRole("button", { name: "A" }))
-    fireEvent.click(await screen.findByRole("menuitem", { name: "Delete" }))
-    const dialog = await screen.findByRole("alertdialog")
-    expect(dialog.textContent).toContain("orphaned")
-    expect(onRemove).toHaveBeenCalledTimes(1)
-    fireEvent.click(screen.getByRole("button", { name: "Delete anyway" }))
-    await waitFor(() => expect(onRemove).toHaveBeenCalledWith("a"))
-  })
-
-  it("hides the context menu when read-only", () => {
-    render(<Flowchart.Root steps={STEPS} readOnly onAdd={() => {}} onRemove={() => {}} />)
-    fireEvent.contextMenu(screen.getByRole("button", { name: "A" }))
-    expect(screen.queryByRole("menu")).toBeNull()
-  })
-
-  it("renames a card from its pill and labels conditions Node n", async () => {
-    const onRename = mock(() => {})
-    render(
-      <Flowchart.Root
-        steps={[{ ...STEPS[0], kind: { label: "Trigger", hue: "#000" } }, { ...STEPS[1], condition: true }]}
-        onRename={onRename}
-      />
-    )
-    expect(screen.getByText("Trigger")).toBeTruthy()
-    expect(screen.getByText("Node 2")).toBeTruthy()
-    fireEvent.doubleClick(screen.getByText("Node 2"))
-    const input = screen.getByRole("textbox", { name: "Node name" })
-    fireEvent.change(input, { target: { value: "Cross references" } })
-    fireEvent.keyDown(input, { key: "Enter" })
-    expect(onRename).toHaveBeenCalledWith("b", "Cross references")
-  })
-
-  it("zooms with the buttons", () => {
-    const { container } = render(<Flowchart.Root steps={STEPS} zoomable />)
-    fireEvent.click(screen.getByRole("button", { name: "Zoom in" }))
-    expect(screen.getByText("125%")).toBeTruthy()
-    const canvas = container.querySelector('[data-slot="flowchart"]') as HTMLElement
-    expect(canvas.style.backgroundSize).toContain("27.5px")
-  })
-
-  it("fills its parent and keeps a min-height floor when zooming out or removing a card", () => {
-    const { container, rerender } = render(<Flowchart.Root steps={STEPS} zoomable height={300} />)
-    const canvas = container.querySelector('[data-slot="flowchart"]') as HTMLElement
-    expect(canvas.className).toContain("h-full")
-    expect(canvas.style.minHeight).toBe("300px")
-    fireEvent.click(screen.getByRole("button", { name: "Zoom out" }))
-    expect(canvas.style.minHeight).toBe("300px")
-    rerender(<Flowchart.Root steps={[STEPS[0]]} zoomable height={300} />)
-    expect(canvas.style.minHeight).toBe("300px")
-  })
-
-  it("clears the selected card on a still click on empty canvas", () => {
-    const { container } = render(<Flowchart.Root steps={STEPS} />)
-    const step = screen.getByRole("button", { name: "A" })
-    fireEvent.click(step)
-    expect(step.getAttribute("aria-pressed")).toBe("true")
-    const canvas = container.querySelector('[data-slot="flowchart"]') as HTMLElement
-    fireEvent.pointerDown(canvas, { button: 0, clientX: 5, clientY: 5 })
-    fireEvent.pointerUp(canvas)
-    expect(step.getAttribute("aria-pressed")).toBe("false")
-  })
-
-  it("selects a connector and edits it from the toolbar", () => {
-    const onEdgeRemove = mock(() => {})
-    const onEdgeChange = mock(() => {})
-    const { container } = render(<Flowchart.Root steps={STEPS} onEdgeRemove={onEdgeRemove} onEdgeChange={onEdgeChange} />)
-    expect(screen.queryByRole("toolbar")).toBeNull()
-    // the wide transparent twin is the click target
-    fireEvent.click(container.querySelector('path[data-edge="a->b"]')!.nextElementSibling!)
-    expect(screen.getByRole("toolbar", { name: "Connector" })).toBeTruthy()
-    expect(container.querySelector('path[data-edge="a->b"]')!.getAttribute("stroke")).toContain("accent")
-    fireEvent.click(screen.getByRole("button", { name: "Stroke 3" }))
-    expect(onEdgeChange).toHaveBeenCalledWith("a->b", { strokeWidth: 3 })
-    fireEvent.click(screen.getByRole("button", { name: "Disconnect" }))
-    expect(onEdgeRemove).toHaveBeenCalledWith("a->b")
-    expect(screen.queryByRole("toolbar")).toBeNull()
-  })
-})

package/src/components/composed/chat/__tests__/glass-material.test.tsx

@@ -1,54 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { cleanup, fireEvent, render, screen } from "@testing-library/react"
-import { createRef } from "react"
-import { Button } from "@/components/ui/button"
-import { GlassContainer } from "@/components/ui/glasscn/glass-container"
-import type { TFrostGlassVariant } from "@/lib/glass-variants"
-
-afterEach(cleanup)
-
-describe("library glass material", () => {
-  for (const glassVariant of [
-    "clear",
-    "frosted",
-    "subtle",
-    "liquid",
-    "liquid-refract",
-  ] as TFrostGlassVariant[]) {
-    test(`${glassVariant} keeps the button as the interactive root`, () => {
-      let clicks = 0
-      const { container } = render(
-        <Button
-          variant="glass"
-          glassVariant={glassVariant}
-          onClick={() => clicks++}
-        >
-          Save
-        </Button>
-      )
-      const button = screen.getByRole("button", { name: "Save" })
-      expect(container.firstElementChild).toBe(button)
-      expect(
-        button.querySelector('[data-liquid-glass="material"]')
-      ).toBeTruthy()
-      fireEvent.click(button)
-      expect(clicks).toBe(1)
-    })
-  }
-
-  test("container forwards refs and attributes to the content host", () => {
-    const ref = createRef<HTMLDivElement>()
-    render(
-      <GlassContainer ref={ref} role="region" aria-label="Details">
-        <button>Inspect</button>
-      </GlassContainer>
-    )
-    expect<HTMLElement | null>(ref.current).toBe(
-      screen.getByRole("region", { name: "Details" })
-    )
-    expect(
-      ref.current?.querySelectorAll('[data-liquid-glass="material"]').length
-    ).toBe(1)
-    expect(screen.getByRole("button", { name: "Inspect" })).toBeTruthy()
-  })
-})

package/src/components/composed/chat/__tests__/markdown.test.tsx

@@ -1,25 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { render, screen, waitFor } from "@testing-library/react"
-import userEvent from "@testing-library/user-event"
-import { Provider } from "jotai"
-
-import { Markdown } from "../markdown"
-
-const SRC = "# Title\n\nBody with `code`.\n\n- one\n- two"
-
-describe("Markdown", () => {
-  test("toggles between rendered preview and raw markup", async () => {
-    const onCopy = mock(() => {})
-    render(<Provider><Markdown source={SRC} onCopy={onCopy} /></Provider>)
-    expect(screen.getByRole("heading", { level: 1 }).textContent).toBe("Title")
-    expect(screen.getAllByRole("listitem").length).toBe(2)
-    const user = userEvent.setup()
-    await user.click(screen.getByRole("tab", { name: "Markup" }))
-    await waitFor(() => {
-      expect(screen.queryByRole("heading", { level: 1 })).toBeNull()
-      expect(screen.getByText(/# Title/)).toBeDefined()
-    })
-    await user.click(screen.getByRole("button", { name: "Copy markdown" }))
-    expect(onCopy).toHaveBeenCalledWith(SRC)
-  })
-})

package/src/components/composed/chat/__tests__/menu-command.test.tsx

@@ -1,35 +0,0 @@
-import { expect, mock, test } from "bun:test"
-import { render, screen, waitFor } from "@testing-library/react"
-import userEvent from "@testing-library/user-event"
-import { MenuCommand } from "@/components/ui/menu-command"
-
-test("filters commands and selects with the keyboard", async () => {
-  const user = userEvent.setup()
-  const onSelect = mock(() => {})
-  const action = mock(() => {})
-  render(
-    <MenuCommand
-      onSelect={onSelect}
-      items={[
-        { id: "search", label: "Search corpus" },
-        { id: "export", label: "Export notes", onSelect: action },
-      ]}
-    >
-      <button>Commands</button>
-    </MenuCommand>
-  )
-  await user.click(screen.getByRole("button", { name: "Commands" }))
-  const input = await screen.findByRole("combobox", { name: "Search commands" })
-  await user.type(input, "Export")
-  await waitFor(() =>
-    expect(screen.queryByRole("option", { name: "Search corpus" })).toBeNull()
-  )
-  await user.keyboard("{ArrowDown}{Enter}")
-  expect(action).toHaveBeenCalledTimes(1)
-  expect(onSelect).toHaveBeenCalledTimes(1)
-  await waitFor(() =>
-    expect(
-      screen.queryByRole("combobox", { name: "Search commands" })
-    ).toBeNull()
-  )
-})

package/src/components/composed/chat/__tests__/recommendation.test.tsx

@@ -1,43 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { render, screen, waitFor, within } from "@testing-library/react"
-import userEvent from "@testing-library/user-event"
-
-import { RecommendationCard } from "../recommendation"
-
-describe("Recommendation content", () => {
-  test("collapses the description and its pills with the body while keeping the title available", async () => {
-    const user = userEvent.setup()
-    const onAccept = mock(() => {})
-    render(
-      <RecommendationCard
-        title="Validate this corpus"
-        description="Check the section features in"
-        entity={{ name: "Iliad", initials: "I" }}
-        leadTime="2 min"
-        defaultOpen={false}
-        onAccept={onAccept}
-      />
-    )
-    const trigger = screen.getByRole("button", { name: "Validate this corpus" })
-    expect(trigger.getAttribute("aria-expanded")).toBe("false")
-    expect(screen.queryByText("Check the section features in")).toBeNull()
-    expect(screen.queryByText("Iliad")).toBeNull()
-    expect(screen.queryByText("2 min")).toBeNull()
-
-    await user.click(trigger)
-    const description = await screen.findByText(
-      "Check the section features in",
-      { exact: false }
-    )
-    expect(description.closest('[data-slot="accordion-panel"]')).not.toBeNull()
-    expect(within(trigger).queryByText("Iliad")).toBeNull()
-    expect(screen.getByText("Iliad")).toBeDefined()
-    expect(screen.getByText("2 min")).toBeDefined()
-    await user.click(screen.getByRole("button", { name: "Accept" }))
-    expect(onAccept).toHaveBeenCalledTimes(1)
-
-    await user.click(trigger)
-    expect(trigger.getAttribute("aria-expanded")).toBe("false")
-    await waitFor(() => expect(screen.queryByText("Iliad")).toBeNull())
-  })
-})