@exegia/corpora-ui 1.0.0 → 2.0.0

package/dist-lib/src/components/blocks/nav/sidebar/ai-sidebar-atom.d.ts

@@ -1,217 +0,0 @@
-import { Atom } from 'jotai';
-import { AISidebarConfig, AISidebarHandlers, AISidebarInstanceId, AISidebarSeed, AISidebarState, DropTarget, FlatResource, SidebarResource, SidebarResourceDropPosition, SidebarResourceMove } from './type.ts';
-/** What a sidebar reads as before `useAISidebar` publishes its options. */
-export declare const DEFAULT_AI_SIDEBAR_CONFIG: AISidebarConfig;
-/**
- * A string-keyed atom family.
- *
- * `jotai/utils`' `atomFamily` is deprecated for Jotai v3, and we need only
- * the string-keyed case with a `remove` — so this stays in-house rather than
- * adding `jotai-family` as a second Jotai package to keep version-aligned.
- * Dropping a key lets the store's WeakMap release that instance's state.
- */
-type Family<AtomType> = ((id: AISidebarInstanceId) => AtomType) & {
-    remove: (id: AISidebarInstanceId) => void;
-};
-/** @internal */
-export declare const aiSidebarConfigAtom: Family<import('jotai').PrimitiveAtom<AISidebarConfig> & {
-    init: AISidebarConfig;
-}>;
-/** @internal Refreshed every commit; nothing subscribes, so it is free. */
-export declare const aiSidebarHandlersAtom: Family<import('jotai').PrimitiveAtom<AISidebarHandlers> & {
-    init: AISidebarHandlers;
-}>;
-/** The sidebar's current data — hook-owned, or the projection of a
- * controlled `items` prop. */
-export declare const aiSidebarItemsAtom: Family<import('jotai').PrimitiveAtom<SidebarResource[]> & {
-    init: SidebarResource[];
-}>;
-/** @internal The hook-owned selection. `select` writes it only while no
- * `activeId` prop owns the selection — read `aiSidebarActiveIdAtom` for the
- * value the sidebar actually renders. */
-export declare const aiSidebarOwnActiveIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
-    init: string | null;
-}>;
-/** @internal Projection of a controlled `activeId` prop; `undefined` while
- * the selection is hook-owned. */
-export declare const aiSidebarControlledActiveIdAtom: Family<import('jotai').PrimitiveAtom<string | null | undefined> & {
-    init: string | null | undefined;
-}>;
-/** Open rows — hook-owned, or the projection of a controlled `expandedIds`
- * prop. */
-export declare const aiSidebarExpandedIdsAtom: Family<import('jotai').PrimitiveAtom<ReadonlySet<string>> & {
-    init: ReadonlySet<string>;
-}>;
-/** Roving-focus target. DOM focus is moved by the block, which owns the row
- * refs; this is only which row is tabbable. */
-export declare const aiSidebarFocusedIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
-    init: string | null;
-}>;
-export declare const aiSidebarDraggingIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
-    init: string | null;
-}>;
-export declare const aiSidebarDropTargetAtom: Family<import('jotai').PrimitiveAtom<DropTarget | null> & {
-    init: DropTarget | null;
-}>;
-export declare const aiSidebarMenuOpenIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
-    init: string | null;
-}>;
-export declare const aiSidebarRenamingIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
-    init: string | null;
-}>;
-export declare const aiSidebarHoveredIdAtom: Family<import('jotai').PrimitiveAtom<string | null> & {
-    init: string | null;
-}>;
-/** Live-region text for the last move or rename outcome. */
-export declare const aiSidebarAnnouncementAtom: Family<import('jotai').PrimitiveAtom<string> & {
-    init: string;
-}>;
-/** A move is in flight. Read synchronously by `moveAISidebarRowAtom` before
- * it starts another — the store needs no ref to see its own latest write. */
-export declare const aiSidebarMovePendingAtom: Family<import('jotai').PrimitiveAtom<boolean> & {
-    init: boolean;
-}>;
-/** @internal The only items atom `useAISidebar` may subscribe to: empty
- * while a controlled `items` prop owns the data, so the projection write
- * never feeds back into the render that produced it. An inline `items={[…]}`
- * array is a new reference every render, and a subscribed round-trip would
- * loop. */
-export declare const aiSidebarOwnedItemsAtom: Family<Atom<SidebarResource[]>>;
-/** @internal The same guard for `expandedIds`, which is controllable here
- * and arrives as an array — just as unstable an identity as `items`. */
-export declare const aiSidebarOwnedExpandedIdsAtom: Family<Atom<ReadonlySet<string>>>;
-/** The selected row: the controlled `activeId` when there is one, the
- * hook-owned selection otherwise. Kept as two atoms because a controlled
- * `activeId` of `null` falls through to the hook-owned value — the block has
- * always read `activeId ?? internalActiveId`. */
-export declare const aiSidebarActiveIdAtom: Family<Atom<string | null>>;
-/** Visible rows in order, each with its depth and parent id. */
-export declare const aiSidebarFlatAtom: Family<Atom<FlatResource[]>>;
-/** Some row is hovered and no drag is running — mounts the pill wrapper. */
-export declare const aiSidebarHoverActiveAtom: Family<Atom<boolean>>;
-/** Whether this one row is the current selection. */
-export declare const aiSidebarRowSelectedAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
-/** Whether this one row is open. */
-export declare const aiSidebarRowExpandedAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
-/** Whether this one row is the roving-focus target. */
-export declare const aiSidebarRowFocusedAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
-/** Whether this one row is in rename mode. */
-export declare const aiSidebarRowRenamingAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
-/** Whether this one row's action menu is open. */
-export declare const aiSidebarRowMenuOpenAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
-/** Whether this one row is the row in flight. */
-export declare const aiSidebarRowDraggingAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
-/** Where a drop on this one row would land, `null` when it is not hovered
- * by a drag. */
-export declare const aiSidebarRowDropAtom: (id: AISidebarInstanceId, rowId: string) => Atom<SidebarResourceDropPosition | null>;
-/** Whether this one row owns the sliding hover pill. */
-export declare const aiSidebarRowHoveredAtom: (id: AISidebarInstanceId, rowId: string) => Atom<boolean>;
-/** The whole state of one sidebar. Components reading a single field should
- * subscribe to that field's atom instead — this one changes on every edit. */
-export declare const aiSidebarStateAtom: Family<Atom<AISidebarState>>;
-export declare const expandAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
-    init: null;
-}>;
-export declare const collapseAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
-    init: null;
-}>;
-export declare const toggleAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
-    init: null;
-}>;
-export declare const expandAllAISidebarRowsAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-export declare const collapseAllAISidebarRowsAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-/** Open every ancestor of `rowId` without touching the rest of the tree. */
-export declare const revealAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
-    init: null;
-}>;
-export declare const selectAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
-    init: null;
-}>;
-/** The store half of `focus`: which row is tabbable. Moving DOM focus is the
- * block's job — it owns the row refs. */
-export declare const focusAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
-    init: null;
-}>;
-/** @internal Keeps the roving target on a row that still renders: a focused
- * row that folds away hands focus to the first visible row instead of
- * pointing at nothing. `useAISidebar` runs it after every projection. */
-export declare const normalizeAISidebarFocusAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-export declare const startAISidebarRenameAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
-    init: null;
-}>;
-export declare const cancelAISidebarRenameAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-/** Commit a rename and leave rename mode. Applied optimistically and rolled
- * back if `onRename` rejects. Blank and unchanged labels are dropped. */
-export declare const renameAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [rowId: string, label: string], void> & {
-    init: null;
-}>;
-export declare const openAISidebarMenuAtom: Family<import('jotai').WritableAtom<null, [rowId: string], void> & {
-    init: null;
-}>;
-/** Closes the menu and hands the roving target back to the row that owned
- * it, then returns that id so the block can move DOM focus there — otherwise
- * focus falls back to the body and the keyboard user loses their place. */
-export declare const closeAISidebarMenuAtom: Family<import('jotai').WritableAtom<null, [], string | null> & {
-    init: null;
-}>;
-/**
- * Reorder, applied optimistically and rolled back if `onMove` rejects.
- *
- * The pending flag is read straight back out of the store, which is why this
- * needs no ref to guard overlapping moves the way React state did: the write
- * is visible to the next call immediately, not after a commit.
- */
-export declare const moveAISidebarRowAtom: Family<import('jotai').WritableAtom<null, [move: SidebarResourceMove], Promise<void>> & {
-    init: null;
-}>;
-/** Replace the data. Reports through `onItemsChange`; writes the atom only
- * when no controlled `items` prop owns it. */
-export declare const setAISidebarItemsAtom: Family<import('jotai').WritableAtom<null, [items: SidebarResource[]], void> & {
-    init: null;
-}>;
-export declare const setAISidebarHoveredAtom: Family<import('jotai').WritableAtom<null, [rowId: string, hovered: boolean], void> & {
-    init: null;
-}>;
-export declare const clearAISidebarHoverAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-export declare const endAISidebarDragAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-/** @internal Publish the latest options; seed the instance once. */
-export declare const mountAISidebarAtom: Family<import('jotai').WritableAtom<null, [config: AISidebarConfig, seed: AISidebarSeed], void> & {
-    init: null;
-}>;
-/** @internal */
-export declare const setAISidebarHandlersAtom: Family<import('jotai').WritableAtom<null, [handlers: AISidebarHandlers], void> & {
-    init: null;
-}>;
-/** @internal One-way projections of controlled props — no callbacks fire. */
-export declare const projectAISidebarItemsAtom: Family<import('jotai').WritableAtom<null, [items: SidebarResource[]], void> & {
-    init: null;
-}>;
-/** @internal */
-export declare const projectAISidebarActiveIdAtom: Family<import('jotai').WritableAtom<null, [activeId: string | null], void> & {
-    init: null;
-}>;
-/** @internal */
-export declare const projectAISidebarExpandedIdsAtom: Family<import('jotai').WritableAtom<null, [expandedIds: string[]], void> & {
-    init: null;
-}>;
-/** Back to the values the instance mounted with. */
-export declare const resetAISidebarAtom: Family<import('jotai').WritableAtom<null, [], void> & {
-    init: null;
-}>;
-/** Drop every atom for `id`. `useAISidebar` calls this on unmount for
- * sidebars it keyed itself; an explicit `sidebarId` outlives its component,
- * so an app-named sidebar keeps its open rows across a route change. */
-export declare function removeAISidebarInstance(id: AISidebarInstanceId): void;
-export {};

package/dist-lib/src/components/blocks/nav/sidebar/ai-sidebar.d.ts

@@ -1,11 +0,0 @@
-import { AISidebarComponentProps } from './type';
-/**
- * Resource tree for the app rail: nested rows with drag-and-drop reorder,
- * inline rename, per-row action menus and full keyboard navigation.
- *
- * Two ways to drive it. Pass the data and handlers as props and the block
- * owns its state, or hold a `useAISidebar` controller and pass it as
- * `controller` — the same rendering, but select, expand, rename, reorder
- * and menu state are then callable from anywhere in your app.
- */
-export declare function AISidebar(props: AISidebarComponentProps): import("react").JSX.Element;

package/dist-lib/src/components/blocks/nav/sidebar/index.d.ts

@@ -1,15 +0,0 @@
-import { AISidebar } from './ai-sidebar';
-import { MarqueeLabel } from './marquee-label.tsx';
-import { ResourceRow } from './sidebar-row.tsx';
-import { SidebarIcon } from './sidebar-icon.tsx';
-export { useAISidebar, type UseAISidebarOptions } from './use-ai-sidebar.ts';
-export { useAISidebarActions, useAISidebarState, } from './use-ai-sidebar-state.ts';
-export type * from './type.ts';
-export { aiSidebarActiveIdAtom, aiSidebarAnnouncementAtom, aiSidebarDraggingIdAtom, aiSidebarDropTargetAtom, aiSidebarExpandedIdsAtom, aiSidebarFlatAtom, aiSidebarFocusedIdAtom, aiSidebarHoverActiveAtom, aiSidebarHoveredIdAtom, aiSidebarItemsAtom, aiSidebarMenuOpenIdAtom, aiSidebarMovePendingAtom, aiSidebarRenamingIdAtom, aiSidebarRowDraggingAtom, aiSidebarRowDropAtom, aiSidebarRowExpandedAtom, aiSidebarRowFocusedAtom, aiSidebarRowHoveredAtom, aiSidebarRowMenuOpenAtom, aiSidebarRowRenamingAtom, aiSidebarRowSelectedAtom, aiSidebarStateAtom, cancelAISidebarRenameAtom, clearAISidebarHoverAtom, closeAISidebarMenuAtom, collapseAISidebarRowAtom, collapseAllAISidebarRowsAtom, endAISidebarDragAtom, expandAISidebarRowAtom, expandAllAISidebarRowsAtom, focusAISidebarRowAtom, moveAISidebarRowAtom, openAISidebarMenuAtom, removeAISidebarInstance, renameAISidebarRowAtom, resetAISidebarAtom, revealAISidebarRowAtom, selectAISidebarRowAtom, setAISidebarHoveredAtom, setAISidebarItemsAtom, startAISidebarRenameAtom, toggleAISidebarRowAtom, } from './ai-sidebar-atom.ts';
-export { AISidebar, MarqueeLabel, ResourceRow, SidebarIcon };
-export declare const Sidebar: {
-    Wrapper: typeof AISidebar;
-    MarqueeLabel: typeof MarqueeLabel;
-    Row: import('react').MemoExoticComponent<({ row }: import('./type.ts').ResourceRowProps) => import("react").JSX.Element>;
-    Icon: typeof SidebarIcon;
-};

package/dist-lib/src/components/blocks/nav/sidebar/sidebar-context.d.ts

@@ -1,3 +0,0 @@
-import { AISidebarContextValue } from './type.ts';
-export declare const AISidebarContext: import('react').Context<AISidebarContextValue | null>;
-export declare function useAISidebarContext(): AISidebarContextValue;

package/dist-lib/src/components/blocks/nav/sidebar/sidebar-icon.d.ts

@@ -1,2 +0,0 @@
-import { SidebarResource } from './type.ts';
-export declare function SidebarIcon(item: SidebarResource, expanded: boolean): import("react").JSX.Element;

package/dist-lib/src/components/blocks/nav/sidebar/sidebar-row.d.ts

@@ -1,4 +0,0 @@
-import { ResourceRowProps } from './type';
-declare function ResourceRowImpl({ row }: ResourceRowProps): import("react").JSX.Element;
-export declare const ResourceRow: import('react').MemoExoticComponent<typeof ResourceRowImpl>;
-export {};

package/dist-lib/src/components/blocks/nav/sidebar/type.d.ts

@@ -1,245 +0,0 @@
-import { ReactElement, ReactNode, DragEvent, KeyboardEvent } from 'react';
-export type SidebarResourceKind = "folder" | "project" | "file" | "bookmark";
-export interface SidebarResource {
-    id: string;
-    label: string;
-    kind: SidebarResourceKind;
-    children?: SidebarResource[];
-    disabled?: boolean;
-}
-export type SidebarResourceDropPosition = "before" | "inside" | "after";
-export interface SidebarResourceMove {
-    itemId: string;
-    targetId: string | null;
-    position: SidebarResourceDropPosition;
-}
-export interface SidebarResourceMenuControls {
-    close: () => void;
-    rename: () => void;
-}
-/** Key for one sidebar's state in the store. Any stable string;
- * `useAISidebar` generates one when you don't pass it. */
-export type AISidebarInstanceId = string;
-/** Options for `useAISidebar`. `items`, `activeId` and `expandedIds` are
- * each controlled when passed and hook-owned via their `default*` twin
- * otherwise. */
-export interface UseAISidebarOptions {
-    /** Key this sidebar's state under a name your app can address —
-     * `useAISidebarState("app-resources")` / `useAISidebarActions(...)` reach
-     * it from anywhere under `ExegiaProvider`. Without one the hook generates
-     * a key and the state is dropped when the component unmounts. */
-    sidebarId?: AISidebarInstanceId;
-    items?: SidebarResource[];
-    defaultItems?: SidebarResource[];
-    onItemsChange?: (items: SidebarResource[]) => void;
-    /** Reject the promise to roll the optimistic move back. */
-    onMove?: (move: SidebarResourceMove) => void | Promise<void>;
-    onMoveError?: (error: unknown, move: SidebarResourceMove) => void;
-    onRename?: (item: SidebarResource, label: string) => void | Promise<void>;
-    activeId?: string | null;
-    defaultActiveId?: string | null;
-    onActiveChange?: (id: string) => void;
-    expandedIds?: string[];
-    defaultExpandedIds?: string[];
-    onExpandedChange?: (ids: string[]) => void;
-}
-/** Everything the sidebar can do, callable from outside the block — a
- * toolbar, a command palette, a route change. Returned by `useAISidebar`
- * and accepted by `<AISidebar controller={…} />`. */
-export interface AISidebarController {
-    /** The key this sidebar's state is stored under. */
-    sidebarId: AISidebarInstanceId;
-    items: SidebarResource[];
-    /** Visible rows in order, each with its depth and parent id. */
-    flat: FlatResource[];
-    getItem: (id: string) => SidebarResource | undefined;
-    selectedId: string | null;
-    select: (id: string) => void;
-    expandedIds: ReadonlySet<string>;
-    isExpanded: (id: string) => boolean;
-    expand: (id: string) => void;
-    collapse: (id: string) => void;
-    toggleExpanded: (id: string) => void;
-    expandAll: () => void;
-    collapseAll: () => void;
-    /** Open every ancestor of `id`, leaving the rest of the tree alone. */
-    reveal: (id: string) => void;
-    /** Roving-focus target. `focus` also moves DOM focus to the row. */
-    focusedId: string | null;
-    focus: (id: string) => void;
-    renamingId: string | null;
-    startRename: (id: string) => void;
-    cancelRename: () => void;
-    /** Commit a rename and leave rename mode. Applied optimistically and
-     * rolled back if `onRename` rejects. Blank and unchanged labels are
-     * dropped. */
-    rename: (id: string, label: string) => void;
-    menuOpenId: string | null;
-    openMenu: (id: string) => void;
-    closeMenu: () => void;
-    /** Reorder, applied optimistically and rolled back if `onMove` rejects.
-     * Refuses moves the data forbids (into itself, into a non-container). */
-    move: (move: SidebarResourceMove) => Promise<void>;
-    /** A move is in flight — further moves are refused until it settles. */
-    movePending: boolean;
-    /** Live-region text for the last move or rename outcome. */
-    announcement: string;
-    /** Back to the values the sidebar mounted with. */
-    reset: () => void;
-    /** @internal Row wiring the view threads through — drag state, the
-     * hover pill and roving keyboard nav all belong to the rendering. */
-    dnd: AISidebarDndState;
-    hover: AISidebarHoverState;
-    onRowKeyDown: (event: KeyboardEvent<HTMLDivElement>, row: FlatResource) => void;
-    setRowRef: (id: string, node: HTMLDivElement | null) => void;
-}
-/** @internal */
-export interface AISidebarDndState extends AISidebarRowDndHandlers {
-    draggingId: string | null;
-    dropTarget: DropTarget | null;
-    onRootDragOver: (event: DragEvent<HTMLDivElement>) => void;
-}
-/** @internal The drag handlers a row needs, stable for the life of the
- * sidebar — they read drag state out of the store when they run instead of
- * closing over it, so handing them to every row costs no re-renders. */
-export interface AISidebarRowDndHandlers {
-    onDrop: (event: DragEvent<HTMLDivElement>) => void;
-    onRowDragStart: (event: DragEvent<HTMLDivElement>, id: string) => void;
-    onRowDragEnd: () => void;
-    onRowDragOver: (event: DragEvent<HTMLDivElement>, row: FlatResource) => void;
-}
-/** @internal */
-export interface AISidebarHoverState {
-    hoveredId: string | null;
-    /** Shared motion layoutId that lets the pill travel between rows. */
-    layoutId: string;
-    onRowHover: (id: string, hovered: boolean) => void;
-    clear: () => void;
-}
-export interface AISidebarProps extends UseAISidebarOptions {
-    /** Never set on the data form — `controller` selects the other one. */
-    controller?: never;
-    renderIcon?: (item: SidebarResource) => ReactNode;
-    renderMenu?: (item: SidebarResource, controls: SidebarResourceMenuControls) => ReactNode;
-    /**
-     * Replaces the default "…" actions button. Must return a single element —
-     * the popover clones it to attach its trigger ref and click handler.
-     */
-    renderActionsTrigger?: (item: SidebarResource) => ReactElement;
-    ariaLabel?: string;
-    className?: string;
-}
-/** Presentational props, shared by both forms of `<AISidebar>`. */
-export type AISidebarViewProps = Pick<AISidebarProps, "renderIcon" | "renderMenu" | "renderActionsTrigger" | "ariaLabel" | "className">;
-/** Drive the block from a `useAISidebar` controller instead of raw props —
- * the controller carries the data and every handler. */
-export interface AISidebarControllerProps extends AISidebarViewProps {
-    controller: AISidebarController;
-}
-/** Either form: raw props, or a `useAISidebar` controller. */
-export type AISidebarComponentProps = AISidebarProps | AISidebarControllerProps;
-export interface FlatResource {
-    item: SidebarResource;
-    depth: number;
-    parentId: string | null;
-}
-export interface DropTarget {
-    id: string | null;
-    position: SidebarResourceDropPosition;
-}
-/** A row takes its place in the tree and nothing else: selection,
- * expansion, focus, rename, drag and hover state all arrive through its own
- * atoms, and the rendering options through the sidebar context. */
-export interface ResourceRowProps {
-    row: FlatResource;
-}
-/** @internal What a row needs from the block, threaded through context so
- * the rows stay prop-light.
- *
- * Deliberately free of sidebar state and of the controller. Rows read state
- * from per-row atoms, so this value keeps its identity for the life of the
- * sidebar and hovering or expanding one row no longer re-renders every row
- * through context. */
-export interface AISidebarContextValue {
-    sidebarId: AISidebarInstanceId;
-    /** Shared motion layoutId that lets the hover pill travel between rows. */
-    hoverLayoutId: string;
-    renderIcon?: AISidebarProps["renderIcon"];
-    renderMenu?: AISidebarProps["renderMenu"];
-    renderActionsTrigger?: AISidebarProps["renderActionsTrigger"];
-    /** Registers the row's DOM node with the block, which owns the ref map —
-     * DOM nodes never go in the store. */
-    setRowRef: (id: string, node: HTMLDivElement | null) => void;
-    onRowKeyDown: (event: KeyboardEvent<HTMLDivElement>, row: FlatResource) => void;
-    onRowHover: (id: string, hovered: boolean) => void;
-    /** Closing returns DOM focus to the row that owned the menu, so it goes
-     * through the block rather than the store. */
-    closeMenu: () => void;
-    dnd: AISidebarRowDndHandlers;
-}
-/** Everything observable about one sidebar, for consumers reading it by id. */
-export interface AISidebarState {
-    items: SidebarResource[];
-    /** Visible rows in order, each with its depth and parent id. */
-    flat: FlatResource[];
-    selectedId: string | null;
-    expandedIds: ReadonlySet<string>;
-    focusedId: string | null;
-    renamingId: string | null;
-    menuOpenId: string | null;
-    draggingId: string | null;
-    dropTarget: DropTarget | null;
-    hoveredId: string | null;
-    /** A move is in flight — further moves are refused until it settles. */
-    movePending: boolean;
-    /** Live-region text for the last move or rename outcome. */
-    announcement: string;
-}
-/** Everything doable to one sidebar from outside its component. */
-export interface AISidebarActions {
-    select: (id: string) => void;
-    expand: (id: string) => void;
-    collapse: (id: string) => void;
-    toggleExpanded: (id: string) => void;
-    expandAll: () => void;
-    collapseAll: () => void;
-    reveal: (id: string) => void;
-    /** Moves the roving-focus target. DOM focus follows only for callers that
-     * hold the controller — the ref map lives in the block, not the store. */
-    focus: (id: string) => void;
-    startRename: (id: string) => void;
-    cancelRename: () => void;
-    rename: (id: string, label: string) => void;
-    openMenu: (id: string) => void;
-    closeMenu: () => void;
-    move: (move: SidebarResourceMove) => Promise<void>;
-    setItems: (items: SidebarResource[]) => void;
-    reset: () => void;
-}
-/** @internal Projection of `useAISidebar`'s options — primitives only, so
- * the store write runs once per real change instead of once per render. */
-export interface AISidebarConfig {
-    controlsItems: boolean;
-    controlsActiveId: boolean;
-    controlsExpandedIds: boolean;
-}
-/** @internal Latest option callbacks. Only write atoms read this, so it can
- * be refreshed every commit without re-rendering anything. */
-export interface AISidebarHandlers {
-    onItemsChange?: (items: SidebarResource[]) => void;
-    onMove?: (move: SidebarResourceMove) => void | Promise<void>;
-    onMoveError?: (error: unknown, move: SidebarResourceMove) => void;
-    onRename?: (item: SidebarResource, label: string) => void | Promise<void>;
-    onActiveChange?: (id: string) => void;
-    onExpandedChange?: (ids: string[]) => void;
-}
-/** @internal What an instance starts from, replayed by
- * `resetAISidebarAtom`. */
-export interface AISidebarSeed {
-    items: SidebarResource[];
-    /** Hook-owned selection — the `defaultActiveId`, never the controlled
-     * `activeId`. */
-    activeId: string | null;
-    focusedId: string | null;
-    expandedIds: string[];
-}

package/dist-lib/src/components/blocks/nav/sidebar/use-ai-sidebar-state.d.ts

@@ -1,29 +0,0 @@
-import { AISidebarActions, AISidebarInstanceId, AISidebarState } from './type.ts';
-/**
- * Read the sidebar registered under `sidebarId` from anywhere below
- * `ExegiaProvider` — no controller, no props, no provider of its own.
- *
- * ```tsx
- * const { selectedId, movePending } = useAISidebarState("app-resources")
- * ```
- *
- * This returns the whole state object, so the caller re-renders on any
- * change. A component that reads one field should subscribe to that field's
- * atom instead: `useAtomValue(aiSidebarActiveIdAtom("app-resources"))`.
- */
-export declare function useAISidebarState(sidebarId: AISidebarInstanceId): AISidebarState;
-/**
- * Drive the sidebar registered under `sidebarId` from anywhere. Writes only —
- * the caller never re-renders when the sidebar changes, so this is what a
- * command palette, a keyboard shortcut or a route guard should reach for.
- *
- * `focus` and `closeMenu` move the store's roving target; DOM focus follows
- * only for callers that hold the controller, because the row refs live in
- * the block rather than the store.
- *
- * ```tsx
- * const resources = useAISidebarActions("app-resources")
- * <Button onClick={resources.collapseAll}>Collapse all</Button>
- * ```
- */
-export declare function useAISidebarActions(sidebarId: AISidebarInstanceId): AISidebarActions;

package/dist-lib/src/components/blocks/nav/sidebar/use-ai-sidebar.d.ts

@@ -1,27 +0,0 @@
-import { AISidebarController, UseAISidebarOptions } from './type.ts';
-export type { UseAISidebarOptions };
-/**
- * The AI sidebar's headless controller — every behaviour the block
- * performs, callable from outside it: select, expand/collapse (one row,
- * every row, or just the ancestors of one), move focus, rename, open a
- * row's action menu, reorder.
- *
- * `items`, `activeId` and `expandedIds` are each controlled when passed
- * and hook-owned via their `default*` twin otherwise. Reorder and rename
- * are applied to the data optimistically and rolled back if
- * `onMove`/`onRename` rejects, so a consumer never reduces the tree
- * itself — `moveResource` and `renameResource` are exported for the ones
- * who keep their data elsewhere.
- *
- * ```tsx
- * const sidebar = useAISidebar({ defaultItems: resources })
- * <AISidebar controller={sidebar} />
- * <Button onClick={sidebar.collapseAll}>Collapse all</Button>
- * ```
- *
- * State lives in Jotai atoms keyed by `sidebarId`, so anything under
- * `ExegiaProvider` can drive this sidebar without the controller — name it
- * and reach for `useAISidebarState(sidebarId)` /
- * `useAISidebarActions(sidebarId)` elsewhere.
- */
-export declare function useAISidebar(options: UseAISidebarOptions): AISidebarController;

package/dist-lib/src/components/blocks/nav/sidebar/utils.d.ts

@@ -1,21 +0,0 @@
-import { FlatResource, SidebarResource, SidebarResourceDropPosition, SidebarResourceMove } from './type.ts';
-export declare const ROW_REVEAL: {
-    readonly duration: 0.16;
-    readonly ease: readonly [0.16, 1, 0.3, 1];
-};
-export declare function canContain(item: SidebarResource): boolean;
-export declare function flattenResources(items: SidebarResource[], expanded: ReadonlySet<string>, depth?: number, parentId?: string | null): FlatResource[];
-export declare function findResource(items: SidebarResource[], id: string): SidebarResource | undefined;
-/** Ids of every ancestor of `id` (nearest last); empty when absent. */
-export declare function ancestorIdsOf(items: SidebarResource[], id: string): string[];
-/** Ids of every row that can hold children and has some — the set
- * `expandAll` opens. */
-export declare function expandableIdsOf(items: SidebarResource[]): string[];
-export declare function containsResource(item: SidebarResource, id: string): boolean;
-export declare function removeResource(items: SidebarResource[], id: string): {
-    items: SidebarResource[];
-    removed?: SidebarResource;
-};
-export declare function insertResource(items: SidebarResource[], resource: SidebarResource, targetId: string | null, position: SidebarResourceDropPosition): SidebarResource[];
-export declare function moveResource(items: SidebarResource[], move: SidebarResourceMove): SidebarResource[] | null;
-export declare function renameResource(items: SidebarResource[], id: string, label: string): SidebarResource[];

package/dist-lib/src/components/blocks/profile/index.d.ts

@@ -1,7 +0,0 @@
-export { ProfileCardBlock, defaultProfileCardItems, } from './profile-card-block';
-export type { ProfileCardBlockProps } from './profile-card-block';
-export { useProfileCard } from './use-profile-card';
-export type { ProfileCardBinding, UseProfileCardOptions } from './use-profile-card';
-export { useProfileCardActions, useProfileCardState, } from './use-profile-card-state';
-export { profileCardBusyAtom, profileCardCollapsedAtom, profileCardMenuOpenAtom, profileCardPendingActionIdAtom, profileCardStateAtom, profileCardVariantAtom, removeProfileCardInstance, resetProfileCardAtom, selectProfileCardActionAtom, setProfileCardMenuOpenAtom, setProfileCardVariantAtom, toggleProfileCardVariantAtom, } from './profile-card-atom';
-export type * from './type';