@exegia/corpora-ui 1.0.0 → 3.0.0

package/dist-lib/components/composed/tree/type.d.ts

@@ -0,0 +1,290 @@
+import type * as React from "react";
+/** One node in the tree. Nesting depth carries meaning per variant — see
+ * `TreeProps["variant"]`. */
+export interface ITreeNode {
+    id: string;
+    label: string;
+    /** Leading icon. Required in practice for `sidebar` — it is all that
+     * remains of a row while the rail is collapsed. */
+    icon?: React.ReactNode;
+    /** Route metadata for the consumer's `onNavigate` — every row renders as
+     * a button, so this is never turned into an anchor element. Read it (with
+     * `target`) off the node your handler receives. One native behaviour is
+     * kept: `toc` rows below the route level jump to `#{id}` after select
+     * (a `#hash` href overrides the id; a non-hash href disables the jump). */
+    href?: string;
+    target?: "_blank" | "_self" | "_parent" | "_top";
+    disabled?: boolean;
+    /** Start expanded. Ancestors of `activeId` expand regardless. */
+    defaultOpen?: boolean;
+    /** Trailing hint — a count, a "New" pill. */
+    badge?: React.ReactNode;
+    /** Fires on selection, before the tree-level `onNavigate`. */
+    onSelect?: () => void;
+    children?: ITreeNode[];
+}
+export type TTreeVariant = "navigation" | "toc" | "sidebar" | "files";
+/** Where a dragged row lands relative to its drop target. */
+export type TTreeDropPosition = "before" | "after" | "inside";
+/** Key for one tree’s state in the store. Any stable string; `useTree`
+ * generates one when you don't pass it. */
+export type TTreeInstanceId = string;
+/** Row a drag hovers, and where the drop would land. */
+export interface ITreeDropTarget {
+    id: string;
+    position: TTreeDropPosition;
+}
+interface ITreeBaseProps {
+    items: ITreeNode[];
+    /** Key this tree's state under a name your app can address —
+     * `useTreeState("app-nav")` / `useTreeActions("app-nav")` reach it from
+     * anywhere under `ExegiaProvider`. Without one the tree generates a key
+     * and its state is dropped when it unmounts. */
+    treeId?: TTreeInstanceId;
+    /** Never set on the data form — `tree` selects the controller form. */
+    tree?: never;
+    /** `id` of the current entry — matches any depth. Its ancestors expand. */
+    activeId?: string;
+    /** Fires for every selection (rows and leaves alike), after the node's
+     * own `onSelect`. Rows are buttons, so this is the routing path — wire
+     * your router's navigate here. `toc` rows below the route level still jump
+     * to `#{id}` natively, after this fires. */
+    onNavigate?: (node: ITreeNode) => void;
+    /** Expand/collapse cues. Silent until `bindSounds()`. */
+    sound?: boolean;
+    ariaLabel?: string;
+    className?: string;
+}
+interface ITreeReadonlyProps {
+    collapsed?: never;
+    onMove?: never;
+    onRename?: never;
+    renderTrailing?: never;
+}
+/** Drive the tree from a `useTree` controller instead of raw props. The
+ * controller carries the variant, the data and every handler; only the
+ * presentational props stay here. */
+export interface ITreeControllerProps {
+    tree: ITreeController;
+    items?: never;
+    ariaLabel?: string;
+    className?: string;
+    /** Row actions revealed on hover/focus (`files` only — ignored by the
+     * other variants, which the controller form cannot type-gate). */
+    renderTrailing?: (node: ITreeNode) => React.ReactNode;
+}
+/** Either form: raw props, or a `useTree` controller via `tree`. */
+export type TTreeProps = TTreeDataProps | ITreeControllerProps;
+/** The four shapes a Tree takes. Editing props only exist on `files`;
+ * `collapsed` only on `sidebar` — the union is the contract. */
+export type TTreeDataProps = ITreeBaseProps & (({
+    /** Nested app navigation. With 3 levels of nodes the top level
+     * becomes collapsible section names (styled as headings, not
+     * rows); with 2 it renders plain selectable rows. */
+    variant: "navigation";
+} & ITreeReadonlyProps) | ({
+    /** Table of contents: top-level nodes are routes (handled in
+     * `onNavigate`); rows below jump to `#{id}` after select, like an
+     * anchor would. Parents select on the row and expand from a
+     * separate overlay chevron. */
+    variant: "toc";
+} & ITreeReadonlyProps) | ({
+    /** Single-level icon rail. `collapsed` shrinks rows to their
+     * leading icon; nested children are ignored. */
+    variant: "sidebar";
+    collapsed?: boolean;
+} & Omit<ITreeReadonlyProps, "collapsed">) | {
+    /** File explorer: only leaves navigate, folders toggle. Compact
+     * spacing; rename, drag-and-drop and trailing actions enabled. */
+    variant: "files";
+    /** Enables drag-and-drop. Reorder `items` yourself: `parentId`
+     * `null` means the root list, `index` is the slot among the new
+     * siblings (computed on the list without the dragged node). */
+    onMove?: (id: string, parentId: string | null, index: number) => void;
+    /** Enables inline rename (double-click or F2). */
+    onRename?: (id: string, label: string) => void;
+    /** Row actions revealed on hover/focus — a menu, a delete icon. */
+    renderTrailing?: (node: ITreeNode) => React.ReactNode;
+    collapsed?: never;
+});
+/** Options for `useTree`. Each of `items`, `activeId` and `collapsed` is
+ * controlled when passed and hook-owned when its `default*` twin is used
+ * instead. */
+export interface IUseTreeOptions {
+    /** Key this tree's state under a name your app can address —
+     * `useTreeState("app-nav")` / `useTreeActions("app-nav")` reach it from
+     * anywhere under `ExegiaProvider`. Without one the hook generates a key
+     * and the state is dropped when the component unmounts. */
+    treeId?: TTreeInstanceId;
+    /** Which shape the tree takes — gates rename/reorder (`files`) and the
+     * collapsible rail (`sidebar`). */
+    variant: TTreeVariant;
+    /** Controlled data. With it, `rename`/`move` only report the edit unless
+     * you also pass `onItemsChange`. */
+    items?: ITreeNode[];
+    /** Hook-owned data — `rename` and `move` apply the edit themselves. */
+    defaultItems?: ITreeNode[];
+    /** Next tree after a `rename`/`move`. Also enables self-applying edits
+     * on top of controlled `items`. */
+    onItemsChange?: (items: ITreeNode[]) => void;
+    /** Controlled selection. Ancestors of the active node expand. */
+    activeId?: string;
+    defaultActiveId?: string;
+    /** Fires for every selection (rows and leaves alike), after the node's
+     * own `onSelect` — wire your router's navigate here. */
+    onNavigate?: (node: ITreeNode) => void;
+    /** Start with these ids expanded instead of the `defaultOpen` set. */
+    defaultExpandedIds?: Iterable<string>;
+    onExpandedChange?: (ids: string[]) => void;
+    /** Controlled rail fold (`sidebar` only). */
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Enables rename (`files`). Not needed when the hook owns the data. */
+    onRename?: (id: string, label: string) => void;
+    /** Enables drag-and-drop (`files`). `parentId` `null` means the root
+     * list, `index` is the slot among the new siblings (computed on the list
+     * without the moved node). Not needed when the hook owns the data. */
+    onMove?: (id: string, parentId: string | null, index: number) => void;
+    /** Expand/collapse cues. Silent until `bindSounds()`. */
+    sound?: boolean;
+}
+/** Everything the tree can do, callable from outside the component.
+ * Returned by `useTree` and accepted by `<Tree tree={…} />`. */
+export interface ITreeController {
+    /** The key this tree's state is stored under. */
+    treeId: TTreeInstanceId;
+    variant: TTreeVariant;
+    items: ITreeNode[];
+    /** `navigation` with 3 levels of nodes — depth 0 renders as sections. */
+    sectioned: boolean;
+    /** Ids of the section headings, empty unless `sectioned`. Pass one to
+     * `expand`/`collapse`/`toggleExpanded` to work a whole section. */
+    sectionIds: string[];
+    sound: boolean;
+    getNode: (id: string) => ITreeNode | null;
+    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;
+    /** Rail folded to icons — always `false` outside `sidebar`. */
+    collapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+    toggleCollapsed: () => void;
+    activeId?: string;
+    /** Select a node: runs its `onSelect`, then `onNavigate`. Inert on
+     * disabled and unknown nodes. */
+    select: (id: string) => void;
+    /** Whether rename is wired up at all (`files` + a handler or owned data). */
+    canRename: boolean;
+    /** Rename target id, `null` while idle. */
+    renamingId: string | null;
+    startRename: (id: string) => void;
+    cancelRename: () => void;
+    /** Commit a rename and leave rename mode. Blank or unchanged labels are
+     * dropped. */
+    rename: (id: string, label: string) => void;
+    /** Whether reorder is wired up at all. */
+    canMove: boolean;
+    move: (id: string, parentId: string | null, index: number) => void;
+    /** Back to the values the tree mounted with. */
+    reset: () => void;
+    dnd: ITreeDndContextValue;
+}
+/** @internal What a row needs from the root, threaded through context so
+ * the recursive rows stay prop-light.
+ *
+ * Deliberately free of tree state. Rows read state from per-node atoms, so
+ * this value keeps its identity for the life of the tree and expanding one
+ * branch no longer re-renders every row through context. */
+export interface ITreeContextValue {
+    treeId: TTreeInstanceId;
+    renderTrailing?: (node: ITreeNode) => React.ReactNode;
+    dnd: ITreeDndHandlers;
+}
+/** @internal The drag event handlers, stable for the life of the tree —
+ * they read drag state out of the store instead of closing over it, so
+ * handing them to every row costs no re-renders. */
+export interface ITreeDndHandlers {
+    enabled: boolean;
+    onRowDragStart: (event: React.DragEvent, id: string) => void;
+    onRowDragOver: (event: React.DragEvent, node: ITreeNode) => void;
+    onRowDragLeave: (event: React.DragEvent) => void;
+    onRowDrop: (event: React.DragEvent, node: ITreeNode) => void;
+    onRowDragEnd: () => void;
+}
+/** @internal Handlers plus live drag state — what `TreeController.dnd`
+ * exposes (all `null`/no-op outside `files`). */
+export interface ITreeDndContextValue extends ITreeDndHandlers {
+    draggedId: string | null;
+    /** Row the pointer is over and where the drop would land. */
+    dropTarget: ITreeDropTarget | null;
+}
+/** Everything observable about one tree, for consumers reading it by id. */
+export interface ITreeState {
+    variant: TTreeVariant;
+    items: ITreeNode[];
+    activeId?: string;
+    expandedIds: ReadonlySet<string>;
+    collapsed: boolean;
+    renamingId: string | null;
+    sectioned: boolean;
+    sectionIds: string[];
+    canRename: boolean;
+    canMove: boolean;
+    draggedId: string | null;
+    dropTarget: ITreeDropTarget | null;
+}
+/** Everything doable to one tree from outside its component. */
+export interface ITreeActions {
+    expand: (id: string) => void;
+    collapse: (id: string) => void;
+    toggleExpanded: (id: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    reveal: (id: string) => void;
+    setCollapsed: (collapsed: boolean) => void;
+    toggleCollapsed: () => void;
+    select: (id: string) => void;
+    startRename: (id: string) => void;
+    cancelRename: () => void;
+    rename: (id: string, label: string) => void;
+    move: (id: string, parentId: string | null, index: number) => void;
+    setItems: (items: ITreeNode[]) => void;
+    reset: () => void;
+}
+/** @internal Projection of `useTree`'s options — primitives only, so the
+ * store write runs once per real change instead of once per render. */
+export interface ITreeConfig {
+    variant: TTreeVariant;
+    sound: boolean;
+    controlsItems: boolean;
+    controlsActiveId: boolean;
+    controlsCollapsed: boolean;
+    managesItems: boolean;
+    hasRenameHandler: boolean;
+    hasMoveHandler: boolean;
+}
+/** @internal Latest option callbacks. Only write atoms read this, so it
+ * can be refreshed every commit without re-rendering anything. */
+export interface ITreeHandlers {
+    onNavigate?: (node: ITreeNode) => void;
+    onItemsChange?: (items: ITreeNode[]) => void;
+    onExpandedChange?: (ids: string[]) => void;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    onRename?: (id: string, label: string) => void;
+    onMove?: (id: string, parentId: string | null, index: number) => void;
+}
+/** @internal What an instance starts from, replayed by `resetTreeAtom`. */
+export interface ITreeSeed {
+    items: ITreeNode[];
+    activeId?: string;
+    collapsed: boolean;
+    expandedIds?: string[];
+}
+export {};

package/dist-lib/components/composed/tree/use-tree-dnd.d.ts

@@ -0,0 +1,18 @@
+import { ITreeDndContextValue, ITreeDndHandlers, TTreeInstanceId } from './type';
+/**
+ * The drag handlers for the `files` variant, stable for the life of the tree.
+ *
+ * Nothing here subscribes to drag state: items, the dragged id and the drop
+ * target are read out of the store when a handler runs. That is what lets
+ * every row share one handler object without re-rendering when a drag moves —
+ * and it keeps `useTree` from subscribing to data it also projects from
+ * props, which would loop on an inline `items` array.
+ *
+ * Inert unless the tree `canMove`. `dataTransfer` is set for interop but
+ * never read, so the flow also works where the store is unavailable (tests,
+ * some webviews).
+ */
+export declare function useTreeDndHandlers(treeId: TTreeInstanceId): ITreeDndHandlers;
+/** The handlers plus live drag state, for `TreeController.dnd`. Rows take the
+ * handlers alone and read the state per node instead. */
+export declare function useTreeDnd(treeId: TTreeInstanceId): ITreeDndContextValue;

package/dist-lib/components/composed/tree/use-tree-state.d.ts

@@ -0,0 +1,25 @@
+import { ITreeActions, TTreeInstanceId, ITreeState } from './type';
+/**
+ * Read the tree registered under `treeId` from anywhere below
+ * `ExegiaProvider` — no controller, no props, no provider of its own.
+ *
+ * ```tsx
+ * const { collapsed, activeId } = useTreeState("app-nav")
+ * ```
+ *
+ * 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(treeCollapsedAtom("app-nav"))`.
+ */
+export declare function useTreeState(treeId: TTreeInstanceId): ITreeState;
+/**
+ * Drive the tree registered under `treeId` from anywhere. Writes only — the
+ * caller never re-renders when the tree changes, so this is what a command
+ * palette, a keyboard shortcut or a route guard should reach for.
+ *
+ * ```tsx
+ * const nav = useTreeActions("app-nav")
+ * <Button onClick={nav.collapseAll}>Collapse all</Button>
+ * ```
+ */
+export declare function useTreeActions(treeId: TTreeInstanceId): ITreeActions;

package/dist-lib/components/composed/tree/use-tree.d.ts

@@ -0,0 +1,24 @@
+import { ITreeController, IUseTreeOptions } from './type';
+/**
+ * The tree's headless controller — every behaviour the component exposes,
+ * callable from outside it: expand/collapse (a node, a section, the whole
+ * tree), fold the `sidebar` rail, select a node, rename, reorder.
+ *
+ * Each piece of state is controlled-or-uncontrolled in the usual React
+ * shape: pass `items`/`activeId`/`collapsed` to own it yourself, or
+ * `defaultItems`/`defaultActiveId`/`defaultCollapsed` to let the hook. When
+ * the hook owns `items` (or you pass `onItemsChange`), `rename` and `move`
+ * apply the edit to the data themselves — otherwise they only report it
+ * through `onRename`/`onMove` and you reduce the tree yourself.
+ *
+ * ```tsx
+ * const tree = useTree({ variant: "files", defaultItems: files })
+ * <Tree tree={tree} />
+ * <Button onClick={tree.collapseAll}>Collapse all</Button>
+ * ```
+ *
+ * State lives in Jotai atoms keyed by `treeId`, so anything under
+ * `ExegiaProvider` can drive this tree without the controller — name it and
+ * reach for `useTreeState(treeId)` / `useTreeActions(treeId)` elsewhere.
+ */
+export declare function useTree(options: IUseTreeOptions): ITreeController;

package/dist-lib/components/composed/tree/utils.d.ts

@@ -0,0 +1,28 @@
+import { ITreeNode } from './type';
+/** Depth-0 nodes read as sections only when the data actually nests three
+ * levels — a two-level tree keeps its top level as plain link rows. */
+export declare function hasThreeLevels(items: readonly ITreeNode[]): boolean;
+/** Ids of every ancestor of `id` (nearest last); empty when absent. */
+export declare function ancestorIdsOf(items: readonly ITreeNode[], id: string): string[];
+/** Ids that start expanded: `defaultOpen` nodes plus every ancestor of the
+ * active entry, so the current location is never folded away. */
+export declare function initialExpandedIds(items: readonly ITreeNode[], activeId?: string): Set<string>;
+/** Ids of every node that can hold children — the set `expandAll` opens.
+ * In `files` an empty `children: []` still counts (it is a folder). */
+export declare function expandableIdsOf(items: readonly ITreeNode[], filesVariant?: boolean): string[];
+/** Immutably relabel `id`. Returns the same array reference when absent. */
+export declare function renameNode(items: readonly ITreeNode[], id: string, label: string): ITreeNode[];
+/** Whether `candidateId` is `id` itself or nests anywhere under it — the
+ * guard that keeps a folder from being dropped into its own subtree. */
+export declare function containsNode(items: readonly ITreeNode[], id: string, candidateId: string): boolean;
+export declare function findNode(items: readonly ITreeNode[], id: string): ITreeNode | null;
+/** Parent id (`null` at root) and index of `id` among its siblings. */
+export declare function locateNode(items: readonly ITreeNode[], id: string): {
+    parentId: string | null;
+    index: number;
+} | null;
+/** Immutably lift `id` out of the tree and reinsert it under `parentId`
+ * (`null` = root) at `index` — the standard `onMove` reducer, exported so
+ * consumers don't each rebuild it. `index` addresses the sibling list
+ * *after* the node has been lifted out. */
+export declare function moveNode(items: readonly ITreeNode[], id: string, parentId: string | null, index: number): ITreeNode[];

package/dist-lib/components/composed/types.d.ts

@@ -0,0 +1,7 @@
+export type TSocialProvider = "google" | "apple" | "github" | "x";
+export type * from './action-bar/types';
+export type * from './ai/types';
+export type * from './chat/flowchart/types';
+export type * from './chat/recommendation/types';
+export type * from './user/types';
+export type * from './verse/types';

package/dist-lib/components/composed/user/index.d.ts

@@ -0,0 +1,11 @@
+import { Info } from './info';
+import { Message } from './message';
+import { Pill } from './pill';
+import { TUserInfoProps, TUserPillProps } from './types';
+declare const User: {
+    Info: typeof Info;
+    Message: typeof Message;
+    Pill: typeof Pill;
+};
+export type { TUserInfoProps, TUserPillProps };
+export default User;

package/dist-lib/components/composed/user/info.d.ts

@@ -0,0 +1,12 @@
+import { TUserInfoProps } from './types';
+/**
+ * This component displays a user's information in a compact format.
+ * that can be used to display a user's name and role,
+ * in the chat bubble header or sidebar profile.
+ * @param {TUserInfoProps['user']} user - The user to display.
+ * @param {TUserInfoProps['description']} description - The description to display.
+ *
+ * @description Displays a user's name and role in a compact format.
+ *
+ */
+export declare function Info({ user, description, direction, audio, size, }: TUserInfoProps): import("react").JSX.Element;

package/dist-lib/components/composed/user/message.d.ts

@@ -0,0 +1,2 @@
+import { IUserMessageProps } from './types';
+export declare function Message({ children, user, size, continued, className, reactions, actions, }: IUserMessageProps): import("react").JSX.Element;

package/dist-lib/components/composed/user/pill.d.ts

@@ -0,0 +1,10 @@
+import { TUserPillProps } from './types';
+/**
+ * This component displays a user's information in a compact format.
+ * that can be used to display a user's name and role,
+ * in the chat bubble header or sidebar profile.
+ * @param {TUserPillProps['user']} user - The user to display.
+ * @description Displays a user's name and role in a compact format.
+ *
+ */
+export declare function Pill({ user }: TUserPillProps): import("react").JSX.Element;

package/dist-lib/components/composed/user/types.d.ts

@@ -0,0 +1,27 @@
+import { TUserType, IAvatarProps } from '../../atoms/types';
+import { IBubbleReactionsProps, TBubbleVariant } from '../../atoms/bubble';
+import { default as React } from 'react';
+export type TUserInfo<T extends TUserType> = T & {
+    description?: string;
+    audio?: IAvatarProps<T>["audio"];
+    size?: IAvatarProps<T>["size"];
+    direction?: Exclude<TBubbleVariant, "ai">;
+};
+export type TUserVariant = "pill" | "info";
+export interface IUserBaseProps<T extends TUserType, Variant extends TUserVariant = TUserVariant> {
+    user: T;
+    variant: Variant;
+}
+export interface IUserMessageProps<T extends TUserType = TUserType> extends Omit<IUserBaseProps<T>, "user"> {
+    children: React.ReactNode;
+    size?: IAvatarProps<T>["size"];
+    user?: TUserInfo<T>;
+    continued?: boolean;
+    className?: string;
+    /** Reaction controls rendered beside the message, outside its surface. */
+    reactions?: IBubbleReactionsProps;
+    /** Optional message actions, typically composed with Bubble.Actions. */
+    actions?: React.ReactNode;
+}
+export type TUserInfoProps<T extends TUserType = TUserType> = Exclude<IUserBaseProps<T, "info">, "variant"> & TUserInfo<T>;
+export type TUserPillProps<T extends TUserType = TUserType> = Exclude<IUserBaseProps<T, "pill">, "variant" | "size">;

package/dist-lib/components/composed/verse/index.d.ts

@@ -0,0 +1,2 @@
+export { Verse, VerseNote, VerseSpan } from './verse';
+export type { TVerseNoteProps, IVerseProps, TVerseSpanProps } from './types';

package/dist-lib/components/composed/verse/types.d.ts

@@ -0,0 +1,18 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { TTextSize } from '../../atoms/text/types';
+import { ITextClickPopoverProps } from '../../atoms/text-selection/types';
+export interface IVerseProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    children?: ReactNode;
+    className?: string;
+    /** Chapter reference rendered as a leading link, e.g. "3:16". */
+    chapter?: ReactNode;
+    /** Destination of the chapter link. */
+    href?: string;
+    /** Popover content opened by clicking the chapter link. */
+    chapterPopover?: ITextClickPopoverProps["popover"];
+    renderChapterPopover?: ITextClickPopoverProps["renderPopover"];
+    /** Type scale shared with nested verse spans and notes. */
+    size?: TTextSize;
+}
+export type TVerseSpanProps = Omit<ITextClickPopoverProps, "type">;
+export type TVerseNoteProps = Omit<ITextClickPopoverProps, "type">;

package/dist-lib/components/composed/verse/verse.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+import { TVerseNoteProps, IVerseProps, TVerseSpanProps } from './types';
+export declare function Verse({ chapter, chapterPopover, children, className, href, renderChapterPopover, size, ...props }: IVerseProps): ReactElement;
+export declare function VerseSpan({ className, size, ...props }: TVerseSpanProps): ReactElement;
+export declare function VerseNote({ className, size, ...props }: TVerseNoteProps): ReactElement;

package/dist-lib/components/docs/atoms-gallery.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+export declare function GalleryTile({ href, name, blurb, className, stageClassName, children, index, }: {
+    href: string;
+    name: string;
+    blurb: string;
+    className?: string;
+    stageClassName?: string;
+    children: React.ReactNode;
+    index: number;
+}): React.JSX.Element;
+export declare function AtomsGallery(): React.JSX.Element;
+export default AtomsGallery;

package/dist-lib/components/docs/block-demo-stage.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+/** Block examples keep controls in normal flow so they never cover the preview. */
+export declare function BlockDemoStage({ controls, children, canvasClassName, }: {
+    controls?: ReactNode;
+    children: ReactNode;
+    canvasClassName?: string;
+}): import("react").JSX.Element;

package/dist-lib/components/docs/blocks-gallery.d.ts

@@ -0,0 +1,2 @@
+/** The same live gallery tiles used by atoms and composed components. */
+export declare function BlocksGallery(): import("react").JSX.Element;

package/dist-lib/components/docs/browser.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+export type TTitleStyleType = "hidden" | "titlebar" | "expanded";
+export interface IBrowserProps {
+    url?: string;
+    title?: string;
+    className?: string;
+    children: ReactNode;
+    titleStyle: TTitleStyleType;
+}
+export declare function BrowserFrame({ url, title, className, titleStyle, children, }: IBrowserProps): import("react").JSX.Element;

package/dist-lib/components/docs/components-gallery.d.ts

@@ -0,0 +1,2 @@
+export declare function ComponentsGallery(): import("react").JSX.Element;
+export default ComponentsGallery;

package/dist-lib/components/docs/demo-controls.d.ts

@@ -0,0 +1,21 @@
+import type * as React from "react";
+/** Lightweight controls for docs demos; never part of the npm surface. */
+export declare function DemoSelect<T extends string>({ label, value, options, onChange, }: {
+    label?: string;
+    value: T;
+    options: readonly T[];
+    onChange: (value: T) => void;
+}): React.JSX.Element;
+/** Stand-in brand mark for demos of a block's logo slot. */
+export declare function DemoBrandMark(): React.JSX.Element;
+export declare function DemoToggle({ label, checked, onChange, }: {
+    label: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+}): React.JSX.Element;
+/** Standard layout for live examples. */
+export declare function DemoStage({ controls, children, canvasClassName, }: {
+    controls?: React.ReactNode;
+    children: React.ReactNode;
+    canvasClassName?: string;
+}): React.JSX.Element;

package/dist-lib/components/icons/__tests__/icons.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-lib/components/icons/file-badge-cfm.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * CFM file icon — badge variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileBadgeCfm({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileBadgeCfm;

package/dist-lib/components/icons/file-badge-corpus.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * Corpus file icon — badge variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileBadgeCorpus({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileBadgeCorpus;

package/dist-lib/components/icons/file-badge-pdf.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * PDF file icon — badge variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileBadgePdf({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileBadgePdf;

package/dist-lib/components/icons/file-badge-tei.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * TEI file icon — badge variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileBadgeTei({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileBadgeTei;

package/dist-lib/components/icons/file-badge-tf.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * TF file icon — badge variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileBadgeTf({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileBadgeTf;

package/dist-lib/components/icons/file-badge-txt.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * TXT file icon — badge variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileBadgeTxt({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileBadgeTxt;

package/dist-lib/components/icons/file-badge-xml.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * XML file icon — badge variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileBadgeXml({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileBadgeXml;

package/dist-lib/components/icons/file-wordmark-cfm.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * CFM file icon — wordmark variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileWordmarkCfm({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileWordmarkCfm;

package/dist-lib/components/icons/file-wordmark-corpus.d.ts

@@ -0,0 +1,7 @@
+import { IFileIconProps } from './types';
+/**
+ * Corpus file icon — wordmark variant.
+ * Light/dark artwork layers switch on Tailwind's `dark` variant.
+ */
+export declare function FileWordmarkCorpus({ size, title, className, ...props }: IFileIconProps): import("react").JSX.Element;
+export default FileWordmarkCorpus;