@exegia/corpora-ui 3.0.0 → 4.0.0

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

@@ -1,93 +0,0 @@
-import type * as React from "react"
-
-import type { TAvatarStatus } from "@/components/atoms"
-
-/** The identity shown on the card. */
-export interface IProfileCardUser {
-  name: string
-  /** Secondary line under the name — a handle, an email, a role. */
-  username?: string
-  /** Avatar image URL. Falls back to the initials when absent or broken. */
-  avatar?: string
-  /** Fallback initials. Derived from `name` when omitted. */
-  initials?: string
-  /** Presence badge on the avatar. Omitted, no badge. */
-  presence?: TAvatarStatus
-}
-
-/** An actionable row of the menu. */
-export interface IProfileCardAction {
-  type?: "item"
-  id: string
-  label: string
-  icon?: React.ReactNode
-  /** Right-aligned hint, e.g. "⌘K". Purely decorative — bind the key yourself. */
-  shortcut?: string
-  disabled?: boolean
-  variant?: "default" | "destructive"
-  /** Returning a promise puts the card in its loading state until it settles. */
-  onSelect?: () => void | Promise<void>
-}
-
-/** A heading over the rows that follow it, up to the next separator. */
-export interface IProfileCardLabel {
-  type: "label"
-  label: string
-}
-
-/** A rule between two sections. */
-export interface IProfileCardSeparator {
-  type: "separator"
-}
-
-/**
- * One entry of `items`. Authored flat; the block renders each run between
- * separators as its own menu group so a label actually names its section.
- */
-export type TProfileCardItem =
-  IProfileCardAction | IProfileCardLabel | IProfileCardSeparator
-
-/** `expanded` shows avatar, name and handle; `collapsed` folds to the avatar
- * alone — for an icon-collapsed sidebar rail. */
-export type TProfileCardVariant = "expanded" | "collapsed"
-
-/** Key for one card's state in the store. Any stable string; `useProfileCard`
- * generates one when the component does not name itself. */
-export type TProfileCardInstanceId = string
-
-/** Everything the store knows about one card. */
-export interface IProfileCardState {
-  variant: TProfileCardVariant
-  menuOpen: boolean
-  /** Id of the action whose promise is in flight, `null` while idle. */
-  pendingActionId: string | null
-  /** `pendingActionId !== null` — the trigger is disabled and shows a spinner. */
-  busy: boolean
-}
-
-/** Write-only handles onto one card. Nothing here re-renders the caller. */
-export interface IProfileCardActions {
-  setVariant: (variant: TProfileCardVariant) => void
-  toggleVariant: () => void
-  /** Convenience over `setVariant`. */
-  collapse: () => void
-  expand: () => void
-  setMenuOpen: (open: boolean) => void
-  openMenu: () => void
-  closeMenu: () => void
-  reset: () => void
-}
-
-/** @internal Which fields the mounted component controls from props. The
- * store must never overwrite a controlled value. */
-export interface IProfileCardConfig {
-  controlsVariant: boolean
-  controlsMenuOpen: boolean
-}
-
-/** @internal Latest option callbacks. Only write atoms read this, so it can
- * be refreshed every commit without re-rendering anything. */
-export interface IProfileCardHandlers {
-  onVariantChange?: (variant: TProfileCardVariant) => void
-  onError?: (error: unknown) => void
-}

package/src/components/blocks/profile/use-profile-card-state.ts

@@ -1,67 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { useAtomValue, useSetAtom } from "jotai"
-
-import {
-  profileCardStateAtom,
-  resetProfileCardAtom,
-  setProfileCardMenuOpenAtom,
-  setProfileCardVariantAtom,
-  toggleProfileCardVariantAtom,
-} from "./profile-card-atom"
-import type {
-  IProfileCardActions,
-  TProfileCardInstanceId,
-  IProfileCardState,
-} from "./type"
-
-/**
- * Read the card registered under `profileCardId` from anywhere below
- * `ExegiaProvider` — no props, no ref, no provider of its own.
- *
- * ```tsx
- * const { variant, busy } = useProfileCardState("account")
- * ```
- *
- * Returns the whole state object, so the caller re-renders on any change. A
- * component that watches one field should subscribe to that atom instead:
- * `useAtomValue(profileCardVariantAtom("account"))`.
- */
-export function useProfileCardState(
-  profileCardId: TProfileCardInstanceId
-): IProfileCardState {
-  return useAtomValue(profileCardStateAtom(profileCardId))
-}
-
-/**
- * Write-only handles onto the card registered under `profileCardId`. Nothing
- * here subscribes, so a rail toggle can fold the card without re-rendering
- * when the card changes.
- *
- * ```tsx
- * const { collapse, expand } = useProfileCardActions("account")
- * ```
- */
-export function useProfileCardActions(
-  profileCardId: TProfileCardInstanceId
-): IProfileCardActions {
-  const setVariant = useSetAtom(setProfileCardVariantAtom(profileCardId))
-  const toggleVariant = useSetAtom(toggleProfileCardVariantAtom(profileCardId))
-  const setMenuOpen = useSetAtom(setProfileCardMenuOpenAtom(profileCardId))
-  const reset = useSetAtom(resetProfileCardAtom(profileCardId))
-
-  return React.useMemo(
-    () => ({
-      setVariant,
-      toggleVariant,
-      collapse: () => setVariant("collapsed"),
-      expand: () => setVariant("expanded"),
-      setMenuOpen,
-      openMenu: () => setMenuOpen(true),
-      closeMenu: () => setMenuOpen(false),
-      reset,
-    }),
-    [setVariant, toggleVariant, setMenuOpen, reset]
-  )
-}

package/src/components/blocks/profile/use-profile-card.ts

@@ -1,132 +0,0 @@
-"use client"
-
-import * as React from "react"
-import { useAtomValue, useSetAtom } from "jotai"
-
-import {
-  profileCardBusyAtom,
-  profileCardMenuOpenAtom,
-  profileCardVariantAtom,
-  projectProfileCardPropsAtom,
-  removeProfileCardInstance,
-  seedProfileCardVariantAtom,
-  selectProfileCardActionAtom,
-  setProfileCardHandlersAtom,
-  setProfileCardMenuOpenAtom,
-} from "./profile-card-atom"
-import type {
-  IProfileCardAction,
-  IProfileCardConfig,
-  IProfileCardHandlers,
-  TProfileCardInstanceId,
-  TProfileCardVariant,
-} from "./type"
-
-export interface IUseProfileCardOptions {
-  profileCardId?: TProfileCardInstanceId
-  /** Controlled fold. `undefined` leaves the store (and `defaultVariant`) in charge. */
-  variant?: TProfileCardVariant
-  defaultVariant?: TProfileCardVariant
-  onVariantChange?: (variant: TProfileCardVariant) => void
-  /** Controlled menu. */
-  open?: boolean
-  defaultOpen?: boolean
-  onError?: (error: unknown) => void
-}
-
-export interface IProfileCardBinding {
-  profileCardId: TProfileCardInstanceId
-  variant: TProfileCardVariant
-  collapsed: boolean
-  menuOpen: boolean
-  busy: boolean
-  /** Hand to the menu's `onOpenChange` (first argument). Stable. */
-  setMenuOpen: (open: boolean) => void
-  /** Run an action: `onSelect`, promise → busy, rejection → `onError`. Stable. */
-  select: (action: IProfileCardAction) => void
-}
-
-/**
- * Binds one profile card to its slice of the store: projects the controlled
- * `variant` / `open` props (one-way, with write gates so the store never
- * overwrites a prop), publishes the latest handlers, and returns the values
- * the component renders from.
- *
- * Unnamed cards key off `useId` and are dropped on unmount; a named
- * `profileCardId` outlives its component, so a fold set from elsewhere
- * (`useProfileCardActions(id).collapse()`) survives a route change.
- */
-export function useProfileCard(
-  options: IUseProfileCardOptions
-): IProfileCardBinding {
-  const {
-    variant: variantProp,
-    defaultVariant = "expanded",
-    onVariantChange,
-    open: openProp,
-    onError,
-  } = options
-  const generatedId = React.useId()
-  const profileCardId = options.profileCardId ?? generatedId
-
-  const controlsVariant = variantProp !== undefined
-  const controlsMenuOpen = openProp !== undefined
-  const config = React.useMemo<IProfileCardConfig>(
-    () => ({ controlsVariant, controlsMenuOpen }),
-    [controlsVariant, controlsMenuOpen]
-  )
-  const handlers = React.useMemo<IProfileCardHandlers>(
-    () => ({ onVariantChange, onError }),
-    [onVariantChange, onError]
-  )
-
-  const project = useSetAtom(projectProfileCardPropsAtom(profileCardId))
-  const publishHandlers = useSetAtom(setProfileCardHandlersAtom(profileCardId))
-  const seedVariant = useSetAtom(seedProfileCardVariantAtom(profileCardId))
-  const setMenuOpen = useSetAtom(setProfileCardMenuOpenAtom(profileCardId))
-  const select = useSetAtom(selectProfileCardActionAtom(profileCardId))
-
-  // Reads BEFORE the write effects, and the writes in passive effects: jotai
-  // (v3) subscribes `useAtomValue` in its own `useEffect` with no
-  // post-subscription recheck, so a write from a `useLayoutEffect` (or from
-  // any effect declared before the reads) lands before the subscription
-  // exists and the card never re-renders with the seeded state.
-  const variant = useAtomValue(profileCardVariantAtom(profileCardId))
-  const menuOpen = useAtomValue(profileCardMenuOpenAtom(profileCardId))
-  const busy = useAtomValue(profileCardBusyAtom(profileCardId))
-
-  // Seed the uncontrolled fold once per mount, before the projection — the
-  // `default*` options describe the mount, not every render. Primitive deps,
-  // so no loop guard is needed.
-  const [seed] = React.useState(() => ({
-    variant: variantProp ?? defaultVariant,
-    open: openProp ?? options.defaultOpen ?? false,
-  }))
-  React.useEffect(() => {
-    if (!controlsVariant) seedVariant(seed.variant)
-    if (!controlsMenuOpen) setMenuOpen(seed.open)
-    // Mount-time seed only.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-  React.useEffect(() => {
-    project(config, variantProp, openProp)
-  }, [project, config, variantProp, openProp])
-  React.useEffect(() => {
-    publishHandlers(handlers)
-  }, [publishHandlers, handlers])
-
-  React.useEffect(() => {
-    if (options.profileCardId !== undefined) return
-    return () => removeProfileCardInstance(profileCardId)
-  }, [options.profileCardId, profileCardId])
-
-  return {
-    profileCardId,
-    variant,
-    collapsed: variant === "collapsed",
-    menuOpen,
-    busy,
-    setMenuOpen,
-    select,
-  }
-}

package/src/components/blocks/scaffold/__tests__/scaffold-atom.test.tsx

@@ -1,236 +0,0 @@
-import { describe, expect, mock, test } from "bun:test"
-import { createStore } from "jotai"
-
-import {
-  measureScaffoldCanvasAtom,
-  updateScaffoldPanelLayoutAtom,
-  resizeScaffoldInspectorAtom,
-  projectScaffoldPropsAtom,
-  registerScaffoldPanelIdsAtom,
-  removeScaffoldInstance,
-  resetScaffoldAtom,
-  scaffoldHiddenPanelIdsAtom,
-  scaffoldHoveredPanelIdAtom,
-  scaffoldInspectorOpenAtom,
-  scaffoldPanelCapacityAtom,
-  scaffoldPanelDimmedAtom,
-  scaffoldPanelHiddenAtom,
-  scaffoldStateAtom,
-  scaffoldVisibilityAtom,
-  setScaffoldHandlersAtom,
-  setScaffoldInspectorOpenAtom,
-  setScaffoldPanelHoveredAtom,
-  toggleScaffoldInspectorAtom,
-  toggleScaffoldPanelAtom,
-} from "../scaffold-atom"
-
-type TStore = ReturnType<typeof createStore>
-
-let keys = 0
-/** A fresh instance per test — ids never collide, no cross-test state. */
-const instance = () => `scaffold-test-${keys++}`
-
-/** Register three panels on a canvas wide enough for all of them. */
-function mountThree(store: TStore, id: string) {
-  store.set(registerScaffoldPanelIdsAtom(id), ["one", "two", "three"])
-  store.set(measureScaffoldCanvasAtom(id), 1200)
-}
-
-describe("scaffold panel visibility atoms", () => {
-  test("narrowing evicts the least-recently-activated panel; widening restores it", () => {
-    const store = createStore()
-    const id = instance()
-    mountThree(store, id)
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual([])
-
-    // Two panels' worth of room.
-    store.set(measureScaffoldCanvasAtom(id), 700)
-    expect(store.get(scaffoldPanelCapacityAtom(id))).toBe(2)
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual(["one"])
-    expect(store.get(scaffoldPanelHiddenAtom(id, "one"))).toBe(true)
-    expect(store.get(scaffoldPanelHiddenAtom(id, "two"))).toBe(false)
-
-    // Room returns — the auto-hidden panel comes back by itself.
-    store.set(measureScaffoldCanvasAtom(id), 1200)
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual([])
-  })
-
-  test("showing a hidden panel past capacity trades places with the oldest visible one", () => {
-    const store = createStore()
-    const id = instance()
-    mountThree(store, id)
-    store.set(measureScaffoldCanvasAtom(id), 700)
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual(["one"])
-
-    store.set(toggleScaffoldPanelAtom(id), "one")
-    expect(store.get(scaffoldPanelHiddenAtom(id, "one"))).toBe(false)
-    expect(store.get(scaffoldPanelHiddenAtom(id, "two"))).toBe(true)
-  })
-
-  test("user-hidden panels stay hidden when the canvas widens; a press shows them again", () => {
-    const store = createStore()
-    const id = instance()
-    mountThree(store, id)
-
-    store.set(toggleScaffoldPanelAtom(id), "two")
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual(["two"])
-
-    store.set(measureScaffoldCanvasAtom(id), 1400)
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual(["two"])
-
-    store.set(toggleScaffoldPanelAtom(id), "two")
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual([])
-  })
-
-  test("the last visible panel refuses to hide; unknown ids are inert", () => {
-    const store = createStore()
-    const id = instance()
-    mountThree(store, id)
-    store.set(measureScaffoldCanvasAtom(id), 400)
-    expect(store.get(scaffoldPanelCapacityAtom(id))).toBe(1)
-    expect(store.get(scaffoldPanelHiddenAtom(id, "three"))).toBe(false)
-
-    store.set(toggleScaffoldPanelAtom(id), "three")
-    expect(store.get(scaffoldPanelHiddenAtom(id, "three"))).toBe(false)
-
-    store.set(toggleScaffoldPanelAtom(id), "nonexistent")
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual(["one", "two"])
-  })
-
-  test("departed panels are pruned from every list on re-registration", () => {
-    const store = createStore()
-    const id = instance()
-    mountThree(store, id)
-    store.set(toggleScaffoldPanelAtom(id), "two")
-
-    store.set(registerScaffoldPanelIdsAtom(id), ["one", "three"])
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual([])
-  })
-
-  test("a resize that lands on the same capacity leaves the visibility untouched", () => {
-    const store = createStore()
-    const id = instance()
-    mountThree(store, id)
-    const before = store.get(scaffoldVisibilityAtom(id))
-
-    // 1200 → 1000 both fit three panels.
-    store.set(measureScaffoldCanvasAtom(id), 1000)
-    expect(store.get(scaffoldVisibilityAtom(id))).toBe(before)
-  })
-})
-
-describe("scaffold hover atoms", () => {
-  test("hover spotlights one panel; a stale leave never clears a newer hover", () => {
-    const store = createStore()
-    const id = instance()
-    mountThree(store, id)
-
-    store.set(setScaffoldPanelHoveredAtom(id), "one", true)
-    expect(store.get(scaffoldPanelDimmedAtom(id, "one"))).toBe(false)
-    expect(store.get(scaffoldPanelDimmedAtom(id, "two"))).toBe(true)
-
-    // The pointer moved on before "one"'s leave fired.
-    store.set(setScaffoldPanelHoveredAtom(id), "two", true)
-    store.set(setScaffoldPanelHoveredAtom(id), "one", false)
-    expect(store.get(scaffoldHoveredPanelIdAtom(id))).toBe("two")
-
-    store.set(setScaffoldPanelHoveredAtom(id), "two", false)
-    expect(store.get(scaffoldHoveredPanelIdAtom(id))).toBe(null)
-    expect(store.get(scaffoldPanelDimmedAtom(id, "one"))).toBe(false)
-  })
-
-  test("the empty-key sentinel reads false however the scaffold moves", () => {
-    const store = createStore()
-    const id = instance()
-    store.set(setScaffoldPanelHoveredAtom(id), "one", true)
-    expect(store.get(scaffoldPanelDimmedAtom(id, ""))).toBe(false)
-    expect(store.get(scaffoldPanelHiddenAtom(id, ""))).toBe(false)
-  })
-})
-
-describe("scaffold inspector atoms", () => {
-  test("set and toggle report through the handler and write the store when uncontrolled", () => {
-    const store = createStore()
-    const id = instance()
-    const onInspectorOpenChange = mock(() => {})
-    store.set(setScaffoldHandlersAtom(id), { onInspectorOpenChange })
-
-    store.set(setScaffoldInspectorOpenAtom(id), true)
-    expect(store.get(scaffoldInspectorOpenAtom(id))).toBe(true)
-    expect(onInspectorOpenChange).toHaveBeenCalledWith(true)
-
-    // Setting the value it already holds is silent.
-    store.set(setScaffoldInspectorOpenAtom(id), true)
-    expect(onInspectorOpenChange).toHaveBeenCalledTimes(1)
-
-    store.set(toggleScaffoldInspectorAtom(id))
-    expect(store.get(scaffoldInspectorOpenAtom(id))).toBe(false)
-    expect(onInspectorOpenChange).toHaveBeenLastCalledWith(false)
-  })
-
-  test("a controlled inspector gates store writes; actions only report", () => {
-    const store = createStore()
-    const id = instance()
-    const onInspectorOpenChange = mock(() => {})
-    store.set(setScaffoldHandlersAtom(id), { onInspectorOpenChange })
-    store.set(projectScaffoldPropsAtom(id), { controlsInspector: true }, false)
-
-    store.set(setScaffoldInspectorOpenAtom(id), true)
-    expect(store.get(scaffoldInspectorOpenAtom(id))).toBe(false)
-    expect(onInspectorOpenChange).toHaveBeenCalledWith(true)
-
-    // The prop coming back around through the projection is what moves it.
-    store.set(projectScaffoldPropsAtom(id), { controlsInspector: true }, true)
-    expect(store.get(scaffoldInspectorOpenAtom(id))).toBe(true)
-  })
-})
-
-describe("scaffold instance lifecycle", () => {
-  test("reset restores every field; remove drops the id from every family", () => {
-    const store = createStore()
-    const id = instance()
-    mountThree(store, id)
-    store.set(measureScaffoldCanvasAtom(id), 700)
-    store.set(setScaffoldInspectorOpenAtom(id), true)
-    store.set(setScaffoldPanelHoveredAtom(id), "two", true)
-
-    store.set(resetScaffoldAtom(id))
-    expect(store.get(scaffoldStateAtom(id))).toEqual({
-      inspectorOpen: false,
-      inspectorWidth: null,
-      panelLayouts: {},
-      panelCapacity: 3,
-      hiddenPanelIds: [],
-      hoveredPanelId: null,
-    })
-
-    // A removed id reads fresh atoms — state from before is gone.
-    mountThree(store, id)
-    store.set(measureScaffoldCanvasAtom(id), 700)
-    removeScaffoldInstance(id)
-    expect(store.get(scaffoldPanelCapacityAtom(id))).toBe(3)
-    expect(store.get(scaffoldHiddenPanelIdsAtom(id))).toEqual([])
-  })
-})
-
-test("panel geometry and expansion persist per scaffold and reset together", () => {
-  const store = createStore()
-  store.set(updateScaffoldPanelLayoutAtom("first"), "editor", {
-    width: 480,
-    secondarySize: 160,
-    secondaryExpanded: true,
-    swapped: true,
-  })
-  store.set(resizeScaffoldInspectorAtom("first"), 360)
-  expect(store.get(scaffoldStateAtom("first")).panelLayouts.editor).toEqual({
-    width: 480,
-    secondarySize: 160,
-    secondaryExpanded: true,
-    swapped: true,
-  })
-  expect(store.get(scaffoldStateAtom("first")).inspectorWidth).toBe(360)
-  expect(store.get(scaffoldStateAtom("second")).panelLayouts).toEqual({})
-  store.set(resetScaffoldAtom("first"))
-  expect(store.get(scaffoldStateAtom("first")).panelLayouts).toEqual({})
-  expect(store.get(scaffoldStateAtom("first")).inspectorWidth).toBeNull()
-})