themelia-react-ui 2.0.5 → 3.0.0

package/dist/components/features/filters/partials/async-options-status.d.ts

@@ -0,0 +1,32 @@
+interface AsyncOptionsStatusProps {
+    /** A request for the current query is in flight. */
+    fetching: boolean;
+    /** The last request for the current query failed. */
+    error: boolean;
+    onRetry: () => void;
+}
+/**
+ * Status above an async option list that still shows rows: the rows may be
+ * from the previous query, so a pending search is announced and a failed one
+ * offers Retry. The editor and the standalone facet share it. The pending
+ * search is announced by AsyncOptionsAnnouncer, so this row carries no role.
+ */
+export declare function AsyncOptionsStatus({ fetching, error, onRetry }: AsyncOptionsStatusProps): import("react").JSX.Element | null;
+interface AsyncOptionsAnnouncerProps {
+    /** A request for the current query is in flight. */
+    fetching: boolean;
+    /** The last request for the current query failed. */
+    error: boolean;
+    /** Options the current query returned. */
+    count: number;
+    /** The list shows rows, so its own empty status is not on screen. */
+    hasRows: boolean;
+}
+/**
+ * One persistent polite live region for an async option list: it says a
+ * search is pending while rows from the previous query are still shown, then
+ * how many options the settled query found. The empty and failed states
+ * announce themselves, so the region stays silent for them.
+ */
+export declare function AsyncOptionsAnnouncer({ fetching, error, count, hasRows }: AsyncOptionsAnnouncerProps): import("react").JSX.Element;
+export {};

package/dist/components/features/filters/partials/date-filter-content.d.ts

@@ -1,7 +1,8 @@
-import type { FilterConfig, FilterTriggerSource } from '../filters.types';
+import type { FilterConfig, FilterOperator, FilterTriggerSource } from '../filters.types';
 interface DateFilterContentProps {
     /** Definition of the filter this control edits. */
     filter: FilterConfig;
+    operator?: FilterOperator;
     /** Current value. */
     value: string[];
     /** Fired when the change filters change. */
@@ -10,5 +11,5 @@ interface DateFilterContentProps {
     /** Origin of the editor, which determines back-button behavior. */
     triggerSource?: FilterTriggerSource;
 }
-export declare function DateFilterContent({ filter, value, onFilterChange, onBackToFilterList, triggerSource, }: DateFilterContentProps): import("react").JSX.Element;
+export declare function DateFilterContent({ filter, operator, value, onFilterChange, onBackToFilterList, triggerSource, }: DateFilterContentProps): import("react").JSX.Element;
 export {};

package/dist/components/features/filters/partials/filter-draft-footer.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+interface FilterDraftFooterProps {
+    /** Supporting copy on the leading edge, such as the selected count. */
+    caption?: ReactNode;
+    /** Why the draft cannot be applied. Replaces the caption and disables Confirm. */
+    error?: string;
+    onConfirm: () => void;
+}
+/** Confirm footer shared by the editors that apply a draft. */
+export declare function FilterDraftFooter({ caption, error, onConfirm }: FilterDraftFooterProps): import("react").JSX.Element;
+export {};

package/dist/components/features/filters/partials/filter-operator-select.d.ts

@@ -6,10 +6,12 @@ export interface FilterOperatorSelectProps {
     /** Comparisons this filter offers. */
     operators: OperatorOption[];
     onOperatorChange: (operator: FilterOperator) => void;
+    /** Keeps the menu closed, for example while a filter change is applying. */
+    disabled?: boolean;
     /** Segment-reset classes forwarded by the parent pill so the trigger
      *  drops its base border + focus ring (it lives inside a segmented
      *  pill, not as a standalone button). */
-    segmentResetClass?: string;
+    segmentResetClassName?: string;
 }
 /**
  * FilterOperatorSelect — operator dropdown for an active filter pill.
@@ -19,4 +21,4 @@ export interface FilterOperatorSelectProps {
  * `header` slot supplies the "Operator" display label, and item rendering
  * keeps density-tokenized padding while primary labels follow Typography.
  */
-export declare function FilterOperatorSelect({ operator, operators, onOperatorChange, segmentResetClass, }: FilterOperatorSelectProps): React.JSX.Element;
+export declare function FilterOperatorSelect({ operator, operators, onOperatorChange, disabled, segmentResetClassName, }: FilterOperatorSelectProps): React.JSX.Element;

package/dist/components/features/filters/partials/filter-pill.d.ts

@@ -17,7 +17,11 @@ export interface FilterPillProps {
     availableFilters: FilterConfig[];
     /** Active regular filters list (for the popover header / context). */
     activeFilters: FilterConfig[];
-    /** External signal to suppress popover open during operator change. */
+    /**
+     * Optional flag a custom strip can read: it is true for 100 ms after an
+     * operator change, and the pill does not open its editor while it is set.
+     * Without it the editor opens as soon as it is asked to.
+     */
     operatorChangeRef?: React.MutableRefObject<boolean>;
 }
 export declare function FilterPill({ filter, value, active, operator, operators, onOperatorChange, onValueChange, onClear, availableFilters, activeFilters, operatorChangeRef, }: FilterPillProps): import("react").JSX.Element;

package/dist/components/features/filters/partials/filter-popover-content.d.ts

@@ -1,9 +1,11 @@
 import { type ComponentProps } from 'react';
 import { PopoverContent } from '../../../base/popover';
-import { type FilterConfig, type FilterTriggerSource } from '../filters.types';
+import { type FilterConfig, type FilterOperator, type FilterTriggerSource } from '../filters.types';
 export interface FilterPopoverContentProps {
     /** Which filter the popover is currently editing. */
     activeFilterInPopover: FilterConfig | null;
+    /** Active operator when the caller already owns the displayed selection. */
+    operator?: FilterOperator;
     /** Filters the user may add. */
     availableFilters: FilterConfig[];
     /** Filters currently applied. */
@@ -33,4 +35,4 @@ export interface FilterPopoverContentProps {
  * The component is used to wrap filter content in a consistent
  * popover interface across different filter types.
  */
-export declare function FilterPopoverContent({ activeFilterInPopover, availableFilters, activeFilters, getFilterValue, setFilterValue, onFilterSelect, onBackToFilterList, onClose, triggerSource, finalFocus, }: FilterPopoverContentProps): import("react").JSX.Element;
+export declare function FilterPopoverContent({ activeFilterInPopover, operator, availableFilters, activeFilters, getFilterValue, setFilterValue, onFilterSelect, onBackToFilterList, onClose, triggerSource, finalFocus, }: FilterPopoverContentProps): import("react").JSX.Element;

package/dist/components/features/filters/partials/filter-tabs.d.ts

@@ -5,7 +5,8 @@ export interface FilterTabsProps {
 }
 /**
  * Single-selection filter preset buttons with Base UI roving keyboard navigation.
- * These change filters rather than switch associated tab panels.
+ * These change filters rather than switch associated tab panels, so arrow keys
+ * only move focus; Enter, Space or a click applies a tab's presets.
  *
  * - "All" tab (empty presets): active when zero non-search active filters
  * - Named tabs: active when presets exactly match non-search active filters

package/dist/components/features/filters/partials/range-filter-content.d.ts

@@ -0,0 +1,12 @@
+import type { FilterConfig, FilterOperator, FilterTriggerSource } from '../filters.types';
+interface RangeFilterContentProps {
+    filter: FilterConfig;
+    operator: FilterOperator;
+    value: string[];
+    onFilterChange: (value: string[]) => void;
+    onBackToFilterList: () => void;
+    onClose: () => void;
+    triggerSource: FilterTriggerSource;
+}
+export declare function RangeFilterContent({ filter, operator, value, onFilterChange, onBackToFilterList, onClose, triggerSource }: RangeFilterContentProps): import("react").JSX.Element;
+export {};

package/dist/components/features/filters/partials/regular-filter-content.d.ts

@@ -1,4 +1,4 @@
-import { type FilterConfig, type FilterTriggerSource } from '../filters.types';
+import type { FilterConfig, FilterTriggerSource } from '../filters.types';
 interface RegularFilterContentProps {
     /** Definition of the filter this control edits. */
     filter: FilterConfig;

package/dist/components/features/filters/utils/filter-utils.d.ts

@@ -1,6 +1,10 @@
 import type { ReactNode } from 'react';
 import type { CascaderNode } from '../../../base/cascader';
-import type { FilterConfig, FilterDependency, FilterOption } from '../filters.types';
+import type { FilterConfig, FilterDependency, FilterOperator, FilterOption } from '../filters.types';
+export declare function getRangeBounds(value: readonly string[], operator?: FilterOperator): [min: string, max: string];
+export declare function isCompleteDateRange(value: readonly string[]): boolean;
+/** Filter dates use local calendar days or the app's explicit parameter format. */
+export declare function parseFilterDate(value: string | undefined, pattern?: string): Date | undefined;
 /**
  * The option for a value and its ancestors, searching nested options.
  */
@@ -27,14 +31,36 @@ export declare function getFilterOptionLabel(filter: FilterConfig, value: string
  */
 export declare function getFilterOptionIcon(filter: FilterConfig, value: string): ReactNode | undefined;
 /**
- * Validates a filter value against the filter configuration
+ * Validates a filter value against the filter configuration.
+ *
+ * The provider holds every value as a string array, so an array is checked
+ * entry by entry: `required` rejects an empty array, `pattern` tests each
+ * non-empty entry, and `min`/`max` test each bound of a RANGE filter. A scalar
+ * number or string is checked directly, as before. `custom` receives the
+ * whole value.
  *
  * @param filter - The filter configuration to validate against
  * @param value - The value to validate
- * @param t
+ * @param t - Resolves a `validation.*` string path to its copy
  * @returns true if valid, or an error message string if invalid
  */
 export declare function validateFilterValue(filter: FilterConfig, value: unknown, t: (key: string) => string): boolean | string;
+/**
+ * The message to show for a draft that fails its filter's `validation`, or
+ * undefined when it may be applied. A bare `false` reads as an invalid format.
+ */
+export declare function getFilterValidationMessage(filter: FilterConfig, value: unknown, strings: {
+    validation: {
+        required: string;
+        minValue: string;
+        maxValue: string;
+        invalidFormat: string;
+    };
+}): string | undefined;
+/** Whether a filter holds several values: MULTI_SELECT, TAGS, or any filter with `multiple`. */
+export declare function isMultiValueFilter(config: Pick<FilterConfig, 'type' | 'multiple'>): boolean;
+/** Whether two filter values hold the same entries in the same order. */
+export declare function isSameFilterValue(a: readonly string[] | undefined, b: readonly string[] | undefined): boolean;
 /**
  * Formats a filter value for display using either the format function provided
  * in the filter config, or by looking up option labels
@@ -45,11 +71,14 @@ export declare function validateFilterValue(filter: FilterConfig, value: unknown
  */
 export declare function formatFilterValue(filter: FilterConfig, value: unknown): string;
 /**
- * Gets the values of dependent filters
+ * Gets the values of dependent filters. A headless helper for
+ * `FilterConfig.dependencies`; FilterLayout does not call it.
  */
 export declare function getDependentFilterValues(dependencies: FilterDependency[], filterState: Record<string, string[]>): Record<string, string[]>;
 /**
- * Determines if a filter should be shown based on its dependencies
+ * Determines if a filter should be shown based on its dependencies. A
+ * headless helper for `FilterConfig.dependencies`; FilterLayout does not call it.
  */
 export declare function shouldShowFilter(filter: FilterConfig, filterState: Record<string, string[]>): boolean;
+/** Reads `FilterConfig.defaultValue` per key. A headless helper; the provider does not call it. */
 export declare function extractFilterDefaults<T extends string = string>(filters: FilterConfig[]): Record<T, string>;

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

@@ -4,10 +4,16 @@ export interface GlobalSearchDialogProps<TGroup extends string = string> extends
     open: boolean;
     /** Open-state callback. Fires on Escape, backdrop click, and result selection. */
     onOpenChange: (open: boolean) => void;
+    /**
+     * Closes the palette after a result is chosen, once `onResultSelect` has run.
+     * Default: `true`. Set `false` to keep it open, for example to pick several
+     * results in a row.
+     */
+    closeOnSelect?: boolean;
     /** Classes for the dialog surface that positions the palette. */
     contentClassName?: string;
 }
-export declare function GlobalSearchDialog<TGroup extends string = string>({ open, onOpenChange, contentClassName, className, strings: stringsProp, autoFocus, ...searchProps }: GlobalSearchDialogProps<TGroup>): import("react").JSX.Element;
+export declare function GlobalSearchDialog<TGroup extends string = string>({ open, onOpenChange, contentClassName, className, strings: stringsProp, autoFocus, closeOnSelect, onResultSelect, ...searchProps }: GlobalSearchDialogProps<TGroup>): import("react").JSX.Element;
 export declare namespace GlobalSearchDialog {
     var displayName: string;
 }

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

@@ -34,6 +34,12 @@ export interface GlobalSearchProps<TGroup extends string = string> {
     onClose?: () => void;
     /** Loading flag — switches the input spinner and renders the loading slot. */
     loading?: boolean;
+    /**
+     * Characters (without surrounding whitespace) a query needs before an empty
+     * result list reads as "no results". Shorter queries show the idle content,
+     * or a hint when there is none. Default: `2`.
+     */
+    minQueryLength?: number;
     /** Idle-state sections (Recent / Suggestions / …). */
     idleSections?: ReadonlyArray<GlobalSearchIdleSection>;
     /** Override default group labels in the tab strip. */
@@ -49,4 +55,4 @@ export interface GlobalSearchProps<TGroup extends string = string> {
     /** Wrapper className. */
     className?: string;
 }
-export declare function GlobalSearch<TGroup extends string = string>({ results, query, onQueryChange, onResultSelect, onClose, loading, idleSections, groupLabels, autoFocus, strings: stringsProp, slots, tabs, className, }: GlobalSearchProps<TGroup>): React.JSX.Element;
+export declare function GlobalSearch<TGroup extends string = string>({ results, query, onQueryChange, onResultSelect, onClose, loading, minQueryLength, idleSections, groupLabels, autoFocus, strings: stringsProp, slots, tabs, className, }: GlobalSearchProps<TGroup>): React.JSX.Element;

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

@@ -16,10 +16,15 @@ export interface GlobalSearchStrings {
     emptyTitle: string;
     /** Empty-state body copy. */
     emptyHint: string;
-    /** Idle-state heading for "Recent" suggestions. */
+    /** Heading for the first idle section when it supplies no `label`. */
     idleRecent: string;
-    /** Idle-state heading for curated "Suggestions". */
+    /** Heading for every later idle section that supplies no `label`. */
     idleSuggestions: string;
+    /**
+     * Shown when something was typed but the query is still shorter than
+     * `minQueryLength` and there is no idle content. `{{count}}` is the threshold.
+     */
+    idleHint?: string;
     /** Tab label for the "All" tab. */
     tabAll: string;
     /** Footer "navigate" hint. */
@@ -28,9 +33,20 @@ export interface GlobalSearchStrings {
     footerOpen: string;
     /** Footer "close" hint. */
     footerClose: string;
-    /** Trailing N results count. */
+    /** Trailing N results count, as a `{{count}}` template. */
     resultsCount: string;
+    /**
+     * Builds the results count from the number, for languages whose plural forms
+     * a single template cannot express. Wins over `resultsCount` when supplied.
+     */
+    formatResultsCount?: (count: number) => string;
     /** "See all" group action — jumps to that tab. */
     seeAll: string;
 }
 export declare const defaultGlobalSearchStrings: GlobalSearchStrings;
+/**
+ * Count copy for the footer and the status announcement. The untouched English
+ * template reads "1 result" for a single hit; an overridden template is used
+ * as written, and `formatResultsCount` takes over entirely.
+ */
+export declare function formatGlobalSearchResultsCount(strings: GlobalSearchStrings, count: number): string;

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

@@ -1,5 +1,5 @@
 import type { LucideIcon } from 'lucide-react';
-import type { ReactNode } from 'react';
+import type { KeyboardEvent, ReactNode } from 'react';
 import type { SemanticTone } from '../../../lib/component-vocabulary';
 /** Subtle tone applied to thumbnail/avatar backgrounds. */
 export type GlobalSearchTone = Exclude<SemanticTone, 'secondary'>;
@@ -60,8 +60,11 @@ export interface GlobalSearchResult<TGroup extends string = string> {
 export interface GlobalSearchIdleSection {
     /** Stable identity for this entry. */
     id: string;
-    /** Display label. */
-    label: string;
+    /**
+     * Section heading. When omitted, `GlobalSearch` uses `strings.idleRecent`
+     * for the first section and `strings.idleSuggestions` for the others.
+     */
+    label?: string;
     /** Leading glyph. */
     icon?: LucideIcon;
     items: Array<{
@@ -88,13 +91,34 @@ export interface GlobalSearchRenderResultContext {
     /** Id of the option wrapping this row, which the search field names as its active descendant. */
     optionId?: string;
 }
+/** What a replacement search input needs to drive the result list from the keyboard. */
+export interface GlobalSearchInputSlotContext {
+    /** Current query. */
+    query: string;
+    /** Reports the next query. */
+    onQueryChange: (query: string) => void;
+    /** Arrow, Enter and Escape handling. Bind it to the input's `onKeyDown`. */
+    onKeyDown: (event: KeyboardEvent) => void;
+    /** Whether results are showing (`aria-expanded`). */
+    expanded: boolean;
+    /** Ids of the result listboxes (`aria-controls`). */
+    controls: string;
+    /** Id of the highlighted option (`aria-activedescendant`). */
+    activeDescendant: string | undefined;
+    /** Whether results are loading. */
+    loading: boolean;
+}
 /** 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 search input. Pass a function to receive the key
+     * handler and combobox state, so the replacement keeps arrow-key navigation;
+     * a plain node renders as given and has no keyboard navigation.
+     */
+    input?: ReactNode | ((context: GlobalSearchInputSlotContext) => ReactNode);
     /** Replaces the default tab strip. */
     tabs?: ReactNode;
-    /** Rendered above the result list when `query.trim().length <= 1`. */
+    /** Rendered above the result list while the query is shorter than `minQueryLength`. */
     idle?: ReactNode;
     /** Rendered when no results match and the query is long enough. */
     empty?: ReactNode;

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

@@ -3,7 +3,7 @@ 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 type { GlobalSearchBadge, GlobalSearchIdleSection, GlobalSearchInputSlotContext, 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-idle-state.d.ts

@@ -8,5 +8,10 @@ export interface GlobalSearchIdleStateProps {
         recent?: React.ElementType;
         suggestions?: React.ElementType;
     };
+    /** Headings for sections that supply no `label`: `recent` for the first section, `suggestions` for the rest. */
+    fallbackLabels?: {
+        recent?: string;
+        suggestions?: string;
+    };
 }
-export declare function GlobalSearchIdleState({ sections, fallbackIcons, }: GlobalSearchIdleStateProps): React.JSX.Element;
+export declare function GlobalSearchIdleState({ sections, fallbackIcons, fallbackLabels, }: GlobalSearchIdleStateProps): React.JSX.Element;

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

@@ -23,5 +23,7 @@ export interface GlobalSearchInputProps {
     controls?: string;
     /** Id of the highlighted result, announced as the active option. */
     activeDescendant?: string;
+    /** Merged onto the outermost node. */
+    className?: string;
 }
 export declare const GlobalSearchInput: React.ForwardRefExoticComponent<GlobalSearchInputProps & React.RefAttributes<HTMLInputElement>>;

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

@@ -1,5 +1,5 @@
-export { Kanban, KanbanBoard, KanbanColumn, KanbanColumnContent, KanbanItem, KanbanItemActions, KanbanItemHandle, KanbanOverlay, } from './kanban';
+export { Kanban, KanbanBoard, KanbanColumn, KanbanColumnContent, KanbanItem, KanbanItemActions, KanbanItemHandle, KanbanItemTrigger, 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 type { KanbanBoardProps, KanbanColumnContentProps, KanbanColumnProps, KanbanContextShape, KanbanItemAction, KanbanItemActionsConfig, KanbanItemActionsProps, KanbanItemHandleProps, KanbanItemMoveEvent, KanbanItemProps, KanbanItemTriggerProps, 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

@@ -16,10 +16,14 @@ export interface KanbanItemContextShape<T = unknown> {
     attributes: unknown;
     setActivatorNodeRef: (node: HTMLElement | null) => void;
     registerHandle: () => () => void;
+    /** Registered by `<KanbanItemTrigger>`, so the card adds no open control of its own. */
+    registerTrigger?: () => () => void;
     /** Stable id (the value returned by `getItemValue`). */
     itemId: string;
     /** The domain item itself — null if it can't be resolved. */
     item: T | null;
+    /** Opens the card: its own `onClick`, else the root `onItemClick`. Unset when neither exists. */
+    activate?: () => void;
 }
 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

@@ -3,8 +3,13 @@ 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;
+/**
+ * Resolve arrow movement from board order, including columns with no cards.
+ * `sourceColumnId` is the column the dragged card came from: in any other
+ * column the slot after the last card is a valid destination, while inside
+ * its own column the card can only take the place of an existing one.
+ */
+export declare function getKanbanKeyboardPosition(columns: Record<string, unknown[]>, position: KanbanKeyboardPosition, key: string, sourceColumnId?: 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

@@ -1,4 +1,4 @@
-import type { KanbanBoardProps, KanbanColumnContentProps, KanbanColumnProps, KanbanItemActionsProps, KanbanItemHandleProps, KanbanItemProps, KanbanOverlayProps, KanbanProps } from './kanban.types';
+import type { KanbanBoardProps, KanbanColumnContentProps, KanbanColumnProps, KanbanItemActionsProps, KanbanItemHandleProps, KanbanItemProps, KanbanItemTriggerProps, 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;
@@ -20,6 +20,15 @@ export declare namespace KanbanItem {
     var displayName: string;
 }
 export declare const KanbanItemHandle: import("react").ForwardRefExoticComponent<KanbanItemHandleProps & import("react").RefAttributes<HTMLButtonElement>>;
+/**
+ * The card's primary control: a real button, usually around the title, that
+ * opens the card (`KanbanItem onClick`, else the root `onItemClick`). It is
+ * the keyboard path for a card that has a `<KanbanItemHandle>`; the whole-card
+ * click stays as a wider pointer target. Without a click handler it renders
+ * its children as plain text. A card without a handle is itself the drag
+ * control and opens with Enter, so it needs no trigger.
+ */
+export declare const KanbanItemTrigger: import("react").ForwardRefExoticComponent<KanbanItemTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
 /**
  * Per-item actions menu (`⋯` trigger → popover with the actions
  * registered at the `<Kanban itemActions>` root). Place inside any

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

@@ -13,12 +13,21 @@ export interface KanbanStrings {
     announceDragEnd: string;
     /** Read when the user cancels a drag with Escape. */
     announceDragCancel: string;
-    /** Aria label on the drag handle. */
+    /**
+     * Accessible name of a drag handle that carries no text of its own.
+     * `{name}` = item label (or ID), so each card's handle is told apart.
+     */
     dragHandleAria: string;
     /** Aria label on the board landmark. */
     boardAria: string;
     /** Aria label on the per-item actions trigger (`⋯`). */
     itemActionsAria: string;
+    /**
+     * Accessible name of the open control a card gets when it has a drag
+     * handle, something to open and no `KanbanItemTrigger`. `{name}` = item
+     * label (or ID). Optional for existing complete string objects.
+     */
+    openItemAria?: string;
 }
-export declare const defaultKanbanStrings: KanbanStrings;
+export declare const defaultKanbanStrings: KanbanStrings & Required<Pick<KanbanStrings, 'openItemAria'>>;
 export declare function interpolateKanbanString(template: string, params: Record<string, string>): string;

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

@@ -58,6 +58,15 @@ export interface KanbanContextShape<T = unknown> {
     /** 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;
+    /** Readable item name, as passed to the root. */
+    getItemLabel?: (item: T) => string;
+    /** The board's resolved strings. */
+    strings?: KanbanStrings;
+    /**
+     * Registered by a card that is its own drag activator and has something to
+     * open, so the board keeps Enter for opening it. Returns the unregister.
+     */
+    registerEnterActivation?: () => () => void;
 }
 export interface KanbanProps<T = unknown> {
     /** Current value. Controlled. */
@@ -83,6 +92,12 @@ export interface KanbanProps<T = unknown> {
      * 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.
+     *
+     * Keyboard: a card with a `KanbanItemHandle` opens through its
+     * `KanbanItemTrigger` (a real button, usually around the title). Without
+     * one the card adds its own open button, named `strings.openItemAria`,
+     * which frames the card on focus. A card without a handle is itself the
+     * drag control, so it opens with Enter and is picked up with Space.
      */
     onItemClick?: (item: T) => void;
     /** Strings for screen-reader announcements. */
@@ -143,6 +158,17 @@ export interface KanbanItemProps {
 export interface KanbanItemHandleProps {
     /** Merged onto the outermost node. */
     className?: string;
+    /**
+     * Accessible name. Defaults to `strings.dragHandleAria` when the handle's
+     * children carry no text (an icon); a handle with text names itself.
+     */
+    ariaLabel?: string;
+    children?: ReactNode;
+}
+export interface KanbanItemTriggerProps {
+    /** Merged onto the button. */
+    className?: string;
+    /** The card's primary label, usually its title. */
     children?: ReactNode;
 }
 export interface KanbanItemActionsProps {

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

@@ -56,11 +56,15 @@ interface MapLayerGroupOption extends Pick<React.ComponentProps<typeof DropdownM
     name: string;
 }
 interface MapLayersContextType {
+    /** Adds the layer, or replaces the entry of the same name in place. */
     registerTileLayer: (layer: MapTileLayerOption) => void;
+    unregisterTileLayer: (name: string) => void;
     tileLayers: MapTileLayerOption[];
     selectedTileLayer: string;
     setSelectedTileLayer: (name: string) => void;
+    /** Adds the group, or replaces the entry of the same name in place. */
     registerLayerGroup: (layer: MapLayerGroupOption) => void;
+    unregisterLayerGroup: (name: string) => void;
     layerGroups: MapLayerGroupOption[];
     activeLayerGroups: string[];
     setActiveLayerGroups: (names: string[]) => void;

package/dist/components/features/map/place-autocomplete.d.ts

@@ -12,6 +12,12 @@ type Feature<TGeometry, TProperties> = {
     bbox?: BBox;
 };
 interface PlaceFeatureProperties {
+    /**
+     * With `osm_type`, the result's identity: OSM ids are unique per element
+     * type only, so a node and a way may share a number. A `searchPlaces`
+     * adapter for another provider must give every result its own
+     * `osm_type` + `osm_id` pair; results repeating a pair are dropped.
+     */
     osm_id: number;
     osm_type: "N" | "W" | "R";
     osm_key: string;
@@ -74,7 +80,10 @@ interface PlaceSearchOptions {
      */
     locationBiasScale?: number;
 }
-/** Consumer-owned geocoding integration. Keep callback identity stable until its provider changes. */
+/**
+ * Consumer-owned geocoding integration. Keep callback identity stable until its
+ * provider changes. Each result is identified by `osm_type` + `osm_id`.
+ */
 type PlaceSearchCallback = (options: PlaceSearchOptions, signal: AbortSignal) => Promise<PlaceFeature[]>;
 interface PlaceAutocompleteProps extends Omit<PlaceSearchOptions, "query">, Omit<React.ComponentProps<"input">, "value" | "onChange"> {
     debounceMs?: number;

package/dist/components/features/media-library/hooks/use-media-library.d.ts

@@ -1,5 +1,7 @@
 import type { MediaLibraryAccessors, MediaLibraryItem, ResolvedMediaLibraryAccessors, UseMediaLibraryOptions, MediaLibraryState } from '../media-library.types';
+/** The upload tab's accepted types unless the consumer configures others. */
+export declare const DEFAULT_MEDIA_UPLOAD_ACCEPT = "image/*,video/*";
 export declare function resolveMediaLibraryAccessors<TItem = MediaLibraryItem>(accessors?: MediaLibraryAccessors<TItem>): ResolvedMediaLibraryAccessors<TItem>;
 export declare function formatMediaLibrarySize(bytes?: number): string;
 export declare function getMediaLibraryDimensions<TItem>(item: TItem, accessors: ResolvedMediaLibraryAccessors<TItem>): string;
-export declare function useMediaLibrary<TItem = MediaLibraryItem>({ items: itemsProp, fetcher, accessors: accessorsProp, selectionMode, value, defaultValue, onValueChange, onItemUpdate, onItemDelete, onUpload, onError, tab: tabProp, defaultTab, onTabChange, view: viewProp, defaultView, onViewChange, query: queryProp, defaultQuery, onQueryChange, type: typeProp, defaultType, onTypeChange, collection: collectionProp, defaultCollection, onCollectionChange, sort: sortProp, defaultSort, onSortChange, uploadOptions: uploadOptionsProp, defaultUploadOptions, onUploadOptionsChange, selecting: selectingProp, defaultSelecting, onSelectingChange, }?: UseMediaLibraryOptions<TItem>): MediaLibraryState<TItem>;
+export declare function useMediaLibrary<TItem = MediaLibraryItem>({ items: itemsProp, fetcher, refreshKey, pageSize, accessors: accessorsProp, selectionMode, value, defaultValue, onValueChange, onItemUpdate, onItemDelete, onUpload, uploadAccept, maxFileSize, maxFiles, uploadFailedMessage, onError, tab: tabProp, defaultTab, onTabChange, view: viewProp, defaultView, onViewChange, query: queryProp, defaultQuery, onQueryChange, type: typeProp, defaultType, onTypeChange, collection: collectionProp, defaultCollection, onCollectionChange, sort: sortProp, defaultSort, onSortChange, uploadOptions: uploadOptionsProp, defaultUploadOptions, onUploadOptionsChange, selecting: selectingProp, defaultSelecting, onSelectingChange, }?: UseMediaLibraryOptions<TItem>): MediaLibraryState<TItem>;

package/dist/components/features/media-library/media-library.d.ts

@@ -1,3 +1,3 @@
 import type { MediaLibraryDialogProps, MediaLibraryProps } from './media-library.types';
-export declare function MediaLibrary<TItem = import('./media-library.types').MediaLibraryItem>({ title, titleSuffix, description, confirmLabel, cancelLabel, selectionMode, density, showMeta, allowUpload, typeFilters, confirmOnSelect, onConfirm, onCancel, onClose, bulkActions, strings: stringsProp, slots, heightClassName, className, items, fetcher, accessors, collections, value, defaultValue, onValueChange, onItemUpdate, onItemDelete, onItemReplace, onItemOpen, onUpload, onError, selecting, defaultSelecting, onSelectingChange, tab, defaultTab, onTabChange, view, defaultView, onViewChange, query, defaultQuery, onQueryChange, type, defaultType, onTypeChange, collection, defaultCollection, onCollectionChange, sort, defaultSort, onSortChange, uploadOptions, defaultUploadOptions, onUploadOptionsChange, ...props }: MediaLibraryProps<TItem>): import("react").JSX.Element;
+export declare function MediaLibrary<TItem = import('./media-library.types').MediaLibraryItem>({ title, titleSuffix, description, confirmLabel, cancelLabel, selectionMode, density, showMeta, allowUpload, typeFilters, confirmOnSelect, onConfirm, onCancel, onClose, bulkActions, strings: stringsProp, slots, heightClassName, className, items, fetcher, refreshKey, pageSize, accessors, collections, value, defaultValue, onValueChange, onItemUpdate, onItemDelete, onItemReplace, onItemOpen, onUpload, uploadAccept, maxFileSize, maxFiles, uploadFailedMessage, onError, selecting, defaultSelecting, onSelectingChange, tab, defaultTab, onTabChange, view, defaultView, onViewChange, query, defaultQuery, onQueryChange, type, defaultType, onTypeChange, collection, defaultCollection, onCollectionChange, sort, defaultSort, onSortChange, uploadOptions, defaultUploadOptions, onUploadOptionsChange, ...props }: MediaLibraryProps<TItem>): import("react").JSX.Element;
 export declare function MediaLibraryDialog<TItem = import('./media-library.types').MediaLibraryItem>({ open, onOpenChange, trigger, dialogTitle, dialogDescription, onClose, className, dialogClassName, contentClassName, closeOnEscape, closeOnBackdropClick, ...props }: MediaLibraryDialogProps<TItem>): import("react").JSX.Element;