@stll/ui 0.5.2 → 0.7.0

package/dist/kanban/sortable-interactions.d.ts

@@ -0,0 +1,75 @@
+import { Button } from "../components/button.js";
+import * as React$1 from "react";
+import { AutoScrollOptions, CollisionDetection, DndContextProps, DragCancelEvent, DragEndEvent, DragOverlayProps, DragStartEvent, KeyboardCoordinateGetter, UniqueIdentifier } from "@dnd-kit/core";
+import { SortableContextProps, useSortable } from "@dnd-kit/sortable";
+//#region src/kanban/sortable-interactions.d.ts
+declare const KANBAN_MOUSE_ACTIVATION_DISTANCE = 8;
+declare const KANBAN_TOUCH_ACTIVATION_CONSTRAINT: {
+  readonly delay: 150;
+  readonly tolerance: 8;
+};
+type KanbanSortableBoardProps = {
+  children: React$1.ReactNode;
+  onDragEnd: (event: DragEndEvent) => void;
+  collisionDetection?: CollisionDetection | undefined;
+  keyboardCoordinates?: KeyboardCoordinateGetter | undefined;
+  autoScroll?: boolean | AutoScrollOptions | undefined;
+  /** Replaces the default mouse, touch, and keyboard sensors when supplied. */
+  sensors?: DndContextProps["sensors"] | undefined;
+  /** Overrides dnd-kit's screen-reader announcements when supplied. */
+  accessibility?: DndContextProps["accessibility"] | undefined;
+  onDragStart?: ((event: DragStartEvent) => void) | undefined;
+  onDragCancel?: ((event: DragCancelEvent) => void) | undefined;
+  /** Rendered in document.body while an item is active. */
+  overlay?: ((activeId: UniqueIdentifier | null) => React$1.ReactNode) | undefined;
+  overlayProps?: Omit<DragOverlayProps, "children"> | undefined;
+};
+/**
+ * Input-complete drag context for sortable boards.
+ *
+ * The consumer owns identifiers and the result of a drop; this component owns
+ * the sensor activation rules, keyboard navigation, auto-scroll configuration,
+ * and overlay lifecycle shared by sortable board UIs.
+ */
+declare const KanbanSortableBoard: ({ children, onDragEnd, collisionDetection, keyboardCoordinates, autoScroll, sensors, accessibility, onDragStart, onDragCancel, overlay, overlayProps }: KanbanSortableBoardProps) => React$1.JSX.Element;
+declare const useKanbanSortableSensors: (keyboardCoordinates?: KeyboardCoordinateGetter) => import("@dnd-kit/core").SensorDescriptor<import("@dnd-kit/core").SensorOptions>[];
+type KanbanSortableListProps = SortableContextProps & React$1.ComponentProps<"div">;
+/** A vertical card list that preserves native vertical touch scrolling. */
+declare const KanbanSortableList: ({ className, children, id, items, strategy, disabled, ...props }: KanbanSortableListProps) => React$1.JSX.Element;
+type KanbanSortableColumnsProps = SortableContextProps & React$1.ComponentProps<"div">;
+/** A horizontal column list that keeps the board pan gesture available. */
+declare const KanbanSortableColumns: ({ className, children, id, items, strategy, disabled, ...props }: KanbanSortableColumnsProps) => React$1.JSX.Element;
+type KanbanSortableBindings = Pick<ReturnType<typeof useSortable>, "attributes" | "listeners" | "setActivatorNodeRef">;
+type UseKanbanSortableOptions = {
+  id: UniqueIdentifier;
+  disabled?: boolean | undefined;
+};
+/**
+ * Connect a sortable item and its separate drag handle without making the
+ * item's content a touch-none activation surface.
+ */
+declare const useKanbanSortable: ({ id, disabled }: UseKanbanSortableOptions) => {
+  isDragging: boolean;
+  setNodeRef: (node: HTMLElement | null) => void;
+  style: {
+    transform: string | undefined;
+    transition: string | undefined;
+  };
+  dragHandle: {
+    attributes: import("@dnd-kit/core").DraggableAttributes;
+    listeners: import("@dnd-kit/core/dist/hooks/utilities").SyntheticListenerMap | undefined;
+    setActivatorNodeRef: (element: HTMLElement | null) => void;
+  };
+};
+type KanbanDragHandleProps = {
+  bindings: KanbanSortableBindings;
+  label: string;
+} & Omit<React$1.ComponentProps<typeof Button>, "aria-label" | "children" | "ref" | "tooltip" | "type">;
+/**
+ * A 44px keyboard-accessible drag activator. The handle is the only board
+ * surface that disables touch panning, leaving cards and scroll regions free
+ * for ordinary scrolling.
+ */
+declare const KanbanDragHandle: ({ bindings, label, className, ...props }: KanbanDragHandleProps) => React$1.JSX.Element;
+//#endregion
+export { KANBAN_MOUSE_ACTIVATION_DISTANCE, KANBAN_TOUCH_ACTIVATION_CONSTRAINT, KanbanDragHandle, KanbanDragHandleProps, KanbanSortableBindings, KanbanSortableBoard, KanbanSortableBoardProps, KanbanSortableColumns, KanbanSortableColumnsProps, KanbanSortableList, KanbanSortableListProps, UseKanbanSortableOptions, useKanbanSortable, useKanbanSortableSensors };

package/dist/kanban/sortable-interactions.js

@@ -0,0 +1,210 @@
+"use client";
+import { cn } from "../lib/utils.js";
+import { Button } from "../components/button.js";
+import { isActiveTouchChange } from "./touch-identity.js";
+import { GripVerticalIcon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React$1 from "react";
+import { createPortal } from "react-dom";
+import { DndContext, DragOverlay, KeyboardSensor, MouseSensor, TouchSensor, useSensor, useSensors } from "@dnd-kit/core";
+import { SortableContext, sortableKeyboardCoordinates, useSortable } from "@dnd-kit/sortable";
+//#region src/kanban/sortable-interactions.tsx
+const KANBAN_MOUSE_ACTIVATION_DISTANCE = 8;
+const KANBAN_TOUCH_ACTIVATION_CONSTRAINT = {
+	delay: 150,
+	tolerance: 8
+};
+const hasTouchLists = (event) => "changedTouches" in event && "touches" in event;
+const getTouchIdentifier = (event) => {
+	if (!hasTouchLists(event)) return null;
+	return event.changedTouches.item(0)?.identifier ?? event.touches.item(0)?.identifier ?? null;
+};
+const getTouchIdentifiers = (touches) => {
+	const identifiers = [];
+	for (let index = 0; index < touches.length; index += 1) {
+		const identifier = touches.item(index)?.identifier;
+		if (identifier !== void 0) identifiers.push(identifier);
+	}
+	return identifiers;
+};
+/**
+* Keeps a delayed touch drag bound to the finger that activated it.
+*
+* dnd-kit's stock touch sensor attaches document-level lifecycle listeners,
+* so a second finger can otherwise move, end, or cancel the active drag. The
+* capture listeners below suppress only secondary touch changes before those
+* listeners receive them; browser scrolling remains native because no default
+* action is prevented here.
+*/
+var KanbanTouchSensor = class extends TouchSensor {
+	identityListeners;
+	ownerDocument;
+	touchIdentifier;
+	constructor(props) {
+		const identityListeners = new AbortController();
+		super({
+			...props,
+			onAbort: (active) => {
+				identityListeners.abort();
+				props.onAbort(active);
+			},
+			onCancel: () => {
+				identityListeners.abort();
+				props.onCancel();
+			},
+			onEnd: () => {
+				identityListeners.abort();
+				props.onEnd();
+			}
+		});
+		this.identityListeners = identityListeners;
+		this.ownerDocument = getTouchDocument(props.event);
+		this.touchIdentifier = getTouchIdentifier(props.event);
+		this.ownerDocument.addEventListener("touchmove", this.handleTouchMove, {
+			capture: true,
+			passive: false,
+			signal: identityListeners.signal
+		});
+		this.ownerDocument.addEventListener("touchend", this.handleTouchEnd, {
+			capture: true,
+			signal: identityListeners.signal
+		});
+		this.ownerDocument.addEventListener("touchcancel", this.handleTouchCancel, {
+			capture: true,
+			signal: identityListeners.signal
+		});
+	}
+	handleTouchMove = (event) => {
+		if (this.isPrimaryTouchChange(event)) return;
+		event.stopImmediatePropagation();
+	};
+	handleTouchEnd = (event) => {
+		if (!this.isPrimaryTouchChange(event)) {
+			event.stopImmediatePropagation();
+			return;
+		}
+		this.detachIdentityListeners();
+	};
+	handleTouchCancel = (event) => {
+		if (!this.isPrimaryTouchChange(event)) {
+			event.stopImmediatePropagation();
+			return;
+		}
+		this.detachIdentityListeners();
+	};
+	isPrimaryTouchChange = (event) => isActiveTouchChange({
+		activeTouchIdentifier: this.touchIdentifier,
+		changedTouchIdentifiers: getTouchIdentifiers(event.changedTouches)
+	});
+	detachIdentityListeners = () => {
+		this.identityListeners.abort();
+	};
+};
+const getTouchDocument = (event) => {
+	if (event.target instanceof Node && event.target.ownerDocument) return event.target.ownerDocument;
+	return document;
+};
+/**
+* Input-complete drag context for sortable boards.
+*
+* The consumer owns identifiers and the result of a drop; this component owns
+* the sensor activation rules, keyboard navigation, auto-scroll configuration,
+* and overlay lifecycle shared by sortable board UIs.
+*/
+const KanbanSortableBoard = ({ children, onDragEnd, collisionDetection, keyboardCoordinates, autoScroll, sensors, accessibility, onDragStart, onDragCancel, overlay, overlayProps }) => {
+	const [activeId, setActiveId] = React$1.useState(null);
+	const defaultSensors = useKanbanSortableSensors(keyboardCoordinates);
+	const handleDragStart = (event) => {
+		setActiveId(event.active.id);
+		onDragStart?.(event);
+	};
+	const handleDragEnd = (event) => {
+		setActiveId(null);
+		onDragEnd(event);
+	};
+	const handleDragCancel = (event) => {
+		setActiveId(null);
+		onDragCancel?.(event);
+	};
+	return /* @__PURE__ */ jsxs(DndContext, {
+		...autoScroll === void 0 ? {} : { autoScroll },
+		...accessibility === void 0 ? {} : { accessibility },
+		...collisionDetection === void 0 ? {} : { collisionDetection },
+		onDragCancel: handleDragCancel,
+		onDragEnd: handleDragEnd,
+		onDragStart: handleDragStart,
+		sensors: sensors ?? defaultSensors,
+		children: [children, overlay && typeof document !== "undefined" ? createPortal(/* @__PURE__ */ jsx(DragOverlay, {
+			...overlayProps,
+			children: overlay(activeId)
+		}), document.body) : null]
+	});
+};
+const useKanbanSortableSensors = (keyboardCoordinates = sortableKeyboardCoordinates) => useSensors(useSensor(MouseSensor, { activationConstraint: { distance: 8 } }), useSensor(KanbanTouchSensor, { activationConstraint: KANBAN_TOUCH_ACTIVATION_CONSTRAINT }), useSensor(KeyboardSensor, { coordinateGetter: keyboardCoordinates }));
+/** A vertical card list that preserves native vertical touch scrolling. */
+const KanbanSortableList = ({ className, children, id, items, strategy, disabled, ...props }) => /* @__PURE__ */ jsx(SortableContext, {
+	...disabled === void 0 ? {} : { disabled },
+	...id === void 0 ? {} : { id },
+	items,
+	...strategy === void 0 ? {} : { strategy },
+	children: /* @__PURE__ */ jsx("div", {
+		className: cn("min-h-0 touch-auto overflow-y-auto overscroll-y-contain", className),
+		...props,
+		children
+	})
+});
+/** A horizontal column list that keeps the board pan gesture available. */
+const KanbanSortableColumns = ({ className, children, id, items, strategy, disabled, ...props }) => /* @__PURE__ */ jsx(SortableContext, {
+	...disabled === void 0 ? {} : { disabled },
+	...id === void 0 ? {} : { id },
+	items,
+	...strategy === void 0 ? {} : { strategy },
+	children: /* @__PURE__ */ jsx("div", {
+		className: cn("flex min-h-0 touch-auto overflow-x-auto overscroll-x-contain", className),
+		...props,
+		children
+	})
+});
+/**
+* Connect a sortable item and its separate drag handle without making the
+* item's content a touch-none activation surface.
+*/
+const useKanbanSortable = ({ id, disabled }) => {
+	const sortable = useSortable({
+		id,
+		...disabled === void 0 ? {} : { disabled }
+	});
+	return {
+		isDragging: sortable.isDragging,
+		setNodeRef: sortable.setNodeRef,
+		style: {
+			transform: sortable.transform ? `translate3d(${sortable.transform.x}px, ${sortable.transform.y}px, 0)` : void 0,
+			transition: sortable.transition
+		},
+		dragHandle: {
+			attributes: sortable.attributes,
+			listeners: sortable.listeners,
+			setActivatorNodeRef: sortable.setActivatorNodeRef
+		}
+	};
+};
+/**
+* A 44px keyboard-accessible drag activator. The handle is the only board
+* surface that disables touch panning, leaving cards and scroll regions free
+* for ordinary scrolling.
+*/
+const KanbanDragHandle = ({ bindings, label, className, ...props }) => /* @__PURE__ */ jsx(Button, {
+	...props,
+	...bindings.attributes,
+	...bindings.listeners,
+	"aria-label": label,
+	className: cn("size-11 touch-none sm:size-11", className),
+	ref: (element) => bindings.setActivatorNodeRef(element),
+	size: "icon-xl",
+	tooltip: false,
+	type: "button",
+	variant: "ghost",
+	children: /* @__PURE__ */ jsx(GripVerticalIcon, { "aria-hidden": "true" })
+});
+//#endregion
+export { KANBAN_MOUSE_ACTIVATION_DISTANCE, KANBAN_TOUCH_ACTIVATION_CONSTRAINT, KanbanDragHandle, KanbanSortableBoard, KanbanSortableColumns, KanbanSortableList, useKanbanSortable, useKanbanSortableSensors };

package/dist/kanban/touch-identity.d.ts

@@ -0,0 +1,8 @@
+//#region src/kanban/touch-identity.d.ts
+type ActiveTouchChangeOptions = {
+  activeTouchIdentifier: number | null;
+  changedTouchIdentifiers: readonly number[];
+};
+declare const isActiveTouchChange: ({ activeTouchIdentifier, changedTouchIdentifiers }: ActiveTouchChangeOptions) => boolean;
+//#endregion
+export { isActiveTouchChange };

package/dist/kanban/touch-identity.js

@@ -0,0 +1,4 @@
+//#region src/kanban/touch-identity.ts
+const isActiveTouchChange = ({ activeTouchIdentifier, changedTouchIdentifiers }) => activeTouchIdentifier === null || changedTouchIdentifiers.includes(activeTouchIdentifier);
+//#endregion
+export { isActiveTouchChange };

package/dist/lib/initials.d.ts

@@ -0,0 +1,16 @@
+//#region src/lib/initials.d.ts
+/**
+ * Extract up to two uppercase initials from a display name.
+ *
+ * Behaviour:
+ * - Multi-word: first letter of each of the first two words.
+ *   "Eva Schmidt" → "ES", "Jan van Houten" → "JV"
+ * - Single-word (Latin): first two characters.
+ *   "John" → "JO"
+ * - CJK / no-space scripts: first two characters.
+ *   "王小明" → "王小"
+ * - Null / empty: "?"
+ */
+declare const getInitials: (name: string | null) => string;
+//#endregion
+export { getInitials };

package/dist/lib/initials.js

@@ -0,0 +1,27 @@
+//#region src/lib/initials.ts
+/**
+* Extract up to two uppercase initials from a display name.
+*
+* Behaviour:
+* - Multi-word: first letter of each of the first two words.
+*   "Eva Schmidt" → "ES", "Jan van Houten" → "JV"
+* - Single-word (Latin): first two characters.
+*   "John" → "JO"
+* - CJK / no-space scripts: first two characters.
+*   "王小明" → "王小"
+* - Null / empty: "?"
+*/
+const getInitials = (name) => {
+	if (!name) return "?";
+	const trimmed = name.trim();
+	if (trimmed.length === 0) return "?";
+	const parts = trimmed.split(/\s+/u);
+	if (parts.length >= 2) {
+		const a = parts.at(0) ?? "";
+		const b = parts.at(1) ?? "";
+		return `${a.at(0) ?? ""}${b.at(0) ?? ""}`.toUpperCase();
+	}
+	return trimmed.slice(0, 2).toUpperCase();
+};
+//#endregion
+export { getInitials };

package/dist/review/review-author-avatar.d.ts

@@ -0,0 +1,23 @@
+import { Avatar } from "../components/avatar.js";
+import { ComponentProps } from "react";
+//#region src/review/review-author-avatar.d.ts
+/**
+ * Shown when an author has neither a name nor anything to fall back on. This
+ * package carries no catalogs, so a localized host passes `fallbackLabel`;
+ * the constant is exported so every surface that needs the same placeholder
+ * outside an avatar reads it from here rather than minting its own.
+ */
+declare const UNKNOWN_AUTHOR_LABEL = "Unknown user";
+type ReviewAuthorAvatarProps = Omit<ComponentProps<typeof Avatar>, "children" | "className"> & {
+  image?: string | null | undefined;
+  name?: string | null;
+  deleted?: boolean | undefined;
+  fallbackLabel?: string;
+  className?: string | undefined;
+  fallbackClassName?: string | undefined;
+};
+/** The author's face on any review surface: image when there is one, initials
+ *  otherwise, dimmed once the account is gone. */
+declare const ReviewAuthorAvatar: ({ deleted, image, name, fallbackLabel, className, fallbackClassName, ...avatarProps }: ReviewAuthorAvatarProps) => import("react").JSX.Element;
+//#endregion
+export { ReviewAuthorAvatar, UNKNOWN_AUTHOR_LABEL };

package/dist/review/review-author-avatar.js

@@ -0,0 +1,30 @@
+import { cn } from "../lib/utils.js";
+import { Avatar, AvatarFallback, AvatarImage } from "../components/avatar.js";
+import { getInitials } from "../lib/initials.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/review/review-author-avatar.tsx
+/**
+* Shown when an author has neither a name nor anything to fall back on. This
+* package carries no catalogs, so a localized host passes `fallbackLabel`;
+* the constant is exported so every surface that needs the same placeholder
+* outside an avatar reads it from here rather than minting its own.
+*/
+const UNKNOWN_AUTHOR_LABEL = "Unknown user";
+/** The author's face on any review surface: image when there is one, initials
+*  otherwise, dimmed once the account is gone. */
+const ReviewAuthorAvatar = ({ deleted = false, image, name, fallbackLabel = UNKNOWN_AUTHOR_LABEL, className, fallbackClassName, ...avatarProps }) => {
+	const displayName = name?.trim() || fallbackLabel;
+	return /* @__PURE__ */ jsxs(Avatar, {
+		...avatarProps,
+		className: cn(className, deleted && "opacity-60 grayscale"),
+		children: [image ? /* @__PURE__ */ jsx(AvatarImage, {
+			alt: displayName,
+			src: image
+		}) : null, /* @__PURE__ */ jsx(AvatarFallback, {
+			className: cn(fallbackClassName, deleted && "bg-muted text-muted-foreground"),
+			children: getInitials(name ?? null)
+		})]
+	});
+};
+//#endregion
+export { ReviewAuthorAvatar, UNKNOWN_AUTHOR_LABEL };

package/dist/review/review-comment-card.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from "react";
+//#region src/review/review-comment-card.d.ts
+type ReviewCommentAuthor = {
+  name: string | null;
+  image?: string | null | undefined;
+  deleted?: boolean | undefined;
+};
+type ReviewCommentCardProps = {
+  author: ReviewCommentAuthor;
+  /** Machine-readable instant for `<time>`; ISO string or Date. */
+  timestamp: string | Date;
+  /** The same instant, already formatted by the host's locale formatter. */
+  formattedTime: string;
+  body: ReactNode;
+  /** The text the comment was written against, when it is worth echoing. */
+  anchorText?: string | undefined;
+  /** The comment is anchored to text the document has since moved past. */
+  isStale?: boolean | undefined;
+  staleLabel?: string | undefined;
+  resolved?: boolean | undefined;
+  onToggleResolved?: (() => void) | undefined;
+  resolveLabel?: string | undefined;
+  reopenLabel?: string | undefined;
+  canDelete?: boolean | undefined;
+  onDelete?: (() => void) | undefined;
+  deleteLabel?: string | undefined;
+  className?: string;
+};
+/** One comment on a reviewed surface: who wrote it, when, what it says, what
+ *  it points at, and the two things a reader can do to it. */
+declare const ReviewCommentCard: ({ author, timestamp, formattedTime, body, anchorText, isStale, staleLabel, resolved, onToggleResolved, resolveLabel, reopenLabel, canDelete, onDelete, deleteLabel, className }: ReviewCommentCardProps) => import("react").JSX.Element;
+//#endregion
+export { ReviewCommentAuthor, ReviewCommentCard };

package/dist/review/review-comment-card.js

@@ -0,0 +1,76 @@
+import { cn } from "../lib/utils.js";
+import { BidiText } from "../components/bidi-text.js";
+import { Button } from "../components/button.js";
+import { ReviewAuthorAvatar } from "./review-author-avatar.js";
+import { CheckIcon, RotateCcwIcon, Trash2Icon } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/review/review-comment-card.tsx
+/** One comment on a reviewed surface: who wrote it, when, what it says, what
+*  it points at, and the two things a reader can do to it. */
+const ReviewCommentCard = ({ author, timestamp, formattedTime, body, anchorText, isStale = false, staleLabel, resolved = false, onToggleResolved, resolveLabel, reopenLabel, canDelete = false, onDelete, deleteLabel, className }) => /* @__PURE__ */ jsxs("article", {
+	className: cn("flex items-start gap-2 px-3 py-2", resolved && "opacity-60", className),
+	"data-slot": "review-comment-card",
+	children: [
+		/* @__PURE__ */ jsx(ReviewAuthorAvatar, {
+			className: "mt-0.5 size-5 shrink-0 text-[9px]",
+			deleted: author.deleted,
+			image: author.image,
+			name: author.name
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			className: "min-w-0 flex-1",
+			children: [
+				/* @__PURE__ */ jsxs("p", {
+					className: "text-muted-foreground flex min-w-0 items-baseline gap-1.5 text-[11px]",
+					children: [/* @__PURE__ */ jsx(BidiText, {
+						as: "span",
+						className: "text-foreground-strong-muted truncate font-medium",
+						children: author.name
+					}), /* @__PURE__ */ jsx("time", {
+						className: "shrink-0 tabular-nums",
+						dateTime: toIsoInstant(timestamp),
+						children: formattedTime
+					})]
+				}),
+				/* @__PURE__ */ jsx(BidiText, {
+					as: "div",
+					className: "text-foreground text-xs wrap-anywhere",
+					children: body
+				}),
+				anchorText === void 0 || anchorText === "" ? null : /* @__PURE__ */ jsx(BidiText, {
+					as: "p",
+					className: "text-muted-foreground mt-0.5 truncate text-[11px] italic",
+					children: anchorText
+				}),
+				isStale && staleLabel !== void 0 ? /* @__PURE__ */ jsx("p", {
+					className: "text-muted-foreground mt-0.5 text-[11px]",
+					children: staleLabel
+				}) : null
+			]
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			className: "flex shrink-0 items-center gap-0.5",
+			children: [onToggleResolved === void 0 ? null : /* @__PURE__ */ jsx(Button, {
+				"aria-label": resolved ? reopenLabel : resolveLabel,
+				onClick: onToggleResolved,
+				size: "icon-xs",
+				variant: "ghost",
+				children: resolved ? /* @__PURE__ */ jsx(RotateCcwIcon, {}) : /* @__PURE__ */ jsx(CheckIcon, {})
+			}), canDelete && onDelete !== void 0 ? /* @__PURE__ */ jsx(Button, {
+				"aria-label": deleteLabel,
+				onClick: onDelete,
+				size: "icon-xs",
+				variant: "ghost",
+				children: /* @__PURE__ */ jsx(Trash2Icon, {})
+			}) : null]
+		})
+	]
+});
+/** `<time dateTime>` wants a machine-readable instant. An unparseable date
+*  yields no attribute rather than throwing on `toISOString`. */
+const toIsoInstant = (timestamp) => {
+	if (typeof timestamp === "string") return timestamp;
+	return Number.isNaN(timestamp.getTime()) ? void 0 : timestamp.toISOString();
+};
+//#endregion
+export { ReviewCommentCard };

package/dist/review/review-decision-actions.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from "react";
+//#region src/review/review-decision-actions.d.ts
+/**
+ * Where a reviewable item stands. Undecided items offer accept/reject;
+ * decided ones offer the way back (revert the applied change, or reopen the
+ * decision). `applying` is undecided but in flight: the same pair, inert,
+ * so the row does not resize while the write lands.
+ */
+type ReviewDecisionState = "pending" | "accepted" | "rejected" | "dismissed" | "applying";
+type ReviewDecisionSize = "xs" | "sm";
+type ReviewDecisionActionsProps = {
+  state: ReviewDecisionState;
+  onAccept?: (() => void) | undefined;
+  onReject?: (() => void) | undefined;
+  onRevert?: (() => void) | undefined;
+  onReopen?: (() => void) | undefined;
+  size?: ReviewDecisionSize;
+  /** Labels are supplied by the host: this package carries no catalogs. */
+  acceptLabel?: ReactNode;
+  rejectLabel?: ReactNode;
+  revertLabel?: ReactNode;
+  /** Accessible name for the icon-only reopen control. */
+  reopenLabel?: string | undefined;
+  acceptTooltip?: ReactNode;
+  rejectTooltip?: ReactNode;
+  disabled?: boolean;
+  className?: string;
+};
+/** Accept / reject / revert / reopen, in one shape, for every review surface. */
+declare const ReviewDecisionActions: ({ state, onAccept, onReject, onRevert, onReopen, size, acceptLabel, rejectLabel, revertLabel, reopenLabel, acceptTooltip, rejectTooltip, disabled, className }: ReviewDecisionActionsProps) => import("react").JSX.Element | null;
+//#endregion
+export { ReviewDecisionActions, ReviewDecisionSize, ReviewDecisionState };

package/dist/review/review-decision-actions.js

@@ -0,0 +1,74 @@
+import { cn } from "../lib/utils.js";
+import { Button } from "../components/button.js";
+import { CheckIcon, RotateCcwIcon, XIcon } from "lucide-react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/review/review-decision-actions.tsx
+/** Accept / reject / revert / reopen, in one shape, for every review surface. */
+const ReviewDecisionActions = ({ state, onAccept, onReject, onRevert, onReopen, size = "sm", acceptLabel, rejectLabel, revertLabel, reopenLabel, acceptTooltip, rejectTooltip, disabled = false, className }) => {
+	const controls = renderControls({
+		acceptLabel,
+		acceptTooltip,
+		disabled,
+		onAccept,
+		onReject,
+		onReopen,
+		onRevert,
+		rejectLabel,
+		rejectTooltip,
+		reopenLabel,
+		revertLabel,
+		size,
+		state
+	});
+	if (controls === null) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("flex items-center gap-1.5", className),
+		"data-slot": "review-decision-actions",
+		children: controls
+	});
+};
+const renderControls = ({ acceptLabel, acceptTooltip, disabled, onAccept, onReject, onReopen, onRevert, rejectLabel, rejectTooltip, reopenLabel, revertLabel, size, state }) => {
+	switch (state) {
+		case "pending":
+		case "applying": {
+			const inert = disabled || state === "applying";
+			return /* @__PURE__ */ jsxs(Fragment, { children: [onAccept === void 0 ? null : /* @__PURE__ */ jsxs(Button, {
+				disabled: inert,
+				onClick: onAccept,
+				size,
+				tooltip: acceptTooltip,
+				variant: "default",
+				children: [/* @__PURE__ */ jsx(CheckIcon, {}), acceptLabel]
+			}), onReject === void 0 ? null : /* @__PURE__ */ jsxs(Button, {
+				disabled: inert,
+				onClick: onReject,
+				size,
+				tooltip: rejectTooltip,
+				variant: "outline",
+				children: [/* @__PURE__ */ jsx(XIcon, {}), rejectLabel]
+			})] });
+		}
+		case "accepted":
+		case "rejected":
+		case "dismissed":
+			if (onRevert === void 0 && onReopen === void 0) return null;
+			return /* @__PURE__ */ jsxs(Fragment, { children: [onRevert === void 0 ? null : /* @__PURE__ */ jsx(Button, {
+				className: "text-muted-foreground hover:text-foreground",
+				disabled,
+				onClick: onRevert,
+				size,
+				variant: "ghost",
+				children: revertLabel
+			}), onReopen === void 0 ? null : /* @__PURE__ */ jsx(Button, {
+				"aria-label": reopenLabel,
+				disabled,
+				onClick: onReopen,
+				size: size === "xs" ? "icon-xs" : "icon-sm",
+				variant: "ghost",
+				children: /* @__PURE__ */ jsx(RotateCcwIcon, {})
+			})] });
+		default: return null;
+	}
+};
+//#endregion
+export { ReviewDecisionActions };

package/dist/review/review-diff-text.d.ts

@@ -0,0 +1,33 @@
+import { CSSProperties, ReactNode } from "react";
+//#region src/review/review-diff-text.d.ts
+declare const TRACKED_DELETION_STYLE: CSSProperties;
+declare const TRACKED_INSERTION_STYLE: CSSProperties;
+type ReviewDiffSegmentType = "equal" | "insert" | "delete";
+type ReviewDiffSegment = {
+  type: ReviewDiffSegmentType;
+  text: string;
+};
+type ReviewDiffProps = {
+  className?: string;
+  children: ReactNode;
+};
+/** Inserted text, wherever it is shown. */
+declare const ReviewDiffInsertion: ({ className, children }: ReviewDiffProps) => import("react").JSX.Element;
+/** Deleted text, wherever it is shown. */
+declare const ReviewDiffDeletion: ({ className, children }: ReviewDiffProps) => import("react").JSX.Element;
+type ReviewDiffTextProps = {
+  segments: readonly ReviewDiffSegment[];
+  className?: string;
+};
+/** A word-level diff rendered inline, in the product's one track-changes
+ *  language. */
+declare const ReviewDiffText: ({ segments, className }: ReviewDiffTextProps) => import("react").JSX.Element;
+/**
+ * A stable render key per segment. Type and text alone repeat inside a single
+ * diff (the same word deleted twice), so each repetition carries its
+ * occurrence count; the result is stable across renders of the same diff and
+ * never falls back to the array index.
+ */
+declare const reviewDiffSegmentKeys: (segments: readonly ReviewDiffSegment[]) => string[];
+//#endregion
+export { ReviewDiffDeletion, ReviewDiffInsertion, ReviewDiffSegment, ReviewDiffSegmentType, ReviewDiffText, TRACKED_DELETION_STYLE, TRACKED_INSERTION_STYLE, reviewDiffSegmentKeys };