@danxbot/ui 2.1.1 → 2.2.1

package/dist/types/components/RecordCard.d.ts

@@ -0,0 +1,153 @@
+import type { ReactNode, Ref } from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "tailwind-variants";
+declare const record: import("tailwind-variants").TVReturnType<{
+    emphasis: {
+        none: {
+            root: string;
+        };
+        accent: {
+            root: string;
+        };
+        warning: {
+            root: string;
+        };
+        danger: {
+            root: string;
+        };
+    };
+    interactive: {
+        true: {
+            root: string[];
+        };
+        false: {};
+    };
+    selected: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    top: string;
+    identifier: string;
+    title: string;
+    subtitle: string;
+    badges: string;
+    metrics: string;
+    metricLabel: string;
+    metricValue: string;
+    footer: string;
+}, undefined, {
+    emphasis: {
+        none: {
+            root: string;
+        };
+        accent: {
+            root: string;
+        };
+        warning: {
+            root: string;
+        };
+        danger: {
+            root: string;
+        };
+    };
+    interactive: {
+        true: {
+            root: string[];
+        };
+        false: {};
+    };
+    selected: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    top: string;
+    identifier: string;
+    title: string;
+    subtitle: string;
+    badges: string;
+    metrics: string;
+    metricLabel: string;
+    metricValue: string;
+    footer: string;
+}, import("tailwind-variants").TVReturnTypeLike<{
+    emphasis: {
+        none: {
+            root: string;
+        };
+        accent: {
+            root: string;
+        };
+        warning: {
+            root: string;
+        };
+        danger: {
+            root: string;
+        };
+    };
+    interactive: {
+        true: {
+            root: string[];
+        };
+        false: {};
+    };
+    selected: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    top: string;
+    identifier: string;
+    title: string;
+    subtitle: string;
+    badges: string;
+    metrics: string;
+    metricLabel: string;
+    metricValue: string;
+    footer: string;
+}>>;
+export interface RecordCardMetric {
+    label: ReactNode;
+    value: ReactNode;
+}
+export interface RecordCardProps extends VariantProps<typeof record> {
+    /** The record's own id — rendered mono, above the title. */
+    identifier?: ReactNode;
+    title: ReactNode;
+    /** What kind of record this is, or who it belongs to. One line. */
+    subtitle?: ReactNode;
+    /** State chips. A slot, so their tones and behaviour stay the consumer's. */
+    badges?: ReactNode;
+    /** The numbers worth seeing without opening the record. */
+    metrics?: readonly RecordCardMetric[];
+    /** Leading — an icon, an avatar, or a drag handle. */
+    media?: ReactNode;
+    /** Trailing, top-aligned — a menu. */
+    action?: ReactNode;
+    /** A last line under a rule: an assignee, a timestamp, a count. */
+    footer?: ReactNode;
+    /**
+     * Render as something else — an `<a>` for a card that navigates.
+     *
+     * Prefer this over `onClick` when the card leads somewhere: a link can be
+     * opened in a new tab, copied, and read out as a link, and a button that
+     * calls `navigate` can do none of those.
+     */
+    render?: useRender.RenderProp;
+    className?: string;
+    children?: ReactNode;
+    ref?: Ref<HTMLElement>;
+    onClick?: (event: React.MouseEvent) => void;
+}
+export declare function RecordCard({ identifier, title, subtitle, badges, metrics, media, action, footer, emphasis, interactive, selected, render, className, children, ref, ...props }: RecordCardProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export {};

package/dist/types/components/kanban/KanbanBoard.d.ts

@@ -0,0 +1,40 @@
+import type { ReactNode } from "react";
+import type { DragSessionCallbacks } from "../../lib/dnd";
+import type { KanbanLane, KanbanMove, KanbanRefusal } from "./types";
+export type { KanbanLane, KanbanMove, KanbanRefusal };
+export interface KanbanBoardProps<T> extends Omit<DragSessionCallbacks, "onDragEnd"> {
+    /**
+     * What this board is a board OF — "Case pipeline", "Release queue".
+     *
+     * It names the horizontal scroller, which is a tab stop because a board wider
+     * than the screen is otherwise unreachable by keyboard. An unlabelled stop
+     * announces as "group" and gives nobody a reason to be there, which is why
+     * this is required rather than optional.
+     */
+    label: string;
+    lanes: readonly KanbanLane<T>[];
+    getItemId: (item: T) => string;
+    /**
+     * A speakable name for one record — "SS-2026-0412, M.R.".
+     *
+     * Required rather than optional. It is what every announcement says, and the
+     * fallback for a missing one is the id, which is speakable and never right.
+     */
+    itemLabel: (item: T) => string;
+    renderItem: (item: T) => ReactNode;
+    /**
+     * The card while it is being carried. Defaults to `renderItem`.
+     *
+     * Worth overriding when the resting card is dense: the clone is moving, often
+     * under a cursor, and the two or three fields that identify the record are
+     * the only ones anybody reads off it.
+     */
+    renderDragging?: (item: T) => ReactNode;
+    onMove: (move: KanbanMove) => void;
+    /** Called INSTEAD of `onMove` when the destination lane carries a `refusal`. */
+    onRefuse?: (refusal: KanbanRefusal) => void;
+    /** Shown in a lane with no cards. */
+    emptyLane?: ReactNode;
+    className?: string;
+}
+export declare function KanbanBoard<T>({ label, lanes, getItemId, itemLabel, renderItem, renderDragging, onMove, onRefuse, emptyLane, className, ...callbacks }: KanbanBoardProps<T>): import("react").JSX.Element;

package/dist/types/components/kanban/recipe.d.ts

@@ -0,0 +1,49 @@
+export declare const kanban: import("tailwind-variants").TVReturnType<{
+    refusing: {
+        true: {
+            lane: string;
+        };
+        false: {};
+    };
+}, {
+    root: string;
+    lane: string;
+    laneHeader: string;
+    laneLabel: string;
+    laneHint: string;
+    laneItems: string;
+    laneEmpty: string;
+    laneRefusal: string;
+}, undefined, {
+    refusing: {
+        true: {
+            lane: string;
+        };
+        false: {};
+    };
+}, {
+    root: string;
+    lane: string;
+    laneHeader: string;
+    laneLabel: string;
+    laneHint: string;
+    laneItems: string;
+    laneEmpty: string;
+    laneRefusal: string;
+}, import("tailwind-variants").TVReturnTypeLike<{
+    refusing: {
+        true: {
+            lane: string;
+        };
+        false: {};
+    };
+}, {
+    root: string;
+    lane: string;
+    laneHeader: string;
+    laneLabel: string;
+    laneHint: string;
+    laneItems: string;
+    laneEmpty: string;
+    laneRefusal: string;
+}>>;

package/dist/types/components/kanban/resolve.d.ts

@@ -0,0 +1,31 @@
+import type { DragEndEvent } from "../../lib/dnd";
+import type { KanbanLane, KanbanMove, KanbanRefusal } from "./types";
+export type KanbanDrop = 
+/** Nothing happened: the card was put back where it came from. */
+{
+    kind: "none";
+} | {
+    kind: "refused";
+    refusal: KanbanRefusal;
+} | {
+    kind: "move";
+    move: KanbanMove;
+};
+export declare function resolveKanbanDrop<T>(lanes: readonly KanbanLane<T>[], event: DragEndEvent): KanbanDrop;
+export interface KanbanDropHandlers {
+    onMove: (move: KanbanMove) => void;
+    onRefuse?: (refusal: KanbanRefusal) => void;
+}
+/**
+ * Resolve a drop and hand it to exactly one of the two callbacks.
+ *
+ * The dispatch is here rather than inline in the component because it is the
+ * other half of the same decision, and the half a resolver test cannot see: a
+ * board that resolved "refused" correctly and then called `onMove` anyway would
+ * keep every test in `resolveKanbanDrop` green while writing the move the
+ * refusal was supposed to stop. Found by mutation — the inline version was the
+ * one thing in this component nothing failed on.
+ *
+ * EXACTLY ONE, OR NEITHER. Never both.
+ */
+export declare function handleKanbanDrop<T>(lanes: readonly KanbanLane<T>[], event: DragEndEvent, handlers: KanbanDropHandlers): KanbanDrop;

package/dist/types/components/kanban/types.d.ts

@@ -0,0 +1,45 @@
+import type { ReactNode } from "react";
+export interface KanbanLane<T> {
+    id: string;
+    /** Spoken in every announcement about this lane, and shown on it. */
+    label: string;
+    /** What the lane means. One line, under the label. */
+    hint?: ReactNode;
+    /**
+     * Work-in-progress ceiling.
+     *
+     * ABSENT MEANS NO CEILING. Not a large number standing in for one: a lane
+     * whose limit is 99 renders "3 / 99", which asks the reader to work out that
+     * 99 was never a real ceiling. Omit the prop and the lane shows a plain
+     * count.
+     */
+    limit?: number;
+    /** In the order they should appear. Their index is what a move reports. */
+    items: readonly T[];
+    /**
+     * Why a card may not be dropped here. Absent means the lane accepts drops.
+     *
+     * Written for the person who would have tried — "needs the case.decide
+     * permission", not "forbidden". It is shown on the lane before anyone drags,
+     * and passed back verbatim through `onRefuse`.
+     */
+    refusal?: string;
+}
+export interface KanbanMove {
+    id: string;
+    from: {
+        lane: string;
+        index: number;
+    };
+    /** `index` is the position in the destination lane WITHOUT the moved card. */
+    to: {
+        lane: string;
+        index: number;
+    };
+}
+export interface KanbanRefusal {
+    id: string;
+    lane: string;
+    /** Verbatim from the lane's `refusal`. */
+    reason: string;
+}

package/dist/types/index.d.ts

@@ -37,6 +37,7 @@ export { Combobox, ComboboxItem, ComboboxGroup, MultiCombobox, type ComboboxProp
 export { Select, SelectItem, SelectGroup, SelectSeparator, type SelectProps, type SelectItemProps, type SelectGroupProps, } from "./components/Select";
 export { StatusSelect, type StatusSelectProps, type StatusOption } from "./components/StatusSelect";
 export { Card, CardHeader, CardFooter, type CardProps, type CardHeaderProps, } from "./components/Card";
+export { RecordCard, type RecordCardProps, type RecordCardMetric, } from "./components/RecordCard";
 export { Tabs, TabList, Tab, TabPanel, type TabsProps, type TabListProps, type TabProps, type TabPanelProps, } from "./components/Tabs";
 export { Accordion, AccordionItem, type AccordionProps, type AccordionItemProps, } from "./components/Accordion";
 export { Breadcrumb, Pagination, type BreadcrumbProps, type PaginationProps, type Crumb, } from "./components/Navigation";
@@ -66,6 +67,7 @@ export { toggleBold, toggleItalic, toggleCode, toggleStrike, toggleInline, setHe
 export { tokenize, listLanguages, resolveLanguage, defineGrammar, registerGrammar, checkCoverage, type Token, type TokenType, type Grammar, type Rule, } from "./lib/syntax";
 export { parseMarkdown, MarkdownNodes, sanitizeHref, type MdNode, type MdInline, type MdCodeRenderer, } from "./lib/syntax/markdown";
 export { DragDrop, DragDropContainer, DragDropItem, DragDropHandle, DragDropOverlay, type DragDropProps, type DragDropContainerProps, type DragDropItemProps, type DragDropHandleProps, type DragDropOverlayProps, } from "./components/DragDrop";
+export { KanbanBoard, type KanbanBoardProps, type KanbanLane, type KanbanMove, type KanbanRefusal, } from "./components/kanban/KanbanBoard";
 export { DEFAULT_DRAG_STRINGS, DRAG_INSTRUCTIONS_ID, DragInstructions, DragLiveRegion, DragSession, DragSessionProvider, applyMove, attachAutoScroll, attachKeyboardSensor, attachPointerSensor, attachSessionWindowListeners, isNoOp, resolveTarget, sameTarget, scrollVelocity, useCreateDragSession, useDragAnnouncements, useDragSession, useDragState, useDraggable, useDropContainer, type ContainerId, type DragAxis, type DragCancelEvent, type DragEndEvent, type DragId, type DragMode, type DragPhase, type DragSessionCallbacks, type DragStartEvent, type DragState, type AutoScrollOptions, type DragAnnouncementContext, type DragAnnouncementOptions, type DragAnnouncements, type DragInstructionsProps, type DragLiveRegionProps, type DragStrings, type DropTarget, type KeyboardSensorOptions, type PointerActivation, } from "./lib/dnd";
 export type { MessageRole, MessagePart, MessagePartType, TextPart, CodePart, ReasoningPart, ToolPart, ToolStatus, FilePart, ComponentPart, ChatFile, ChatMessage, RenderContext, PartRenderer, PartRenderers, ChatComponentRenderer, ChatComponents, } from "./components/chat/types";
 export { Chat, ChatPopover, type ChatProps, type ChatPopoverProps, type ChatSurface, } from "./components/chat/Chat";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danxbot/ui",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "type": "module",
   "description": "Danxbot — a domain-agnostic React design system with motion as a first-class primitive.",
   "license": "MIT",