@sesamehr/react-design-system 1.1.0 → 1.3.0

package/dist/Button/Button.d.ts

@@ -7,6 +7,6 @@ export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElemen
 }
 /**
  * Button — mirrors `@sesame/orxata-core` Button.
- * `asChild` replaces reka-ui's `<Primitive as-child>` via `@radix-ui/react-slot`.
+ * `asChild` renders the child element instead of a `<button>`, via `@radix-ui/react-slot`.
  */
 export declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Data/Table/TableBody/TableBody.d.ts

@@ -15,7 +15,6 @@ export interface TableBodyProps extends React.ComponentPropsWithoutRef<'tbody'>
 }
 /**
  * Styled `<tbody>`. When `draggable`, wraps rows in a dnd-kit sortable
- * context — replacing the Vue `vue-draggable-plus` (Sortable.js) integration.
- * Sortable item ids are derived from the index of each `items` entry.
+ * context. Sortable item ids are derived from the index of each `items` entry.
  */
 export declare const TableBody: import('react').ForwardRefExoticComponent<TableBodyProps & import('react').RefAttributes<HTMLTableSectionElement>>;

package/dist/Feedback/Alert/Alert.d.ts

@@ -4,15 +4,17 @@ export interface AlertProps extends Omit<React.HTMLAttributes<HTMLDivElement>, '
     dismissible?: boolean;
     collapsible?: boolean;
     isOpen?: boolean;
-    /** Emitted when the alert is dismissed (maps Vue `dismissed`). */
+    /** Called once the alert has been dismissed. */
     onDismissed?: () => void;
-    /** Emitted with the next open state (maps Vue `update:isOpen`). */
+    /** Called with the next open state — the controlled half of `isOpen`. */
     onOpenChange?: (isOpen: boolean) => void;
-    /** Emitted with the next open state (maps Vue `toggled`). */
+    /** Called with the next open state when the collapsible toggle is used. */
     onToggled?: (open: boolean) => void;
 }
 /**
- * Alert — mirrors `@sesame/orxata-core` Alert.
- * Vue `provide/inject` context becomes React context (`AlertContext`).
+ * Alert.
+ *
+ * The parts share dismissal and collapsible state through `AlertContext`, so
+ * each one decides its own visibility rather than being told by the root.
  */
 export declare const Alert: import('react').ForwardRefExoticComponent<AlertProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Feedback/Dialog/Dialog.d.ts

@@ -5,7 +5,7 @@ export interface DialogProps {
     onOpenChange?: (open: boolean) => void;
     modal?: boolean;
 }
-/** Dialog — maps reka-ui `DialogRoot` to `@radix-ui/react-dialog`. */
+/** Dialog root — built on `@radix-ui/react-dialog`. */
 export declare const Dialog: {
     ({ children, defaultOpen, open, onOpenChange, modal, }: DialogProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;

package/dist/Feedback/Dialog/DialogTwoPanelContent.d.ts

@@ -1,7 +1,7 @@
 import * as DialogPrimitive from '@radix-ui/react-dialog';
 export interface DialogTwoPanelContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
     showCloseButton?: boolean;
-    /** Aside panel content (maps Vue `#aside` slot). */
+    /** Content of the side panel, beside the main one. */
     aside?: React.ReactNode;
 }
 /** DialogTwoPanelContent — two-column dialog (main + aside) with close button. */

package/dist/Feedback/Popover/Popover.d.ts

@@ -1,5 +1,5 @@
 export interface PopoverProps {
-    /** Trigger element (maps Vue `#trigger` slot); rendered via Radix `asChild`. */
+    /** Element that opens the popover; rendered via Radix `asChild`. */
     trigger?: React.ReactNode;
     children?: React.ReactNode;
     defaultOpen?: boolean;
@@ -7,7 +7,7 @@ export interface PopoverProps {
     onOpenChange?: (open: boolean) => void;
     modal?: boolean;
 }
-/** Popover — maps reka-ui `PopoverRoot/Trigger` to `@radix-ui/react-popover`. */
+/** Popover — built on `@radix-ui/react-popover`, root and trigger in one. */
 export declare const Popover: {
     ({ trigger, children, defaultOpen, open, onOpenChange, modal, }: PopoverProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;

package/dist/Feedback/Tooltip/Tooltip.d.ts

@@ -1,5 +1,5 @@
 export interface TooltipProps {
-    /** Trigger element (maps Vue `#trigger` slot); rendered via Radix `asChild`. */
+    /** Element the tooltip describes; rendered via Radix `asChild`. */
     trigger?: React.ReactNode;
     children?: React.ReactNode;
     defaultOpen?: boolean;
@@ -9,7 +9,7 @@ export interface TooltipProps {
     skipDelayDuration?: number;
     disableHoverableContent?: boolean;
 }
-/** Tooltip — maps reka-ui `TooltipProvider/Root/Trigger` to `@radix-ui/react-tooltip`. */
+/** Tooltip — built on `@radix-ui/react-tooltip`, provider and root in one. */
 export declare const Tooltip: {
     ({ trigger, children, defaultOpen, open, onOpenChange, delayDuration, skipDelayDuration, disableHoverableContent, }: TooltipProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;

package/dist/Forms/Inputs/Combobox/Combobox.d.ts

@@ -19,9 +19,9 @@ export interface ComboboxProps extends Omit<React.HTMLAttributes<HTMLDivElement>
     dataTestid: string;
 }
 /**
- * Combobox root — replaces reka-ui `ComboboxRoot`.
+ * Combobox root.
  *
- * reka had no React equivalent, so this is `@radix-ui/react-popover` for the
+ * Radix ships no combobox, so this is `@radix-ui/react-popover` for the
  * open/close shell plus a small context (see `context.ts`) carrying the
  * selection, `multiple`, `disabled` and search state that the parts share.
  */

package/dist/Forms/Inputs/Combobox/ComboboxChipsInput.d.ts

@@ -7,7 +7,7 @@ export interface ComboboxChipsInputProps extends Omit<React.InputHTMLAttributes<
     trigger?: React.ReactNode;
 }
 /**
- * ComboboxChipsInput — replaces reka `ComboboxChipsInput`.
+ * ComboboxChipsInput — the search field with the current selection as chips.
  * Multi-select field: renders the selected values as removable chips (read from
  * the shared `multiple` model) alongside the search field.
  */

package/dist/Forms/Inputs/Combobox/ComboboxContent.d.ts

@@ -5,7 +5,7 @@ export interface ComboboxContentProps extends Omit<React.ComponentPropsWithoutRe
     align?: 'start' | 'center' | 'end';
 }
 /**
- * ComboboxContent — replaces reka `ComboboxPortal`/`ComboboxContent`/`ComboboxViewport`.
+ * ComboboxContent — the popover surface and the scrollable list in one.
  * `@radix-ui/react-popover` provides the portal + positioning; `cmdk`'s `Command`
  * provides item filtering. A visually-hidden `CommandInput` receives the shared
  * search string so typing in the anchored input filters the list.

package/dist/Forms/Inputs/Combobox/ComboboxEmpty.d.ts

@@ -1,6 +1,6 @@
 import { CommandEmpty } from 'cmdk';
 export type ComboboxEmptyProps = React.ComponentPropsWithoutRef<typeof CommandEmpty>;
-/** ComboboxEmpty — replaces reka `ComboboxEmpty`. Shown when no items match. */
+/** ComboboxEmpty — shown when the search matches no items. */
 export declare const ComboboxEmpty: import('react').ForwardRefExoticComponent<Omit<{
     children?: React.ReactNode;
 } & Pick<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & {

package/dist/Forms/Inputs/Combobox/ComboboxGroup.d.ts

@@ -3,5 +3,5 @@ export interface ComboboxGroupProps extends React.ComponentPropsWithoutRef<typeo
     /** Optional group heading. */
     label?: string;
 }
-/** ComboboxGroup — replaces reka `ComboboxGroup` + `ComboboxLabel`. */
+/** ComboboxGroup — a labelled set of items. */
 export declare const ComboboxGroup: import('react').ForwardRefExoticComponent<ComboboxGroupProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/Combobox/ComboboxInput.d.ts

@@ -9,7 +9,7 @@ export interface ComboboxInputProps extends Omit<React.InputHTMLAttributes<HTMLI
     trigger?: React.ReactNode;
 }
 /**
- * ComboboxInput — replaces reka `ComboboxAnchor` + `ComboboxInput` + `ComboboxTrigger`.
+ * ComboboxInput — the anchor, the search field and the trigger button in one.
  * The single-select text field: shows the current selection, opens the popover
  * on focus and drives cmdk filtering via the shared `search` state.
  */

package/dist/Forms/Inputs/Combobox/ComboboxItem.d.ts

@@ -4,7 +4,7 @@ export interface ComboboxItemProps extends Omit<React.ComponentPropsWithoutRef<t
     disabled?: boolean;
 }
 /**
- * ComboboxItem — replaces reka `ComboboxItem` + `ComboboxItemIndicator`.
+ * ComboboxItem — a selectable option, with its own check indicator.
  * Selecting commits the value through the shared context (toggles for multiple).
  */
 export declare const ComboboxItem: import('react').ForwardRefExoticComponent<ComboboxItemProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/Combobox/ComboboxSeparator.d.ts

@@ -1,6 +1,6 @@
 import { CommandSeparator } from 'cmdk';
 export type ComboboxSeparatorProps = React.ComponentPropsWithoutRef<typeof CommandSeparator>;
-/** ComboboxSeparator — replaces reka `ComboboxSeparator`. */
+/** ComboboxSeparator — a rule between groups of items. */
 export declare const ComboboxSeparator: import('react').ForwardRefExoticComponent<Omit<Pick<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof import('react').HTMLAttributes<HTMLDivElement>> & {
     ref?: React.Ref<HTMLDivElement>;
 } & {

package/dist/Forms/Inputs/Combobox/context.d.ts

@@ -1,10 +1,10 @@
 /**
  * Shared Combobox state.
  *
- * The reka-ui `ComboboxRoot` exposed a single context (model value, multiple,
- * disabled, open) consumed by every sub-part. cmdk + `@radix-ui/react-popover`
- * split those responsibilities, so we recreate that single context here to keep
- * the same public component split and behaviour.
+ * cmdk owns the list and the filtering, `@radix-ui/react-popover` owns the
+ * open state, and neither knows about the selection. One context holds what
+ * every part needs — the value, `multiple`, `disabled` and the search term — so
+ * a part can be used on its own without threading props through the tree.
  */
 export interface ComboboxContextValue {
     /** Current selection. `string` for single-select, `string[]` for multiple. */

package/dist/Forms/Inputs/InputNumber/InputNumber.d.ts

@@ -13,7 +13,8 @@ export interface InputNumberProps extends Omit<React.HTMLAttributes<HTMLDivEleme
     disabled?: boolean;
 }
 /**
- * InputNumber root — replaces reka-ui `NumberFieldRoot`.
+ * InputNumber root. Radix ships no NumberField, so the stepping, clamping and
+ * keyboard behaviour are implemented here.
  * Radix has no NumberField, so this is a controlled numeric field that provides
  * value/step/min/max/disabled context to its subcomponents.
  */

package/dist/Forms/Inputs/InputNumber/InputNumberDecrement.d.ts

@@ -1,3 +1,3 @@
 export type InputNumberDecrementProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-/** Replaces reka-ui `NumberFieldDecrement`. */
+/** Steps the value down; holds to repeat. */
 export declare const InputNumberDecrement: import('react').ForwardRefExoticComponent<InputNumberDecrementProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Forms/Inputs/InputNumber/InputNumberIncrement.d.ts

@@ -1,3 +1,3 @@
 export type InputNumberIncrementProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
-/** Replaces reka-ui `NumberFieldIncrement`. */
+/** Steps the value up; holds to repeat. */
 export declare const InputNumberIncrement: import('react').ForwardRefExoticComponent<InputNumberIncrementProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Forms/Inputs/InputNumber/InputNumberInput.d.ts

@@ -1,3 +1,3 @@
 export type InputNumberInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'type'>;
-/** Replaces reka-ui `NumberFieldInput` — a `spinbutton`-role text input. */
+/** The editable field itself, with a `spinbutton` role. */
 export declare const InputNumberInput: import('react').ForwardRefExoticComponent<InputNumberInputProps & import('react').RefAttributes<HTMLInputElement>>;

package/dist/Forms/Inputs/InputOtp/InputOtp.d.ts

@@ -1,10 +1,9 @@
 import { InputOtpProps } from './types.ts';
 /**
- * InputOtp root — mirrors `@sesame/orxata-core` InputOtp.
+ * InputOtp root.
  *
- * The Vue package delegates to reka-ui's `PinInput`, which has no Radix
- * counterpart, so the pin behaviour (focus advance, backspace, arrow keys,
- * paste spreading, per-slot labels) lives here and reaches the slots through
- * context. The rendered DOM matches the Vue version: one `<input>` per slot.
+ * Radix ships no PinInput, so the behaviour lives here — focus advance,
+ * backspace, arrow keys, paste spreading, per-slot labels — and reaches the
+ * slots through context. One `<input>` per slot.
  */
 export declare const InputOtp: import('react').ForwardRefExoticComponent<InputOtpProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/InputOtp/types.d.ts

@@ -6,13 +6,13 @@ export interface InputOtpProps extends Omit<React.HTMLAttributes<HTMLDivElement>
     /** Render every slot as a password field. */
     mask?: boolean;
     disabled?: boolean;
-    /** Controlled code (mirrors the Vue `v-model`). */
+    /** Controlled code. Pair with `onValueChange`; omit for uncontrolled. */
     value?: string;
     /** Uncontrolled initial code. */
     defaultValue?: string;
     /** Emitted whenever the code changes. */
     onValueChange?: (code: string) => void;
-    /** Emitted once every slot is filled (mirrors the Vue `complete` event). */
+    /** Called once every slot holds a character. */
     onComplete?: (code: string) => void;
     children?: React.ReactNode;
 }

package/dist/Forms/Inputs/InputPassword/InputPassword.d.ts

@@ -1,20 +1,20 @@
 import { InputSize } from '../inputSize.ts';
 export interface InputPasswordProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
     size?: InputSize;
-    /** Controlled value (mirrors the Vue `field` model). */
+    /** Controlled value. Pair with `onFieldChange`; omit for uncontrolled. */
     field?: string;
-    /** Emitted on input (mirrors the Vue `update:field` event). */
+    /** Called on every input with the next value. */
     onFieldChange?: (value: string) => void;
-    /** Controlled clear-text state (mirrors the Vue `visible` model). */
+    /** Controlled clear-text state. Pair with `onVisibleChange`. */
     visible?: boolean;
-    /** Emitted when the toggle flips (mirrors the Vue `update:visible` event). */
+    /** Called when the reveal toggle flips, with the next state. */
     onVisibleChange?: (visible: boolean) => void;
     dataTestid: string;
 }
 /**
  * InputPassword root — mirrors `@sesame/orxata-core` InputPassword.
  * Provides the value and clear-text state to `InputPasswordInput` and
- * `InputPasswordToggle` through context, replacing the Vue provide/inject.
+ * `InputPasswordToggle` through context.
  * Both `field` and `visible` work controlled or uncontrolled.
  */
 export declare const InputPassword: import('react').ForwardRefExoticComponent<InputPasswordProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/InputPassword/InputPasswordToggle.d.ts

@@ -1,8 +1,8 @@
 import { ReactNode } from 'react';
 export interface InputPasswordToggleProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
     /**
-     * Custom toggle content. Accepts a render function to receive the clear-text
-     * state, mirroring the Vue scoped slot `<slot :visible="visible">`.
+     * Custom toggle content. Pass a render function to receive the current
+     * clear-text state and render accordingly.
      */
     children?: ReactNode | ((props: {
         visible: boolean;

package/dist/Forms/Inputs/InputText/InputText.d.ts

@@ -1,16 +1,16 @@
 import { InputSize } from '../inputSize.ts';
 export interface InputTextProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
     size?: InputSize;
-    /** Controlled value (mirrors the Vue `field` model). */
+    /** Controlled value. Pair with `onFieldChange`; omit for uncontrolled. */
     field?: string;
-    /** Emitted on input (mirrors the Vue `update:field` event). */
+    /** Called on every input with the next value. */
     onFieldChange?: (value: string) => void;
 }
 /**
- * InputText — mirrors `@sesame/orxata-core` InputText.
- * The Vue `field` v-model becomes the `field` value + `onFieldChange` callback.
- * Native `value`/`onChange` still pass through via `...props`.
- * `type` defaults to `'text'` but can be overridden (matches the Vue
- * `<input type="text" v-bind="props">` where a passed `type` wins).
+ * InputText.
+ *
+ * `field` + `onFieldChange` are the controlled pair; native `value`/`onChange`
+ * still pass through via `...props` for anyone who prefers them. `type`
+ * defaults to `'text'`, and a `type` passed by the caller wins.
  */
 export declare const InputText: import('react').ForwardRefExoticComponent<InputTextProps & import('react').RefAttributes<HTMLInputElement>>;

package/dist/Forms/Inputs/Select/Select.d.ts

@@ -0,0 +1,20 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+export interface SelectProps extends Omit<React.ComponentPropsWithoutRef<typeof SelectPrimitive.Root>, 'children'> {
+    className?: string;
+    children?: React.ReactNode;
+    dataTestid: string;
+}
+/**
+ * Select root. `@radix-ui/react-select` Root renders no element of its own, so
+ * the wrapper below is what carries `data-slot`, `data-testid` and the class.
+ *
+ * The selection is held here rather than handed to the primitive as an optional
+ * prop: an empty string is how Radix asks for the placeholder, so passing one
+ * keeps it controlled from the first render, where `undefined` would make it
+ * flip from uncontrolled to controlled on the first choice and warn. Both paths
+ * still work — `defaultValue` seeds the state, `value` overrides it.
+ *
+ * The same state also feeds the trigger's render prop, together with the label
+ * registry in `context.ts`.
+ */
+export declare const Select: import('react').ForwardRefExoticComponent<SelectProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/Select/SelectContent.d.ts

@@ -0,0 +1,11 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+export interface SelectContentProps extends Omit<React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>, 'side' | 'align' | 'sideOffset' | 'position'> {
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+}
+/**
+ * The floating list. Always positioned against the trigger rather than over it,
+ * so the popup matches the trigger's width and never covers it.
+ */
+export declare const SelectContent: import('react').ForwardRefExoticComponent<SelectContentProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/Select/SelectGroup.d.ts

@@ -0,0 +1,7 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+export interface SelectGroupProps extends React.ComponentPropsWithoutRef<typeof SelectPrimitive.Group> {
+    /** Optional group heading. */
+    label?: string;
+}
+/** Groups related options under a heading, announced as a group label. */
+export declare const SelectGroup: import('react').ForwardRefExoticComponent<SelectGroupProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/Select/SelectItem.d.ts

@@ -0,0 +1,14 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+export interface SelectItemProps extends React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> {
+    value: string;
+    disabled?: boolean;
+}
+/**
+ * A single option.
+ *
+ * The rendered text is published to the root on mount so the trigger's render
+ * prop can name the selection. Reading it off the DOM keeps arbitrary markup
+ * working, and it runs while the list is closed too: the primitive keeps items
+ * mounted in a detached fragment so their text is available to the trigger.
+ */
+export declare const SelectItem: import('react').ForwardRefExoticComponent<SelectItemProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/Select/SelectSeparator.d.ts

@@ -0,0 +1,4 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+export type SelectSeparatorProps = React.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator>;
+/** A rule between groups of options. Decorative, hidden from assistive tech. */
+export declare const SelectSeparator: import('react').ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/Select/SelectTrigger.d.ts

@@ -0,0 +1,25 @@
+import * as SelectPrimitive from '@radix-ui/react-select';
+/** What the `children` render prop receives. */
+export interface SelectTriggerState {
+    /** Rendered text of the selected item, empty while nothing is chosen. */
+    selectedLabel: string;
+    /** Value of the selected item. */
+    value: string | undefined;
+}
+export interface SelectTriggerProps extends Omit<React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger>, 'children'> {
+    /** Shown while nothing is selected. */
+    placeholder?: string;
+    disabled?: boolean;
+    /** Replaces the chevron. */
+    icon?: React.ReactNode;
+    /** Replaces what is rendered for the current value. */
+    children?: (state: SelectTriggerState) => React.ReactNode;
+}
+/**
+ * The button that opens the list and shows the current value.
+ *
+ * It takes no size prop: height and radius come from the `--controller-*`
+ * variables shared with every other input, so `inputSizeClass[size]` on any
+ * ancestor drives it.
+ */
+export declare const SelectTrigger: import('react').ForwardRefExoticComponent<SelectTriggerProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Forms/Inputs/Select/context.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared Select state.
+ *
+ * Radix keeps its own selection state in a scoped context that is not part of
+ * its public API, and it never exposes the *text* of the selected item — the
+ * trigger shows it by portalling the item's own text node, so no caller ever
+ * gets a string back. `SelectTrigger` hands that string to its render prop, so
+ * the value and a value → text registry are kept here instead: every
+ * `SelectItem` publishes its rendered text on mount, including while the list
+ * is closed.
+ */
+export interface SelectContextValue {
+    /** Current selection, or `undefined` while the placeholder shows. */
+    value: string | undefined;
+    /** Rendered text of every mounted item, keyed by its value. */
+    labels: Record<string, string>;
+    /** Publish an item's rendered text. Called by `SelectItem` on mount. */
+    registerLabel: (value: string, label: string) => void;
+}
+export declare const SelectContext: import('react').Context<SelectContextValue | null>;
+export declare function useSelectContext(): SelectContextValue;

package/dist/Forms/Inputs/Select/index.d.ts

@@ -0,0 +1,6 @@
+export { Select, type SelectProps } from './Select.tsx';
+export { SelectTrigger, type SelectTriggerProps, type SelectTriggerState, } from './SelectTrigger.tsx';
+export { SelectContent, type SelectContentProps } from './SelectContent.tsx';
+export { SelectItem, type SelectItemProps } from './SelectItem.tsx';
+export { SelectGroup, type SelectGroupProps } from './SelectGroup.tsx';
+export { SelectSeparator, type SelectSeparatorProps, } from './SelectSeparator.tsx';

package/dist/Forms/Inputs/Select/types.d.ts

@@ -0,0 +1,6 @@
+export type { SelectProps } from './Select';
+export type { SelectTriggerProps, SelectTriggerState } from './SelectTrigger';
+export type { SelectContentProps } from './SelectContent';
+export type { SelectItemProps } from './SelectItem';
+export type { SelectGroupProps } from './SelectGroup';
+export type { SelectSeparatorProps } from './SelectSeparator';

package/dist/Forms/Inputs/Toggle/Checkbox/Checkbox.d.ts

@@ -3,9 +3,9 @@ export interface CheckboxProps extends React.ComponentPropsWithoutRef<typeof Che
     variant?: 'default' | 'rounded';
 }
 /**
- * Checkbox — mirrors `@sesame/orxata-core` Checkbox.
- * `v-model` (`boolean | 'indeterminate'`) maps to Radix `checked` /
- * `onCheckedChange` (+ `defaultChecked`). The Vue `TransitionBounce` wrapper
- * has no React equivalent yet and is omitted.
+ * Checkbox — built on `@radix-ui/react-checkbox`. `checked` is
+ * `boolean | 'indeterminate'`, paired with `onCheckedChange`, or
+ * `defaultChecked` for uncontrolled. The indicator appears without a
+ * transition; there is no ported animation wrapper yet.
  */
 export declare const Checkbox: import('react').ForwardRefExoticComponent<CheckboxProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Forms/Inputs/Toggle/RadioButton/RadioButton.d.ts

@@ -1,7 +1,7 @@
 import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
 export type RadioButtonProps = React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>;
 /**
- * RadioButton — mirrors `@sesame/orxata-core` RadioButton (reka `RadioGroupItem`).
- * The Vue `TransitionBounce` wrapper has no React equivalent yet and is omitted.
+ * RadioButton — built on `@radix-ui/react-radio-group` `Item`. The indicator
+ * appears without a transition; there is no ported animation wrapper yet.
  */
 export declare const RadioButton: import('react').ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & import('react').RefAttributes<HTMLButtonElement>, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Forms/Inputs/Toggle/RadioButton/RadioGroup.d.ts

@@ -3,7 +3,7 @@ export interface RadioGroupProps extends React.ComponentPropsWithoutRef<typeof R
     orientation?: 'horizontal' | 'vertical';
 }
 /**
- * RadioGroup — mirrors `@sesame/orxata-core` RadioGroup (reka `RadioGroupRoot`).
+ * RadioGroup — built on `@radix-ui/react-radio-group`.
  * `v-model` maps to Radix `value` / `onValueChange` (+ `defaultValue`).
  */
 export declare const RadioGroup: import('react').ForwardRefExoticComponent<RadioGroupProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/Toggle/Switch/Switch.d.ts

@@ -6,8 +6,7 @@ export interface SwitchProps extends Omit<React.ComponentPropsWithoutRef<'div'>,
     children?: React.ReactNode;
 }
 /**
- * Switch — mirrors `@sesame/orxata-core` Switch. A custom div + native checkbox
- * toggle (the source does not use reka `SwitchRoot`), so it is ported as a
- * controlled component: `checked` + `onCheckedChange` replace Vue's `v-model`.
+ * Switch — a styled div wrapping a native checkbox rather than a primitive,
+ * controlled through `checked` + `onCheckedChange`.
  */
 export declare const Switch: import('react').ForwardRefExoticComponent<SwitchProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Inputs/index.d.ts

@@ -4,4 +4,5 @@ export * from './InputNumber/index.ts';
 export * from './InputPassword/index.ts';
 export * from './InputOtp/index.ts';
 export * from './Combobox/index.ts';
+export * from './Select/index.ts';
 export * from './Toggle/index.ts';

package/dist/Forms/Inputs/inputSize.d.ts

@@ -1,7 +1,7 @@
 /**
- * Control sizes shared by every input. Mirrors the `input-{size}` classes the
- * Vue package applies directly; CSS modules hash the class names, so consumers
- * resolve them through this map instead of building the string by hand.
+ * Control sizes shared by every input. The class names are global and part of
+ * the public vocabulary — a consumer can apply `input-{size}` to an ancestor
+ * and every descendant control that reads the custom properties follows.
  */
 export type InputSize = 'sm' | 'md' | 'lg';
 export declare const inputSizeClass: Record<InputSize, string>;

package/dist/Layout/Card/Card.d.ts

@@ -5,6 +5,6 @@ export interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
 }
 /**
  * Card — mirrors `@sesame/orxata-core` Card.
- * `asChild` replaces reka-ui's `<Primitive as-child>` via `@radix-ui/react-slot`.
+ * `asChild` renders the child element instead of a `<div>`, via `@radix-ui/react-slot`.
  */
 export declare const Card: import('react').ForwardRefExoticComponent<CardProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Layout/Divider/Divider.d.ts

@@ -7,10 +7,11 @@ export interface DividerProps extends React.HTMLAttributes<HTMLDivElement> {
     dataTestid: string;
 }
 /**
- * Divider — mirrors `@sesame/orxata-core` Divider.
- * reka-ui's `Separator` has no Radix counterpart in this package's dependency
- * set, so the separator semantics are implemented here: `aria-orientation` is
- * only emitted for the vertical case (horizontal is the ARIA default).
- * `asChild` replaces reka-ui's `<Primitive as-child>` via `@radix-ui/react-slot`.
+ * Divider.
+ *
+ * No separator primitive is in this package's dependency set, so the semantics
+ * are implemented here: `aria-orientation` is emitted only for the vertical
+ * case, since horizontal is the ARIA default. `asChild` renders the child
+ * element instead of a `<div>`, via `@radix-ui/react-slot`.
  */
 export declare const Divider: import('react').ForwardRefExoticComponent<DividerProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Layout/Resizable/Resizable.d.ts

@@ -5,10 +5,10 @@ export type ResizableProps = Omit<React.ComponentPropsWithoutRef<typeof PanelGro
     dataTestid: string;
 };
 /**
- * Resizable — maps reka-ui `SplitterGroup` to `react-resizable-panels` `PanelGroup`.
+ * Resizable — built on `react-resizable-panels` `PanelGroup`.
  *
- * `direction` mirrors reka's `direction`. We also set `data-orientation` from it
- * because `react-resizable-panels` emits `data-panel-group-direction` (not
- * `data-orientation`), and the CSS selectors + a11y rely on `data-orientation`.
+ * `data-orientation` is set from `direction` because the underlying library
+ * emits `data-panel-group-direction` instead, and both the CSS selectors and the
+ * accessibility hooks read `data-orientation`.
  */
 export declare const Resizable: ForwardRefExoticComponent<ResizableProps & RefAttributes<ImperativePanelGroupHandle>>;

package/dist/Layout/Resizable/ResizableHandle.d.ts

@@ -1,17 +1,16 @@
 import { PanelResizeHandleProps } from 'react-resizable-panels';
 export type ResizableHandleProps = PanelResizeHandleProps & {
     /**
-     * Orientation of the parent group. `react-resizable-panels` does not expose
-     * the group direction to the handle DOM (reka propagated it via context), so
-     * we accept it explicitly to drive the `data-orientation` CSS selectors.
+     * Orientation of the parent group. `react-resizable-panels` puts nothing on
+     * the handle DOM to say which way the group runs, so it is passed in to drive
+     * the `data-orientation` CSS selectors.
      */
     orientation?: 'horizontal' | 'vertical';
     dataTestid: string;
 };
 /**
- * ResizableHandle — maps reka-ui `SplitterResizeHandle` to
- * `react-resizable-panels` `PanelResizeHandle`. Renders a grip bar; `children`
- * override the default `GripVertical` icon (mirrors reka's default slot).
+ * ResizableHandle — built on `react-resizable-panels` `PanelResizeHandle`.
+ * Renders a grip bar; `children` replace the default `GripVertical` icon.
  *
  * Not `forwardRef`: `PanelResizeHandle` is a plain function component and does
  * not accept a `ref`.