@exegia/corpora-ui 3.0.0 → 3.1.0

package/src/components/blocks/chat/type.ts

@@ -1,96 +0,0 @@
-import type * as React from "react"
-import type { IComposerProps } from "@/components/composed/chat/composer"
-
-export type TAiScopeKind =
-  "word" | "passage" | "articulus" | "quaestio" | "corpus"
-
-export interface IAiScope {
-  kind: TAiScopeKind
-  label: string
-  /** Reader location shown after a normal word/node scope. */
-  location?: string
-  range?: string
-  nodeId?: string
-  nodeIds?: string[]
-  pinned?: boolean
-}
-
-export interface IRecommendationStackProps
-  extends React.ComponentPropsWithoutRef<"div"> {
-  children: React.ReactNode
-}
-
-export interface IPinnedThreadBannerProps {
-  className?: string
-}
-
-export interface IDegradedBannerProps {
-  reason?: React.ReactNode
-  onRetry?: () => void
-  className?: string
-}
-
-// The reader selection shapes moved with `SelectionPopover` to
-// `composed/reader`; re-exported so the block's surface stays whole.
-export type { INodeSelection, IWordSelection } from "@/components/composed/reader"
-
-export interface IAiPanelProps extends Omit<
-  React.ComponentPropsWithoutRef<"aside">,
-  "title"
-> {
-  scope: IAiScope
-  onNewThread?: () => void
-  onScopeChange?: (kind: IAiScope["kind"]) => void
-  onRemoveScope?: () => void
-  thread?: React.ReactNode
-  /** Transient confirmation (e.g. ApplyToast), anchored to the bottom of the
-   * thread and sized slightly narrower than the composer. */
-  toast?: React.ReactNode
-  prompts?: string[]
-  onPromptSelect?: (prompt: string) => void
-  composerProps?: IComposerProps
-  scopePickerOpen?: boolean
-  onScopePickerOpenChange?: (open: boolean) => void
-  locked?: boolean
-  headerTitle?: string
-}
-
-export interface IAiPanelHeaderProps {
-  title: string
-  /** Shows the lock affordance and its “Published corpus” tooltip. */
-  locked?: boolean
-  onNewThread?: () => void
-}
-
-export type { TComposerMode } from "@/components/composed/chat/composer"
-export type { IDiffRow, TSuggestionState } from "@/components/composed/ai/types"
-
-export interface IVersionHistoryEntry {
-  id?: string
-  responseId: string
-  applyingUser?: string
-  nodeId: string
-  previousValue: string
-  nextValue?: string
-  timestamp: string | Date
-  version: string
-  action?: "apply" | "revert"
-}
-
-export interface ISuggestedPromptsProps {
-  prompts?: string[]
-  onSelect?: (prompt: string) => void
-  emptyLabel?: string
-  className?: string
-}
-
-export interface IVersionHistoryRecordProps {
-  entry: IVersionHistoryEntry
-  className?: string
-}
-
-
-export interface ILockedBannerProps {
-  children?: React.ReactNode
-  className?: string
-}

package/src/components/blocks/chat/version-history-record.tsx

@@ -1,37 +0,0 @@
-"use client"
-
-import type * as React from "react"
-import { cn } from "@/lib/utils"
-import { accentText, mutedText } from "./shared"
-import type { IVersionHistoryRecordProps } from "./type"
-
-
-
-export function VersionHistoryRecord({
-  entry,
-  className,
-}: IVersionHistoryRecordProps): React.ReactElement {
-  const timestamp =
-    entry.timestamp instanceof Date
-      ? entry.timestamp.toLocaleString()
-      : entry.timestamp
-  return (
-    <article
-      className={cn("border-l border-border pl-3", className)}
-      data-slot="version-history-record"
-    >
-      <p className="text-xs text-foreground/85">
-        <span className={cn("font-medium", accentText)}>
-          resp=&quot;{entry.responseId}&quot;
-        </span>
-        {entry.applyingUser ? ` · ${entry.applyingUser}` : ""}
-      </p>
-      <p className={cn("mt-1 text-xs", mutedText)}>
-        Node <code>{entry.nodeId}</code> · v{entry.version} · {timestamp}
-      </p>
-      <p className="mt-2 text-xs text-muted-foreground">
-        Previous value: <del>{entry.previousValue}</del>
-      </p>
-    </article>
-  )
-}

package/src/components/blocks/layout.ts

@@ -1,35 +0,0 @@
-import ShellLayout, {
-  AnimatedPanel,
-  AnimatedPanelTrigger,
-  useShellPanels,
-  resetShellPanelWidthAtom,
-  resizeShellPanelAtom,
-  shellFitFitsAtom,
-  shellFitMeasuredAtom,
-  shellFitMetricsAtom,
-  shellFitPanelBoundsAtom,
-  shellFitPanelWidthAtom,
-  shellFitRequestedWidthAtom,
-  shellFitStateAtom,
-} from "@/components/blocks/shell"
-
-const Layout = {
-  Main: ShellLayout,
-  Panel: AnimatedPanel,
-  Trigger: AnimatedPanelTrigger,
-}
-
-export {
-  useShellPanels,
-  resetShellPanelWidthAtom,
-  resizeShellPanelAtom,
-  shellFitFitsAtom,
-  shellFitMeasuredAtom,
-  shellFitMetricsAtom,
-  shellFitPanelBoundsAtom,
-  shellFitPanelWidthAtom,
-  shellFitRequestedWidthAtom,
-  shellFitStateAtom,
-}
-
-export default Layout

package/src/components/blocks/profile/__tests__/profile-card-block.test.tsx

@@ -1,362 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { render, screen } from "@testing-library/react"
-import userEvent from "@testing-library/user-event"
-
-import { act } from "@testing-library/react"
-
-import { AnimatedSidebarPanelContext } from "@/components/blocks/shell/utils"
-import { ProfileCardBlock } from "../profile-card-block"
-import {
-  useProfileCardActions,
-  useProfileCardState,
-} from "../use-profile-card-state"
-import type { IProfileCardActions, IProfileCardState } from "../type"
-
-const USER = { name: "Jenny Hamilton", username: "@jennycodes" }
-
-describe("ProfileCardBlock", () => {
-  test("names the trigger after the identity it shows", () => {
-    render(<ProfileCardBlock user={USER} />)
-
-    const trigger = screen.getByRole("button", {
-      name: "Jenny Hamilton @jennycodes, account menu",
-    })
-    expect(trigger.textContent).toContain("Jenny Hamilton")
-    expect(trigger.textContent).toContain("@jennycodes")
-  })
-
-  test("falls back to initials derived from the name", () => {
-    render(<ProfileCardBlock user={{ name: "Jenny Hamilton" }} />)
-    expect(screen.getByText("JH")).toBeDefined()
-  })
-
-  test("opens the default menu with a destructive sign-out", async () => {
-    const user = userEvent.setup()
-    render(<ProfileCardBlock user={USER} />)
-
-    await user.click(screen.getByRole("button"))
-
-    expect(
-      await screen.findByRole("menuitem", { name: "Profile" })
-    ).toBeDefined()
-    expect(screen.getByRole("menuitem", { name: "Settings" })).toBeDefined()
-    expect(screen.getByRole("menuitem", { name: "Teams" })).toBeDefined()
-    expect(screen.getByRole("menuitem", { name: "Invite" })).toBeDefined()
-    expect(
-      screen
-        .getByRole("menuitem", { name: "Log out" })
-        .getAttribute("data-variant")
-    ).toBe("destructive")
-  })
-
-  test("opens from the keyboard", async () => {
-    const user = userEvent.setup()
-    render(<ProfileCardBlock user={USER} />)
-
-    await user.tab()
-    await user.keyboard("{Enter}")
-
-    expect(
-      await screen.findByRole("menuitem", { name: "Profile" })
-    ).toBeDefined()
-  })
-
-  test("fires the handler behind the selected item", async () => {
-    const user = userEvent.setup()
-    const onSelect = mock(() => {})
-    render(
-      <ProfileCardBlock
-        items={[{ id: "settings", label: "Settings", onSelect }]}
-        user={USER}
-      />
-    )
-
-    await user.click(screen.getByRole("button"))
-    await user.click(await screen.findByRole("menuitem", { name: "Settings" }))
-
-    expect(onSelect).toHaveBeenCalled()
-  })
-
-  test("items replace the default menu", async () => {
-    const user = userEvent.setup()
-    render(
-      <ProfileCardBlock
-        items={[{ id: "switch", label: "Switch team" }]}
-        user={USER}
-      />
-    )
-
-    await user.click(screen.getByRole("button"))
-
-    expect(
-      await screen.findByRole("menuitem", { name: "Switch team" })
-    ).toBeDefined()
-    expect(screen.queryByRole("menuitem", { name: "Log out" })).toBeNull()
-  })
-
-  test("labels name the group they head, up to the next separator", async () => {
-    const user = userEvent.setup()
-    render(
-      <ProfileCardBlock
-        items={[
-          { type: "label", label: "Workspace" },
-          { id: "switch", label: "Switch team" },
-          { type: "separator" },
-          { id: "sign-out", label: "Log out", variant: "destructive" },
-        ]}
-        user={USER}
-      />
-    )
-
-    await user.click(screen.getByRole("button"))
-
-    const named = await screen.findByRole("group", { name: "Workspace" })
-    expect(named.querySelectorAll('[data-slot="menu-item"]')).toHaveLength(1)
-    expect(screen.getAllByRole("group")).toHaveLength(2)
-    expect(
-      screen
-        .getByRole("menuitem", { name: "Log out" })
-        .getAttribute("data-variant")
-    ).toBe("destructive")
-  })
-
-  test("reports a rejected action through onError", async () => {
-    const user = userEvent.setup()
-    const onError = mock(() => {})
-    render(
-      <ProfileCardBlock
-        items={[
-          {
-            id: "sign-out",
-            label: "Log out",
-            onSelect: async () => {
-              throw new Error("Session already ended.")
-            },
-          },
-        ]}
-        onError={onError}
-        user={USER}
-      />
-    )
-
-    await user.click(screen.getByRole("button"))
-    await user.click(await screen.findByRole("menuitem", { name: "Log out" }))
-
-    await new Promise((resolve) => setTimeout(resolve, 0))
-    expect(onError).toHaveBeenCalled()
-  })
-  test("variant=collapsed folds to the avatar but keeps the accessible name", () => {
-    const { rerender } = render(
-      <ProfileCardBlock user={USER} variant="collapsed" />
-    )
-
-    const trigger = screen.getByRole("button", {
-      name: "Jenny Hamilton @jennycodes, account menu",
-    })
-    expect(trigger.hasAttribute("data-collapsed")).toBe(true)
-    // Hover names the tile the way the rail's menu buttons do.
-    expect(trigger.getAttribute("title")).toBe("Jenny Hamilton @jennycodes")
-    // The avatar stays; the identity lines fold (hidden, not removed — that
-    // is what lets the fold animate back open).
-    expect(screen.getByText("JH")).toBeDefined()
-    const identity = trigger.querySelector(
-      '[data-slot="profile-card-identity"]'
-    )
-    expect(identity?.getAttribute("aria-hidden")).toBe("true")
-    expect(identity?.textContent).toContain("Jenny Hamilton")
-    // Full-width h-10 row, like the tree rail's tiles: avatar centred on
-    // the rail's own centre line, no inset.
-    expect(trigger.className).toContain("justify-center")
-    expect(trigger.className).toContain("h-10")
-    expect(trigger.className).toContain("w-full")
-    expect(trigger.className).toContain("p-0")
-
-    rerender(<ProfileCardBlock user={USER} variant="expanded" />)
-    expect(trigger.hasAttribute("data-collapsed")).toBe(false)
-    expect(trigger.getAttribute("title")).toBeNull()
-    expect(identity?.getAttribute("aria-hidden")).toBeNull()
-  })
-
-  test("variant=collapsed still opens the menu", async () => {
-    const user = userEvent.setup()
-    render(<ProfileCardBlock user={USER} variant="collapsed" />)
-    await user.click(screen.getByRole("button"))
-    expect(
-      await screen.findByRole("menuitem", { name: "Log out" })
-    ).toBeDefined()
-  })
-
-  test("follows the enclosing AnimatedPanel unless variant is set", () => {
-    const panel = {
-      collapsed: true,
-      collapsible: "icon",
-      side: "left",
-    } as const
-    const { rerender } = render(
-      <AnimatedSidebarPanelContext.Provider value={panel}>
-        <ProfileCardBlock user={USER} />
-      </AnimatedSidebarPanelContext.Provider>
-    )
-    const trigger = screen.getByRole("button")
-    expect(trigger.hasAttribute("data-collapsed")).toBe(true)
-
-    // An explicit prop wins over the panel.
-    rerender(
-      <AnimatedSidebarPanelContext.Provider value={panel}>
-        <ProfileCardBlock user={USER} variant="expanded" />
-      </AnimatedSidebarPanelContext.Provider>
-    )
-    expect(trigger.hasAttribute("data-collapsed")).toBe(false)
-  })
-
-  test("outside any panel an unnamed card starts expanded", () => {
-    render(<ProfileCardBlock user={USER} />)
-    expect(screen.getByRole("button").hasAttribute("data-collapsed")).toBe(
-      false
-    )
-    expect(screen.getByRole("button").getAttribute("data-variant")).toBe(
-      "expanded"
-    )
-  })
-
-  test("defaultVariant seeds an uncontrolled card", () => {
-    render(<ProfileCardBlock defaultVariant="collapsed" user={USER} />)
-    expect(screen.getByRole("button").getAttribute("data-variant")).toBe(
-      "collapsed"
-    )
-  })
-  test("data-variant mirrors the fold and onVariantChange reports store-driven changes", () => {
-    const onVariantChange = mock(() => {})
-    let actions!: IProfileCardActions
-    let state!: IProfileCardState
-    function Probe() {
-      actions = useProfileCardActions("account")
-      state = useProfileCardState("account")
-      return null
-    }
-    render(
-      <>
-        <ProfileCardBlock
-          onVariantChange={onVariantChange}
-          profileCardId="account"
-          user={USER}
-        />
-        <Probe />
-      </>
-    )
-    const trigger = screen.getByRole("button")
-    expect(trigger.getAttribute("data-variant")).toBe("expanded")
-    expect(state.variant).toBe("expanded")
-
-    // Driven from outside by id — no controller, no ref.
-    act(() => actions.collapse())
-    expect(trigger.getAttribute("data-variant")).toBe("collapsed")
-    expect(state.variant).toBe("collapsed")
-    expect(onVariantChange).toHaveBeenCalledWith("collapsed")
-
-    act(() => actions.toggleVariant())
-    expect(trigger.getAttribute("data-variant")).toBe("expanded")
-    expect(onVariantChange).toHaveBeenLastCalledWith("expanded")
-  })
-
-  test("a controlled variant is never overwritten by the store", () => {
-    let actions!: IProfileCardActions
-    function Probe() {
-      actions = useProfileCardActions("locked")
-      return null
-    }
-    const onVariantChange = mock(() => {})
-    render(
-      <>
-        <ProfileCardBlock
-          onVariantChange={onVariantChange}
-          profileCardId="locked"
-          user={USER}
-          variant="expanded"
-        />
-        <Probe />
-      </>
-    )
-    act(() => actions.collapse())
-    // Reported, not applied — the prop is truth.
-    expect(onVariantChange).toHaveBeenCalledWith("collapsed")
-    expect(screen.getByRole("button").getAttribute("data-variant")).toBe(
-      "expanded"
-    )
-  })
-
-  test("openMenu / closeMenu from outside drive the menu through the store", async () => {
-    let actions!: IProfileCardActions
-    function Probe() {
-      actions = useProfileCardActions("menu")
-      return null
-    }
-    render(
-      <>
-        <ProfileCardBlock profileCardId="menu" user={USER} />
-        <Probe />
-      </>
-    )
-    act(() => actions.openMenu())
-    expect(
-      await screen.findByRole("menuitem", { name: "Profile" })
-    ).toBeDefined()
-    act(() => actions.closeMenu())
-    await new Promise((r) => setTimeout(r, 300))
-    expect(screen.queryByRole("menuitem", { name: "Profile" })).toBeNull()
-  })
-
-  test("busy tracks a pending action in the store", async () => {
-    const user = userEvent.setup()
-    let resolve!: () => void
-    let state!: IProfileCardState
-    function Probe() {
-      state = useProfileCardState("busy")
-      return null
-    }
-    render(
-      <>
-        <ProfileCardBlock
-          items={[
-            {
-              id: "slow",
-              label: "Slow",
-              onSelect: () => new Promise<void>((r) => (resolve = r)),
-            },
-          ]}
-          profileCardId="busy"
-          user={USER}
-        />
-        <Probe />
-      </>
-    )
-    await user.click(screen.getByRole("button"))
-    await user.click(await screen.findByRole("menuitem", { name: "Slow" }))
-    expect(state.busy).toBe(true)
-    expect(state.pendingActionId).toBe("slow")
-    await act(async () => {
-      resolve()
-      await Promise.resolve()
-    })
-    expect(state.busy).toBe(false)
-  })
-
-  test("user.presence and the presence prop reach the avatar badge", () => {
-    const { rerender } = render(
-      <ProfileCardBlock user={{ ...USER, presence: "online" }} />
-    )
-    // The atoms avatar badge carries the status as a color class, not a
-    // data attribute (see atoms/avatar/utils statusClasses).
-    const badge = () => document.querySelector('[data-slot="avatar-badge"]')
-    expect(badge()?.classList.contains("bg-success")).toBe(true)
-    rerender(
-      <ProfileCardBlock
-        presence="offline"
-        user={{ ...USER, presence: "online" }}
-      />
-    )
-    expect(badge()?.classList.contains("bg-text-secondary")).toBe(true)
-    rerender(<ProfileCardBlock user={USER} />)
-    expect(badge()).toBeNull()
-  })
-})

package/src/components/blocks/profile/index.ts

@@ -1,28 +0,0 @@
-export {
-  ProfileCardBlock,
-  defaultProfileCardItems,
-} from "./profile-card-block"
-export type { IProfileCardBlockProps } from "./profile-card-block"
-export { useProfileCard } from "./use-profile-card"
-export type { IProfileCardBinding, IUseProfileCardOptions } from "./use-profile-card"
-export {
-  useProfileCardActions,
-  useProfileCardState,
-} from "./use-profile-card-state"
-// The public atom surface. `@internal` atoms (config, handlers, projections,
-// the mount seed) stay unexported on purpose.
-export {
-  profileCardBusyAtom,
-  profileCardCollapsedAtom,
-  profileCardMenuOpenAtom,
-  profileCardPendingActionIdAtom,
-  profileCardStateAtom,
-  profileCardVariantAtom,
-  removeProfileCardInstance,
-  resetProfileCardAtom,
-  selectProfileCardActionAtom,
-  setProfileCardMenuOpenAtom,
-  setProfileCardVariantAtom,
-  toggleProfileCardVariantAtom,
-} from "./profile-card-atom"
-export type * from "./type"