@exegia/corpora-ui 3.0.0 → 3.1.0

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())
-  })
-})

package/src/components/composed/chat/actions.tsx

@@ -1,81 +0,0 @@
-import { Bubble } from "@/components/atoms"
-import { Button } from "@/components/ui/button"
-import {
-  Tooltip,
-  TooltipCreateHandle,
-  TooltipPopup,
-  TooltipProvider,
-  TooltipTrigger,
-} from "@/components/ui/tooltip"
-import type {
-  IBubbleActionsProps,
-  TBubbleActionKey,
-  TBubbleActionPayload,
-} from "./type"
-import { useCallback, useMemo, type ComponentType } from "react"
-
-const tooltipHandle = TooltipCreateHandle<ComponentType>()
-
-export function Actions<K extends TBubbleActionKey = TBubbleActionKey>({
-  actions,
-  size,
-  onClick,
-}: IBubbleActionsProps<K>) {
-  const handleClick = useCallback(
-    (key: K, payload: TBubbleActionPayload) => {
-      if (onClick) onClick(key, payload)
-    },
-    [onClick]
-  )
-
-  const renderActionButton = useCallback(
-    (key?: K, action?: (typeof actions)[K]) => {
-      if (!key || !action) return
-      return (
-        <Button
-          aria-label={action?.tooltip}
-          size={action?.size ?? size}
-          variant="ghost"
-          onClick={() => {
-            const payload =
-              (action?.onClick?.arguments[1] as TBubbleActionPayload) ??
-              undefined
-            handleClick(key, payload)
-          }}
-        />
-      )
-    },
-    [handleClick, size]
-  )
-
-  const actionButtons = useMemo(() => {
-    if (!actions || Object.values(actions).length === 0) return []
-    return Object.entries<(typeof actions)[K]>(actions).map(([key, action]) => {
-      if (!key || !action) return
-      //return renderActionButton(key as K, action as typeof actions[K]);
-      return { key: key, action }
-    })
-  }, [actions])
-
-  return (
-    <TooltipProvider>
-      <Bubble.Actions>
-        {actionButtons &&
-          actionButtons.map((item, index) => (
-            <TooltipTrigger
-              key={index}
-              render={renderActionButton(item?.key as K, item?.action)}
-            >
-              {item?.action.icon}
-            </TooltipTrigger>
-          ))}
-      </Bubble.Actions>
-
-      <Tooltip handle={tooltipHandle}>
-        {({ payload: Payload }) => (
-          <TooltipPopup>{Payload !== undefined && <Payload />}</TooltipPopup>
-        )}
-      </Tooltip>
-    </TooltipProvider>
-  )
-}

package/src/components/composed/chat/attachment-file.ts

@@ -1,82 +0,0 @@
-"use client"
-
-import { useEffect, useState } from "react"
-
-const MIME_BY_EXTENSION: Record<string, string> = {
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  png: "image/png",
-  gif: "image/gif",
-  webp: "image/webp",
-  avif: "image/avif",
-  svg: "image/svg+xml",
-  mp4: "video/mp4",
-  webm: "video/webm",
-  mov: "video/quicktime",
-  mp3: "audio/mpeg",
-  m4a: "audio/mp4",
-  wav: "audio/wav",
-  ogg: "audio/ogg",
-  pdf: "application/pdf",
-  txt: "text/plain",
-  md: "text/markdown",
-  csv: "text/csv",
-  json: "application/json",
-  xml: "text/xml",
-}
-
-export function attachmentMimeType(file: File): string {
-  return file.type && file.type !== "application/octet-stream"
-    ? file.type
-    : (MIME_BY_EXTENSION[file.name.split(".").pop()?.toLowerCase() ?? ""] ??
-        file.type)
-}
-
-export function attachmentFileKind(
-  file: File
-):
-  { kind: "image" } | { kind: "media"; audio: boolean } | { kind: "document" } {
-  const mime = attachmentMimeType(file)
-  if (mime.startsWith("image/")) return { kind: "image" }
-  if (mime.startsWith("video/") || mime.startsWith("audio/"))
-    return { kind: "media", audio: mime.startsWith("audio/") }
-  return { kind: "document" }
-}
-
-interface FilePreview {
-  file: File
-  url?: string
-  text?: string
-}
-
-/** Each mounted attachment owns its URL, so clearing the tray cannot break a sent preview. */
-export function useAttachmentFile(file?: File) {
-  const [preview, setPreview] = useState<FilePreview>()
-  useEffect(() => {
-    if (!file) return
-    let active = true
-    let url: string | undefined
-    // Create browser resources after mounting; cancelled renders never allocate a URL.
-    void Promise.resolve().then(async () => {
-      if (!active) return
-      try {
-        const mime = attachmentMimeType(file)
-        const blob =
-          mime && file.type !== mime ? file.slice(0, file.size, mime) : file
-        url = URL.createObjectURL(blob)
-        const text =
-          mime.startsWith("text/") || mime === "application/json"
-            ? await file.slice(0, 8192).text()
-            : undefined
-        if (active) setPreview({ file, url, text })
-      } catch {
-        if (active) setPreview({ file, url })
-      }
-    })
-    return () => {
-      active = false
-      if (url) URL.revokeObjectURL(url)
-    }
-  }, [file])
-  return preview?.file === file ? preview : undefined
-}