themelia-react-ui 0.0.0-stage → 1.0.0

package/dist/components/features/global-search/global-search.types.d.ts

@@ -0,0 +1,105 @@
+import type { LucideIcon } from 'lucide-react';
+import type { ReactNode } from 'react';
+import type { SemanticTone } from '../../../lib/component-vocabulary';
+/** Subtle tone applied to thumbnail/avatar backgrounds. */
+export type GlobalSearchTone = Exclude<SemanticTone, 'secondary'>;
+/** A single piece of metadata rendered inline on the secondary line. */
+export interface GlobalSearchMeta {
+    /** Leading glyph. */
+    icon?: LucideIcon;
+    /** Display label. */
+    label: string;
+    /** Render the label as monospace + tabular-nums (SKUs, IDs, codes). */
+    mono?: boolean;
+}
+/** Status pill rendered next to the title. */
+export interface GlobalSearchBadge {
+    /** Display label. */
+    label: string;
+    /** Semantic tone driving the entry's colour. */
+    tone: Extract<SemanticTone, 'success' | 'warning' | 'destructive' | 'info' | 'secondary'>;
+}
+/** A single search result row. */
+export interface GlobalSearchResult<TGroup extends string = string> {
+    /** Unique identifier for keyboard navigation and onSelect payload. */
+    id: string;
+    /** Primary title — the only line guaranteed to render. */
+    title: string;
+    /** Secondary line — typically subtitle / description / tagline. */
+    subtitle?: string;
+    /** Group key — the result is bucketed under this in the list. */
+    group: TGroup;
+    /** Avatar (people-flavoured rows). */
+    avatar?: {
+        src?: string;
+        initials: string;
+        tone?: GlobalSearchTone;
+    };
+    /** Thumbnail (objects/items — bookings, products, files). */
+    thumbnail?: {
+        src?: string;
+        icon?: LucideIcon;
+        tone?: GlobalSearchTone;
+    };
+    /** Inline metadata items separated by `·` on the secondary line. */
+    meta?: GlobalSearchMeta[];
+    /** Plain-text tags rendered inline on the secondary line. */
+    tags?: string[];
+    /** Status pill rendered next to the title. */
+    badge?: GlobalSearchBadge;
+    /** Prominent value displayed on the right edge. */
+    rightValue?: string;
+    /** Subtle label under `rightValue` (e.g. "Total"). */
+    rightLabel?: string;
+    /** Recency hint — displayed at the trailing edge of the meta row. */
+    timestamp?: string;
+    /** Free-form payload forwarded to `onResultSelect`. */
+    data?: unknown;
+}
+/** Static section preset (recent, suggestions) shown when the query is empty. */
+export interface GlobalSearchIdleSection {
+    /** Stable identity for this entry. */
+    id: string;
+    /** Display label. */
+    label: string;
+    /** Leading glyph. */
+    icon?: LucideIcon;
+    items: Array<{
+        id: string;
+        label: string;
+        icon?: LucideIcon;
+        /** Run when clicked — typically `setQuery(item.label)`. */
+        onSelect?: () => void;
+    }>;
+}
+/** Tab definition rendered above the result list. */
+export interface GlobalSearchTab<TGroup extends string = string> {
+    /** "all" is treated specially; otherwise a group key from the results. */
+    value: 'all' | TGroup;
+    /** Display label. */
+    label: string;
+}
+/** Render-prop context handed to `renderResult`. */
+export interface GlobalSearchRenderResultContext {
+    isActive: boolean;
+    query: string;
+    /** Fired when an entry is activated. */
+    onSelect: () => void;
+}
+/** Slot map — every consumer-overridable surface. */
+export interface GlobalSearchSlots<TGroup extends string = string> {
+    /** Replaces the default search input (kbd-aware). */
+    input?: ReactNode;
+    /** Replaces the default tab strip. */
+    tabs?: ReactNode;
+    /** Rendered above the result list when `query.trim().length <= 1`. */
+    idle?: ReactNode;
+    /** Rendered when no results match and the query is long enough. */
+    empty?: ReactNode;
+    /** Rendered while loading results. */
+    loading?: ReactNode;
+    /** Rendered below the result list. */
+    footer?: ReactNode;
+    /** Per-result custom rendering. */
+    renderResult?: (result: GlobalSearchResult<TGroup>, ctx: GlobalSearchRenderResultContext) => ReactNode;
+}

package/dist/components/features/global-search/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useGlobalSearch } from './use-global-search';
+export type { UseGlobalSearchOptions, UseGlobalSearchReturn, } from './use-global-search';

package/dist/components/features/global-search/hooks/use-global-search.d.ts

@@ -0,0 +1,33 @@
+import type { GlobalSearchResult } from '../global-search.types';
+export interface UseGlobalSearchOptions<TGroup extends string = string> {
+    results: ReadonlyArray<GlobalSearchResult<TGroup>>;
+    query: string;
+    /** Fires when the user activates a row (Enter or click). */
+    onResultSelect?: (result: GlobalSearchResult<TGroup>) => void;
+    /** Fires when the user presses Escape. */
+    onClose?: () => void;
+}
+export interface UseGlobalSearchReturn<TGroup extends string = string> {
+    /** Results bucketed by group, in insertion order. */
+    grouped: Record<string, GlobalSearchResult<TGroup>[]>;
+    /** Result count per tab (`all` plus each group key). */
+    tabCounts: Record<string, number>;
+    /** Currently-selected tab. */
+    activeTab: 'all' | TGroup;
+    /** Set the active tab — also resets the active index. */
+    setActiveTab: (tab: 'all' | TGroup) => void;
+    /** Filtered grouped map respecting the active tab. */
+    visibleGrouped: Record<string, GlobalSearchResult<TGroup>[]>;
+    /** Flat ordered list matching what is currently rendered. */
+    flat: GlobalSearchResult<TGroup>[];
+    /** Index into `flat` of the currently-highlighted row. */
+    activeIdx: number;
+    setActiveIdx: (i: number) => void;
+    /** Programmatically activate a result by id. */
+    setActiveById: (id: string) => void;
+    /** Bind to the search input's `onKeyDown` for arrow / enter / escape support. */
+    onKeyDown: (e: React.KeyboardEvent) => void;
+    /** Activate the row at `activeIdx`. */
+    selectActive: () => void;
+}
+export declare function useGlobalSearch<TGroup extends string = string>({ results, query, onResultSelect, onClose, }: UseGlobalSearchOptions<TGroup>): UseGlobalSearchReturn<TGroup>;

package/dist/components/features/global-search/index.d.ts

@@ -0,0 +1,9 @@
+export { GlobalSearch } from './global-search';
+export type { GlobalSearchProps } from './global-search';
+export { GlobalSearchDialog } from './global-search-dialog';
+export type { GlobalSearchDialogProps } from './global-search-dialog';
+export { defaultGlobalSearchStrings, type GlobalSearchStrings, } from './global-search.strings';
+export type { GlobalSearchBadge, GlobalSearchIdleSection, GlobalSearchMeta, GlobalSearchRenderResultContext, GlobalSearchResult, GlobalSearchSlots, GlobalSearchTab, GlobalSearchTone, } from './global-search.types';
+export { GlobalSearchEmptyState, GlobalSearchFooter, GlobalSearchIdleState, GlobalSearchInput, GlobalSearchResultRow, GlobalSearchTabs, } from './partials';
+export type { GlobalSearchEmptyStateProps, GlobalSearchFooterProps, GlobalSearchIdleStateProps, GlobalSearchInputProps, GlobalSearchResultRowProps, GlobalSearchTabsProps, } from './partials';
+export { useGlobalSearch, type UseGlobalSearchOptions, type UseGlobalSearchReturn, } from './hooks';

package/dist/components/features/global-search/partials/global-search-empty-state.d.ts

@@ -0,0 +1,7 @@
+export interface GlobalSearchEmptyStateProps {
+    /** Surface title. */
+    title: string;
+    /** Short guidance shown beneath the control. */
+    hint: string;
+}
+export declare function GlobalSearchEmptyState({ title, hint }: GlobalSearchEmptyStateProps): import("react").JSX.Element;

package/dist/components/features/global-search/partials/global-search-footer.d.ts

@@ -0,0 +1,13 @@
+export interface GlobalSearchFooterProps {
+    /** Footer hint for the arrow keys. */
+    navigateLabel: string;
+    /** Footer hint for the enter key. */
+    openLabel: string;
+    /** Footer hint for the escape key. */
+    closeLabel: string;
+    /** Trailing right-aligned content (e.g. "3 results"). */
+    trailing?: React.ReactNode;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+export declare function GlobalSearchFooter({ navigateLabel, openLabel, closeLabel, trailing, className, }: GlobalSearchFooterProps): import("react").JSX.Element;

package/dist/components/features/global-search/partials/global-search-idle-state.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { GlobalSearchIdleSection } from '../global-search.types';
+export interface GlobalSearchIdleStateProps {
+    /** Sections to render, in display order. */
+    sections: ReadonlyArray<GlobalSearchIdleSection>;
+    /** Optional override for the heading icon when missing on a section. */
+    fallbackIcons?: {
+        recent?: React.ElementType;
+        suggestions?: React.ElementType;
+    };
+}
+export declare function GlobalSearchIdleState({ sections, fallbackIcons, }: GlobalSearchIdleStateProps): React.JSX.Element;

package/dist/components/features/global-search/partials/global-search-input.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+export interface GlobalSearchInputProps {
+    /** Current value. */
+    value: string;
+    /** Fired with the next value. */
+    onValueChange: (value: string) => void;
+    onKeyDown?: (e: React.KeyboardEvent) => void;
+    /** Shown while the value is empty. */
+    placeholder?: string;
+    /** Accessible name for the clear control. */
+    clearLabel?: string;
+    /** Shows the pending indicator. */
+    loading?: boolean;
+    /** Focuses the control on mount. */
+    autoFocus?: boolean;
+}
+export declare const GlobalSearchInput: React.ForwardRefExoticComponent<GlobalSearchInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/features/global-search/partials/global-search-result-row.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import type { GlobalSearchResult } from '../global-search.types';
+export interface GlobalSearchResultRowProps<TGroup extends string = string> {
+    /** The result this row represents. */
+    result: GlobalSearchResult<TGroup>;
+    /** Highlighted via keyboard nav. */
+    active?: boolean;
+    /** Current search text. */
+    query?: string;
+    /** Fired when an entry is activated. */
+    onSelect?: () => void;
+    onMouseEnter?: () => void;
+    /** Merged onto the outermost node. */
+    className?: string;
+}
+export declare function GlobalSearchResultRow<TGroup extends string = string>({ result, active, query, onSelect, onMouseEnter, className, }: GlobalSearchResultRowProps<TGroup>): React.JSX.Element;

package/dist/components/features/global-search/partials/global-search-tabs.d.ts

@@ -0,0 +1,13 @@
+export interface GlobalSearchTabsProps<TGroup extends string = string> {
+    /** Currently-selected tab. */
+    value: 'all' | TGroup;
+    onValueChange: (value: 'all' | TGroup) => void;
+    /** Tabs to offer, in display order. */
+    tabs: ReadonlyArray<{
+        value: 'all' | TGroup;
+        label: string;
+    }>;
+    /** Result counts shown beside each group. */
+    counts: Record<string, number>;
+}
+export declare function GlobalSearchTabs<TGroup extends string = string>({ value, onValueChange, tabs, counts, }: GlobalSearchTabsProps<TGroup>): import("react").JSX.Element;

package/dist/components/features/global-search/partials/index.d.ts

@@ -0,0 +1,12 @@
+export { GlobalSearchEmptyState } from './global-search-empty-state';
+export type { GlobalSearchEmptyStateProps } from './global-search-empty-state';
+export { GlobalSearchFooter } from './global-search-footer';
+export type { GlobalSearchFooterProps } from './global-search-footer';
+export { GlobalSearchIdleState } from './global-search-idle-state';
+export type { GlobalSearchIdleStateProps } from './global-search-idle-state';
+export { GlobalSearchInput } from './global-search-input';
+export type { GlobalSearchInputProps } from './global-search-input';
+export { GlobalSearchResultRow } from './global-search-result-row';
+export type { GlobalSearchResultRowProps } from './global-search-result-row';
+export { GlobalSearchTabs } from './global-search-tabs';
+export type { GlobalSearchTabsProps } from './global-search-tabs';

package/dist/components/features/global-search/partials/tone-palettes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Default tone palettes for thumbnails and avatars.
+ *
+ * Consumers can override per-call via `slots.toneBg` / `slots.toneAvatar`.
+ */
+import type { GlobalSearchTone } from '../global-search.types';
+export declare const DEFAULT_TONE_BG: Record<GlobalSearchTone, string>;
+export declare const DEFAULT_TONE_AVATAR: Record<GlobalSearchTone, string>;

package/dist/components/features/kanban/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useKanban, type UseKanbanOptions, type UseKanbanResult, } from './use-kanban';

package/dist/components/features/kanban/hooks/use-kanban.d.ts

@@ -0,0 +1,32 @@
+import type { KanbanItemMoveEvent, KanbanValue } from '../kanban.types';
+/**
+ * Headless hook — exposes the same state machine `<Kanban>` uses
+ * internally so consumers can build a fully custom UI against it.
+ *
+ *   const { findItem, move } = useKanban({ value, onValueChange,
+ *     getItemValue });
+ *   move({ itemId: 'card-1', toColumnId: 'shipped', toIndex: 0 });
+ */
+export interface UseKanbanOptions<T> {
+    value: KanbanValue<T>;
+    onValueChange: (next: KanbanValue<T>) => void;
+    getItemValue: (item: T) => string;
+    onItemMove?: (event: KanbanItemMoveEvent<T>) => void;
+}
+export interface UseKanbanResult<T> {
+    findItem: (id: string) => {
+        columnId: string;
+        index: number;
+        item: T;
+    } | undefined;
+    /**
+     * Move an item between columns / within the same column. Idempotent:
+     * a no-op move is safe.
+     */
+    move: (input: {
+        itemId: string;
+        toColumnId: string;
+        toIndex?: number;
+    }) => void;
+}
+export declare function useKanban<T>({ value, onValueChange, getItemValue, onItemMove, }: UseKanbanOptions<T>): UseKanbanResult<T>;

package/dist/components/features/kanban/index.d.ts

@@ -0,0 +1,5 @@
+export { Kanban, KanbanBoard, KanbanColumn, KanbanColumnContent, KanbanItem, KanbanItemActions, KanbanItemHandle, KanbanOverlay, } from './kanban';
+export { defaultKanbanStrings, interpolateKanbanString, type KanbanStrings, } from './kanban.strings';
+export type { KanbanBoardProps, KanbanColumnContentProps, KanbanColumnProps, KanbanContextShape, KanbanItemAction, KanbanItemActionsConfig, KanbanItemActionsProps, KanbanItemHandleProps, KanbanItemMoveEvent, KanbanItemProps, KanbanOverlayProps, KanbanProps, KanbanValue, } from './kanban.types';
+export { useKanban, type UseKanbanOptions, type UseKanbanResult, } from './hooks';
+export type { KanbanItemContextShape } from './kanban-context';

package/dist/components/features/kanban/kanban-context.d.ts

@@ -0,0 +1,25 @@
+import type { KanbanContextShape } from './kanban.types';
+export declare const KanbanContextProvider: import("react").Provider<KanbanContextShape<unknown> | null>;
+export declare function useKanbanContext<T = unknown>(): KanbanContextShape<T>;
+/**
+ * Internal context exposed by `<KanbanItem>` so the optional
+ * `<KanbanItemHandle>` knows which listeners + accessibility props to
+ * wire to the dedicated drag handle. Also carries the resolved
+ * domain item so `<KanbanItemActions>` (and any other item-aware
+ * subcomponent) can render per-item content without prop drilling.
+ *
+ * The dnd-kit shapes are widened to `unknown` so consumers can spread
+ * them onto any HTMLElement.
+ */
+export interface KanbanItemContextShape<T = unknown> {
+    listeners: unknown;
+    attributes: unknown;
+    setActivatorNodeRef: (node: HTMLElement | null) => void;
+    registerHandle: () => () => void;
+    /** Stable id (the value returned by `getItemValue`). */
+    itemId: string;
+    /** The domain item itself — null if it can't be resolved. */
+    item: T | null;
+}
+export declare const KanbanItemContextProvider: import("react").Provider<KanbanItemContextShape<unknown> | null>;
+export declare function useKanbanItemContext<T = unknown>(): KanbanItemContextShape<T>;

package/dist/components/features/kanban/kanban-keyboard.d.ts

@@ -0,0 +1,10 @@
+import type { KeyboardCoordinateGetter } from '@dnd-kit/core';
+export interface KanbanKeyboardPosition {
+    columnId: string;
+    index: number;
+}
+/** Resolve arrow movement from board order, including columns with no cards. */
+export declare function getKanbanKeyboardPosition(columns: Record<string, unknown[]>, position: KanbanKeyboardPosition, key: string): KanbanKeyboardPosition;
+export declare function createKanbanKeyboardCoordinates(value: Record<string, unknown[]>, getItemValue: (item: unknown) => string, findItem: (id: string) => KanbanKeyboardPosition | undefined, destination: {
+    current: KanbanKeyboardPosition | null;
+}, onPositionChange?: (position: KanbanKeyboardPosition) => void): KeyboardCoordinateGetter;

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

@@ -0,0 +1,38 @@
+import type { KanbanBoardProps, KanbanColumnContentProps, KanbanColumnProps, KanbanItemActionsProps, KanbanItemHandleProps, KanbanItemProps, KanbanOverlayProps, KanbanProps } from './kanban.types';
+export declare function Kanban<T>({ value, onValueChange, getItemValue, getItemLabel, getColumnLabel, onItemMove, itemActions, onItemClick, strings: stringsProp, className, children, }: KanbanProps<T>): import("react").JSX.Element;
+export declare namespace Kanban {
+    var displayName: string;
+}
+export declare function KanbanBoard({ className, style, children }: KanbanBoardProps): import("react").JSX.Element;
+export declare namespace KanbanBoard {
+    var displayName: string;
+}
+export declare function KanbanColumn({ value, className, children }: KanbanColumnProps): import("react").JSX.Element;
+export declare namespace KanbanColumn {
+    var displayName: string;
+}
+export declare function KanbanColumnContent({ value, className, children, }: KanbanColumnContentProps): import("react").JSX.Element;
+export declare namespace KanbanColumnContent {
+    var displayName: string;
+}
+export declare function KanbanItem({ value, className, disabled, onClick, children, }: KanbanItemProps): import("react").JSX.Element;
+export declare namespace KanbanItem {
+    var displayName: string;
+}
+export declare const KanbanItemHandle: import("react").ForwardRefExoticComponent<KanbanItemHandleProps & import("react").RefAttributes<HTMLButtonElement>>;
+/**
+ * Per-item actions menu (`⋮` trigger → popover with the actions
+ * registered at the `<Kanban itemActions>` root). Place inside any
+ * `<KanbanItem>` — typically in the card's top-right corner.
+ *
+ * The trigger marks itself with `data-stop-item-click` so opening the
+ * menu doesn't fire the parent `onItemClick` callback.
+ */
+export declare function KanbanItemActions<T = unknown>({ className, icon, ariaLabel, }: KanbanItemActionsProps): import("react").JSX.Element | null;
+export declare namespace KanbanItemActions {
+    var displayName: string;
+}
+export declare function KanbanOverlay<T = unknown>({ className, render }: KanbanOverlayProps<T>): import("react").JSX.Element;
+export declare namespace KanbanOverlay {
+    var displayName: string;
+}

package/dist/components/features/kanban/kanban.strings.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Strings for the Kanban — drag-and-drop screen-reader announcements
+ * + accessibility labels. The library never renders user-visible copy
+ * that the consumer hasn't already supplied via column headers / item
+ * children, so the strings here are exclusively for assistive tech.
+ */
+export interface KanbanStrings {
+    /** Read by screen readers when a drag begins. `{name}` = item label (or ID). */
+    announceDragStart: string;
+    /** Read when an item moves over a column. `{from}` / `{to}` are column labels; `{position}` is one-based. */
+    announceDragMove: string;
+    /** Read when an item is dropped into a column. */
+    announceDragEnd: string;
+    /** Read when the user cancels a drag with Escape. */
+    announceDragCancel: string;
+    /** Aria label on the drag handle. */
+    dragHandleAria: string;
+    /** Aria label on the board landmark. */
+    boardAria: string;
+    /** Aria label on the per-item actions trigger (`⋮`). */
+    itemActionsAria: string;
+}
+export declare const defaultKanbanStrings: KanbanStrings;
+export declare function interpolateKanbanString(template: string, params: Record<string, string>): string;

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

@@ -0,0 +1,168 @@
+import type { CSSProperties, ReactNode } from 'react';
+import type { StringsProp } from '../../../lib/strings';
+import type { ActionPresentation } from '../../../lib/action-presentation';
+import type { KanbanStrings } from './kanban.strings';
+/**
+ * The columns→items map. Keys are column ids; values are arrays of
+ * domain items. The library is generic in `T` — pass a `getItemValue`
+ * accessor that turns each item into a stable string id.
+ */
+export type KanbanValue<T = unknown> = Record<string, T[]>;
+/**
+ * A single action available on a Kanban item — surfaces inside the
+ * `<KanbanItemActions>` (`⋮`) shared `ActionMenu`. Mirrors the action
+ * definition shape used by table/card/page action chrome so consumers can
+ * re-use the same action concepts across surfaces.
+ */
+export interface KanbanItemAction<T = unknown> extends Omit<ActionPresentation, 'visible' | 'disabled'> {
+    /** Stable id used as React key + data-action attribute. */
+    id: string;
+    /** Visible label inside the popover. */
+    label: string;
+    /** Optional leading icon node. */
+    icon?: ReactNode;
+    /** Click handler — receives the item that owns this action. */
+    onClick: (item: T) => void;
+    /** Hide this action for some items (defaults to always visible). */
+    visible?: boolean | ((item: T) => boolean);
+    /** Disable this action for some items. */
+    disabled?: boolean | ((item: T) => boolean);
+}
+/**
+ * Static array OR factory that produces actions per item — same
+ * pattern as `DataTable.rowActions`. Use the factory form when the
+ * available actions depend on item state (e.g. a "Reopen" action only
+ * for items in the `done` column).
+ *
+ * (The exported name is `KanbanItemActionsConfig` so it doesn't clash
+ * with the runtime component `<KanbanItemActions>`.)
+ */
+export type KanbanItemActionsConfig<T = unknown> = ReadonlyArray<KanbanItemAction<T>> | ((item: T) => ReadonlyArray<KanbanItemAction<T>>);
+export interface KanbanContextShape<T = unknown> {
+    /** Current value. Controlled. */
+    value: KanbanValue<T>;
+    onValueChange: (next: KanbanValue<T>) => void;
+    getItemValue: (item: T) => string;
+    /** id of the item currently being dragged (null when idle). */
+    activeId: string | null;
+    /** Direct reference to the active item (null when idle). */
+    activeItem: T | null;
+    /** Resolve a (columnId, itemId) lookup → the item, or undefined. */
+    findItem: (id: string) => {
+        columnId: string;
+        index: number;
+        item: T;
+    } | undefined;
+    /** Item-level actions registered at the `<Kanban>` root, if any. */
+    itemActions?: KanbanItemActionsConfig<T>;
+    /** Item-level click handler. Fires on whole-card click; the drag
+     *  handle and action menu stop propagation so they don't trigger it. */
+    onItemClick?: (item: T) => void;
+}
+export interface KanbanProps<T = unknown> {
+    /** Current value. Controlled. */
+    value: KanbanValue<T>;
+    onValueChange: (next: KanbanValue<T>) => void;
+    getItemValue: (item: T) => string;
+    /** Readable item name for drag announcements; defaults to its ID. */
+    getItemLabel?: (item: T) => string;
+    /** Readable column name for drag announcements; defaults to its ID. */
+    getColumnLabel?: (columnId: string) => string;
+    /**
+     * Fires when an item is dropped into a different column. Use to mirror
+     * the change to your backend / optimistic update layer.
+     */
+    onItemMove?: (event: KanbanItemMoveEvent<T>) => void;
+    /**
+     * Item-level actions surfaced through `<KanbanItemActions>`. Pass a
+     * static array for actions that always appear, or a factory for
+     * per-item conditional actions (e.g. "Reopen" only on shipped items).
+     */
+    itemActions?: KanbanItemActionsConfig<T>;
+    /**
+     * Fires when the consumer clicks anywhere on a `<KanbanItem>` other
+     * than the drag handle or actions menu. Use to open a detail
+     * drawer, navigate, etc.
+     */
+    onItemClick?: (item: T) => void;
+    /** Strings for screen-reader announcements. */
+    strings?: StringsProp<KanbanStrings>;
+    /** Merged onto the outermost node. */
+    className?: string;
+    children?: ReactNode;
+}
+export interface KanbanItemMoveEvent<T = unknown> {
+    item: T;
+    itemId: string;
+    from: {
+        columnId: string;
+        index: number;
+    };
+    to: {
+        columnId: string;
+        index: number;
+    };
+}
+export interface KanbanBoardProps {
+    /** Merged onto the outermost node. */
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export interface KanbanColumnProps {
+    /** Stable column id — must be a key of the `KanbanValue` map. */
+    value: string;
+    /** Merged onto the outermost node. */
+    className?: string;
+    children?: ReactNode;
+}
+export interface KanbanColumnContentProps {
+    /** Same column id as its parent `<KanbanColumn>`. */
+    value: string;
+    /** Merged onto the outermost node. */
+    className?: string;
+    children?: ReactNode;
+}
+export interface KanbanItemProps {
+    /** Stable item id (the value returned by `getItemValue`). */
+    value: string;
+    /** Merged onto the outermost node. */
+    className?: string;
+    /**
+     * Disable dragging on this specific item — useful while a row is
+     * mid-mutation.
+     */
+    disabled?: boolean;
+    /**
+     * Per-item override for the root-level `onItemClick`. Falls back to
+     * the `onItemClick` registered on `<Kanban>` if omitted.
+     */
+    onClick?: () => void;
+    children?: ReactNode;
+}
+export interface KanbanItemHandleProps {
+    /** Merged onto the outermost node. */
+    className?: string;
+    children?: ReactNode;
+}
+export interface KanbanItemActionsProps {
+    /** Optional class on the trigger button. */
+    className?: string;
+    /** Override the trigger icon (defaults to a `⋮` MoreHorizontal). */
+    icon?: ReactNode;
+    /** aria-label on the trigger button. Defaults to `strings.itemActionsAria`. */
+    ariaLabel?: string;
+}
+export interface KanbanOverlayProps<T = unknown> {
+    /** Merged onto the outermost node. */
+    className?: string;
+    /**
+     * Render-prop alternative — receives the active item and column id, lets
+     * the consumer return any node. Defaults to a tinted dashed outline at
+     * the size of the source row.
+     */
+    render?: (ctx: {
+        item: T | null;
+        columnId: string | null;
+    }) => ReactNode;
+}

package/dist/components/features/map/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * features/map — package-owned Leaflet map surface plus place autocomplete.
+ *
+ * These are not shadcn primitives and not base wrappers. The family creates a
+ * React context, owns marker/layer/draw/fullscreen lifecycles behind seven
+ * callbacks, and carries the optional Leaflet peer set — so it lives in
+ * `features/` alongside the other callback-and-provider driven surfaces.
+ *
+ * It stays framework-agnostic: no router, i18n, or data-fetching imports.
+ * Consumers drive it entirely through props, callbacks, and strings.
+ */
+export * from './map';
+export * from './place-autocomplete';