@sesamehr/react-design-system 0.1.0

package/dist/Data/Table/hooks/useTablePinning/useTablePinning.types.d.ts

@@ -0,0 +1,50 @@
+import { ColumnPinningState } from '@tanstack/react-table';
+import { ColumnDef } from '../../types';
+export interface PinningOptions<TData = unknown> {
+    /** Column definitions (needed for deriving pinning from col.pin) */
+    columns: ColumnDef<TData>[];
+    /** Initial pinning state (optional - derived from col.pin if not provided) */
+    initial?: ColumnPinningState;
+}
+export interface CellInfo<TData> {
+    columnId: string;
+    value: unknown;
+    row: TData;
+    rowIndex: number;
+}
+export interface HeaderInfo {
+    columnId: string;
+    header: string;
+    width?: number;
+}
+export interface PinningInstance<TData> {
+    /** Current pinning state */
+    pinningState: ColumnPinningState;
+    /** Pin a column to left or right */
+    pinColumn: (columnId: string, position: 'left' | 'right') => void;
+    /** Unpin a column */
+    unpinColumn: (columnId: string) => void;
+    /** Check if a column is pinned */
+    isPinned: (columnId: string) => 'left' | 'right' | false;
+    /** Get cells for left pinned columns */
+    getLeftCells: (rowIndex: number) => CellInfo<TData>[];
+    /** Get cells for center (unpinned) columns */
+    getCenterCells: (rowIndex: number) => CellInfo<TData>[];
+    /** Get cells for right pinned columns */
+    getRightCells: (rowIndex: number) => CellInfo<TData>[];
+    /** Header info for left pinned columns */
+    leftHeaders: HeaderInfo[];
+    /** Header info for center columns */
+    centerHeaders: HeaderInfo[];
+    /** Header info for right pinned columns */
+    rightHeaders: HeaderInfo[];
+    /** Total width of left pinned columns */
+    leftWidth: number;
+    /** Total width of right pinned columns */
+    rightWidth: number;
+}
+export interface PinningPluginDef<TData = unknown> {
+    type: 'pinning';
+    options: PinningOptions<TData>;
+    create: (tableInstance: unknown, rows: TData[]) => PinningInstance<TData>;
+}

package/dist/Data/Table/hooks/useTableSelection/useTableSelection.d.ts

@@ -0,0 +1,2 @@
+import { SelectionOptions, SelectionPluginDef } from './useTableSelection.types';
+export declare function useTableSelection<TData = unknown>(options?: SelectionOptions): SelectionPluginDef<TData>;

package/dist/Data/Table/hooks/useTableSelection/useTableSelection.types.d.ts

@@ -0,0 +1,31 @@
+export interface SelectionOptions {
+    /** Initially selected row keys */
+    initial?: (string | number)[];
+}
+export interface SelectionInstance {
+    /** Selection state: Record<rowKey, boolean> */
+    selection: Record<string, boolean>;
+    /** Check if a specific row is selected */
+    isSelected: (key: string | number) => boolean;
+    /** Whether all rows are selected */
+    isAllSelected: boolean;
+    /** Whether some (but not all) rows are selected */
+    isSomeSelected: boolean;
+    /** Toggle selection for a specific row */
+    toggle: (key: string | number) => void;
+    /** Toggle selection for all rows */
+    toggleAll: () => void;
+    /** Select specific rows */
+    select: (keys: (string | number)[]) => void;
+    /** Deselect specific rows */
+    deselect: (keys: (string | number)[]) => void;
+    /** Clear all selection */
+    clear: () => void;
+    /** Array of selected keys */
+    selectedKeys: string[];
+}
+export interface SelectionPluginDef<TData = unknown> {
+    type: 'selection';
+    options: SelectionOptions;
+    create: (rows: TData[], getRowKey: (row: TData, index: number) => string | number) => SelectionInstance;
+}

package/dist/Data/Table/hooks/useTableSorting/useTableSorting.d.ts

@@ -0,0 +1,2 @@
+import { SortingOptions, SortingPluginDef } from './useTableSorting.types';
+export declare function useTableSorting(options?: SortingOptions): SortingPluginDef;

package/dist/Data/Table/hooks/useTableSorting/useTableSorting.types.d.ts

@@ -0,0 +1,24 @@
+import { SortingState } from '../../types';
+export interface SortingOptions {
+    /** Initial sorting state */
+    initial?: SortingState;
+}
+export interface SortingInstance {
+    /** Current sorting state */
+    sorting: SortingState | null;
+    /** Set sorting */
+    set: (sorting: SortingState | null) => void;
+    /** Toggle sorting for a field (asc -> desc -> none) */
+    toggle: (field: string) => void;
+    /** Clear sorting */
+    clear: () => void;
+    /** Check if a field is currently sorted */
+    isSorted: (field: string) => boolean;
+    /** Get sort direction for a field */
+    getDirection: (field: string) => 'asc' | 'desc' | null;
+}
+export interface SortingPluginDef {
+    type: 'sorting';
+    options: SortingOptions;
+    create: () => SortingInstance;
+}

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

@@ -0,0 +1,17 @@
+export { Table, type TableComponentProps } from './Table';
+export { TableHead, type TableHeadProps } from './TableHead/TableHead';
+export { TableBody, type TableBodyProps } from './TableBody/TableBody';
+export { TableRow, type TableRowProps } from './TableRow/TableRow';
+export { TableCell, type TableCellProps } from './TableCell/TableCell';
+export { TableHeaderCell, type TableHeaderCellProps, } from './TableHeaderCell/TableHeaderCell';
+export { TableSelectCell, type TableSelectCellProps, } from './TableSelectCell/TableSelectCell';
+export { TableDragCell, type TableDragCellProps, } from './TableDragCell/TableDragCell';
+export { TableBulkHeader, type TableBulkHeaderProps, } from './TableBulkHeader/TableBulkHeader';
+export { TablePagination, type TablePaginationProps, } from './TablePagination/TablePagination';
+export { TableEmpty, type TableEmptyProps } from './TableEmpty/TableEmpty';
+export { TableAvatar, type TableAvatarProps } from './TableAvatar/TableAvatar';
+export { TableRowExpanded, type TableRowExpandedProps, } from './TableRowExpanded/TableRowExpanded';
+export { TableExpandCell, type TableExpandCellProps, } from './TableExpandCell/TableExpandCell';
+export { TableColumnVisibility, type TableColumnVisibilityProps, } from './TableColumnVisibility/TableColumnVisibility';
+export { useTable, type UseTableOptions, type UseTableReturn, useTableSelection, type SelectionInstance as UseTableSelectionReturn, useTableSorting, type SortingInstance as UseTableSortingReturn, useTablePagination, type UseTablePaginationOptions, type UseTablePaginationReturn, useTableDetailRow, type DetailRowInstance, type DetailRowOptions, type DetailRowPluginDef, useTablePinning, type PinningOptions as UseTablePinningOptions, type PinningInstance as UseTablePinningReturn, type CellInfo, type HeaderInfo, useTableColumns, type ColumnsOptions as UseTableColumnsOptions, type ColumnsInstance as UseTableColumnsReturn, useScrollShadow, type UseScrollShadowOptions, type UseScrollShadowReturn, useDragToScroll, type UseDragToScrollOptions, type UseDragToScrollReturn, useFixedColumns, type UseFixedColumnsOptions, } from './hooks';
+export type { TableProps, TableMode, ColumnDef, ColumnAlign, CellContext, SortingState, PaginationState, PaginationChangePayload, SortingChangePayload, SelectionChangePayload, FilterChangePayload, ColumnResizeMode, ColumnVisibilityState, ColumnOrderState, ExpandedState, ColumnVisibilityChangePayload, ColumnOrderChangePayload, RowExpandChangePayload, ColumnResizePayload, ColumnPinningState, } from './types';

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

@@ -0,0 +1,90 @@
+import { ReactNode } from 'react';
+export type ColumnAlign = 'left' | 'center' | 'right';
+export interface ColumnDef<TData = unknown> {
+    field: string;
+    header?: string;
+    sortable?: boolean;
+    resizable?: boolean;
+    /** Column width - accepts number (px), string with unit ('200px', '1rem', '20%') */
+    width?: string | number;
+    /** Tailwind width class (e.g., 'w-48', 'w-1/4') - takes precedence over width for styling */
+    widthClass?: string;
+    /** Text alignment for header and cells */
+    align?: ColumnAlign;
+    minWidth?: number;
+    maxWidth?: number;
+    enableHiding?: boolean;
+    /** Pin column to left or right edge (for fixed columns) */
+    pin?: 'left' | 'right';
+    cellSlot?: (props: CellContext<TData>) => ReactNode;
+    headerSlot?: () => ReactNode;
+}
+export interface CellContext<TData = unknown> {
+    row: TData;
+    value: unknown;
+    rowIndex: number;
+}
+export type TableMode = 'client' | 'server';
+export type ColumnResizeMode = 'onChange' | 'onEnd';
+export interface SortingState {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export interface PaginationState {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+}
+export type ColumnVisibilityState = Record<string, boolean>;
+export type ColumnOrderState = string[];
+export type ExpandedState = Record<string, boolean> | true;
+export interface ColumnPinningState {
+    left?: string[];
+    right?: string[];
+}
+export interface TableState {
+    sorting: SortingState | null;
+    pagination: PaginationState;
+    selectedRows: Set<string | number>;
+    globalFilter: string;
+    columnVisibility: ColumnVisibilityState;
+    columnOrder: ColumnOrderState;
+    expanded: ExpandedState;
+    columnSizing: Record<string, number>;
+}
+export interface TableProps<TData = unknown> {
+    data: TData[];
+    mode?: TableMode;
+    rowKey?: string | ((row: TData) => string | number);
+    loading?: boolean;
+}
+export interface PaginationChangePayload {
+    page: number;
+    pageSize: number;
+}
+export interface SortingChangePayload {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export interface SelectionChangePayload<TData = unknown> {
+    selectedKeys: (string | number)[];
+    selectedRows: TData[];
+}
+export interface FilterChangePayload {
+    globalFilter: string;
+}
+export interface ColumnVisibilityChangePayload {
+    visibility: ColumnVisibilityState;
+}
+export interface ColumnOrderChangePayload {
+    order: ColumnOrderState;
+}
+export interface RowExpandChangePayload {
+    expanded: ExpandedState;
+    rowKey?: string | number;
+}
+export interface ColumnResizePayload {
+    field: string;
+    size: number;
+}

package/dist/Display/Avatar/Avatar.d.ts

@@ -0,0 +1,23 @@
+import { AvatarVariants } from '.';
+import { BulletVariants } from '../../Feedback/Bullet';
+export interface AvatarProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> {
+    /** Image source URL */
+    src?: string;
+    /** Fallback initials (max 2 characters) */
+    initials?: string;
+    /** Avatar size */
+    size?: AvatarVariants['size'];
+    /** Disabled state - shows gray placeholder */
+    disabled?: boolean;
+    /** Status indicator color - automatically positions Bullet based on size */
+    status?: BulletVariants['color'];
+    /** Action slot (rendered top-right) */
+    action?: React.ReactNode;
+    /** Label slot (rendered bottom-center) */
+    label?: React.ReactNode;
+}
+/**
+ * Avatar — mirrors `@orxata/core` Avatar. SVG hexagon shape with hover
+ * drop-shadow, clip-path image, foreignObject initials, and status Bullet.
+ */
+export declare const Avatar: import('react').ForwardRefExoticComponent<AvatarProps & import('react').RefAttributes<HTMLSpanElement>>;

package/dist/Display/Avatar/hooks/useAvatarBullet.d.ts

@@ -0,0 +1,16 @@
+import { AvatarVariants } from '..';
+type AvatarSize = NonNullable<AvatarVariants['size']>;
+interface BulletTopStyle {
+    top: string;
+    left: string;
+}
+interface BulletBottomStyle {
+    bottom: string;
+    left: string;
+}
+export type BulletStyle = BulletTopStyle | BulletBottomStyle;
+export declare function useAvatarBullet(size: AvatarSize): {
+    bulletSize: "8" | "24" | "16" | "12" | null | undefined;
+    bulletStyle: BulletStyle;
+};
+export {};

package/dist/Display/Avatar/index.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+export { Avatar, type AvatarProps } from './Avatar';
+export declare const avatarVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | "2xl" | "xl" | "2xs" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const avatarTextVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | "2xl" | "xl" | "2xs" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type AvatarVariants = VariantProps<typeof avatarVariants>;

package/dist/Display/AvatarGroup/AvatarGroup.d.ts

@@ -0,0 +1,16 @@
+export interface AvatarItem {
+    src?: string;
+    initials?: string;
+    disabled?: boolean;
+}
+export interface AvatarGroupProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onClick'> {
+    /** List of avatars to display */
+    avatars: AvatarItem[];
+    /** Maximum number of avatars to show before collapsing */
+    max?: number;
+    /** Whether the group is interactive (clickable) */
+    interactive?: boolean;
+    /** Click handler (only fired when interactive) */
+    onClick?: React.MouseEventHandler<HTMLButtonElement>;
+}
+export declare const AvatarGroup: import('react').ForwardRefExoticComponent<AvatarGroupProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Display/AvatarGroup/index.d.ts

@@ -0,0 +1 @@
+export { AvatarGroup, type AvatarGroupProps, type AvatarItem, } from './AvatarGroup';

package/dist/Display/Badge/Badge.d.ts

@@ -0,0 +1,6 @@
+import { BadgeVariants } from '.';
+export interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    variant?: BadgeVariants['variant'];
+}
+/** Badge — mirrors `@orxata/core` Badge (cva-only). */
+export declare const Badge: import('react').ForwardRefExoticComponent<BadgeProps & import('react').RefAttributes<HTMLSpanElement>>;

package/dist/Display/Badge/index.d.ts

@@ -0,0 +1,6 @@
+import { VariantProps } from 'class-variance-authority';
+export { Badge, type BadgeProps } from './Badge';
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "outline" | "destructive" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type BadgeVariants = VariantProps<typeof badgeVariants>;

package/dist/Display/PaymentCard/PaymentCard.d.ts

@@ -0,0 +1,13 @@
+import { BadgeType, CardData, PaymentCardVariants } from '.';
+export interface PaymentCardProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Card size */
+    size?: PaymentCardVariants['size'];
+    /** Disabled state (reduces opacity) */
+    disabled?: boolean;
+    /** Badge type to display */
+    badgeType?: BadgeType;
+    /** Card data (number, name, expiry, last digits) */
+    cardData?: CardData;
+}
+/** PaymentCard — mirrors `@orxata/core` PaymentCard. */
+export declare const PaymentCard: import('react').ForwardRefExoticComponent<PaymentCardProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Display/PaymentCard/index.d.ts

@@ -0,0 +1,20 @@
+import { VariantProps } from 'class-variance-authority';
+export { PaymentCard, type PaymentCardProps } from './PaymentCard';
+export declare const paymentCardVariants: (props?: ({
+    size?: "default" | "compact" | null | undefined;
+    disabled?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type PaymentCardVariants = VariantProps<typeof paymentCardVariants>;
+export type BadgeType = 'virtual' | 'physical' | 'subscription';
+export interface CardData {
+    /** Card number (masked) */
+    cardNumber?: string;
+    /** Cardholder name */
+    cardholderName?: string;
+    /** Expiry date */
+    expiryDate?: string;
+    /** CVC (masked) */
+    cvc?: string;
+    /** Last 4 digits (for compact view) */
+    lastFourDigits?: string;
+}

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

@@ -0,0 +1,18 @@
+import { AlertVariant } from './alert-context';
+export interface AlertProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onToggle'> {
+    variant?: AlertVariant;
+    dismissible?: boolean;
+    collapsible?: boolean;
+    isOpen?: boolean;
+    /** Emitted when the alert is dismissed (maps Vue `dismissed`). */
+    onDismissed?: () => void;
+    /** Emitted with the next open state (maps Vue `update:isOpen`). */
+    onOpenChange?: (isOpen: boolean) => void;
+    /** Emitted with the next open state (maps Vue `toggled`). */
+    onToggled?: (open: boolean) => void;
+}
+/**
+ * Alert — mirrors `@orxata/core` Alert.
+ * Vue `provide/inject` context becomes React context (`AlertContext`).
+ */
+export declare const Alert: import('react').ForwardRefExoticComponent<AlertProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,3 @@
+export type AlertCloseProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+/** AlertClose — dismisses the parent Alert via context. */
+export declare const AlertClose: import('react').ForwardRefExoticComponent<AlertCloseProps & import('react').RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,3 @@
+export type AlertDescriptionProps = React.HTMLAttributes<HTMLDivElement>;
+/** AlertDescription — hidden when a collapsible Alert is closed. */
+export declare const AlertDescription: import('react').ForwardRefExoticComponent<AlertDescriptionProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,3 @@
+export type AlertIconProps = React.HTMLAttributes<HTMLDivElement>;
+/** AlertIcon — renders the variant's default lucide icon, or `children` if provided. */
+export declare const AlertIcon: import('react').ForwardRefExoticComponent<AlertIconProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,3 @@
+export type AlertTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** AlertTitle — the alert label heading. */
+export declare const AlertTitle: import('react').ForwardRefExoticComponent<AlertTitleProps & import('react').RefAttributes<HTMLHeadingElement>>;

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

@@ -0,0 +1,3 @@
+export type AlertToggleProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+/** AlertToggle — toggles the collapsible Alert via context. */
+export declare const AlertToggle: import('react').ForwardRefExoticComponent<AlertToggleProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/Feedback/Alert/alert-context.d.ts

@@ -0,0 +1,12 @@
+export type AlertVariant = 'warning' | 'error' | 'info' | 'success';
+export interface AlertContextValue {
+    variant: AlertVariant;
+    isDismissed: boolean;
+    isOpen: boolean;
+    dismissible: boolean;
+    collapsible: boolean;
+    handleDismiss: () => void;
+    handleToggle: () => void;
+}
+export declare const AlertContext: import('react').Context<AlertContextValue>;
+export declare const useAlertContext: () => AlertContextValue;

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

@@ -0,0 +1,7 @@
+export { Alert, type AlertProps } from './Alert';
+export { AlertClose, type AlertCloseProps } from './AlertClose';
+export { AlertDescription, type AlertDescriptionProps, } from './AlertDescription';
+export { AlertIcon, type AlertIconProps } from './AlertIcon';
+export { AlertTitle, type AlertTitleProps } from './AlertTitle';
+export { AlertToggle, type AlertToggleProps } from './AlertToggle';
+export { type AlertVariant } from './alert-context';

package/dist/Feedback/Bullet/Bullet.d.ts

@@ -0,0 +1,7 @@
+import { BulletVariants } from '.';
+export interface BulletProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'> {
+    size?: BulletVariants['size'];
+    color?: BulletVariants['color'];
+}
+/** Bullet — mirrors `@orxata/core` Bullet (cva-only). */
+export declare const Bullet: import('react').ForwardRefExoticComponent<BulletProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Feedback/Bullet/index.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+export { Bullet, type BulletProps } from './Bullet';
+export declare const bulletVariants: (props?: ({
+    size?: "8" | "24" | "16" | "12" | null | undefined;
+    color?: "active" | "warning" | "info" | "neutral" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type BulletVariants = VariantProps<typeof bulletVariants>;

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

@@ -0,0 +1,12 @@
+export interface DialogProps {
+    children?: React.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    modal?: boolean;
+}
+/** Dialog — maps reka-ui `DialogRoot` to `@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/DialogContent.d.ts

@@ -0,0 +1,6 @@
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+export interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    showCloseButton?: boolean;
+}
+/** DialogContent — portalled Radix dialog content with overlay and close button. */
+export declare const DialogContent: import('react').ForwardRefExoticComponent<DialogContentProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,3 @@
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+export type DialogDescriptionProps = React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>;
+export declare const DialogDescription: import('react').ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & import('react').RefAttributes<HTMLParagraphElement>, "ref"> & import('react').RefAttributes<HTMLParagraphElement>>;

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

@@ -0,0 +1,4 @@
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+export type DialogOverlayProps = React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>;
+/** DialogOverlay — the dimmed backdrop behind dialog content. */
+export declare const DialogOverlay: import('react').ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & import('react').RefAttributes<HTMLDivElement>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,3 @@
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+export type DialogTitleProps = React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>;
+export declare const DialogTitle: import('react').ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & import('react').RefAttributes<HTMLHeadingElement>, "ref"> & import('react').RefAttributes<HTMLHeadingElement>>;

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

@@ -0,0 +1,8 @@
+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). */
+    aside?: React.ReactNode;
+}
+/** DialogTwoPanelContent — two-column dialog (main + aside) with close button. */
+export declare const DialogTwoPanelContent: import('react').ForwardRefExoticComponent<DialogTwoPanelContentProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,7 @@
+export { Dialog, type DialogProps } from './Dialog';
+export { DialogContent, type DialogContentProps } from './DialogContent';
+export { DialogTitle, type DialogTitleProps } from './DialogTitle';
+export { DialogDescription, type DialogDescriptionProps, } from './DialogDescription';
+export { DialogOverlay, type DialogOverlayProps } from './DialogOverlay';
+export { DialogTwoPanelContent, type DialogTwoPanelContentProps, } from './DialogTwoPanelContent';
+export { Trigger as DialogTrigger, Close as DialogClose, } from '@radix-ui/react-dialog';

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

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

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

@@ -0,0 +1,6 @@
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+export interface PopoverContentProps extends React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content> {
+    showArrow?: boolean;
+}
+/** PopoverContent — portalled Radix popover content with optional arrow. */
+export declare const PopoverContent: import('react').ForwardRefExoticComponent<PopoverContentProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,3 @@
+export { Popover, type PopoverProps } from './Popover';
+export { PopoverContent, type PopoverContentProps } from './PopoverContent';
+export { PopoverClose } from '@radix-ui/react-popover';

package/dist/Feedback/StatusBadge/StatusBadge.d.ts

@@ -0,0 +1,6 @@
+import { StatusBadgeVariants } from '.';
+export interface StatusBadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    status?: StatusBadgeVariants['status'];
+}
+/** StatusBadge — mirrors `@orxata/core` StatusBadge (cva-only). */
+export declare const StatusBadge: import('react').ForwardRefExoticComponent<StatusBadgeProps & import('react').RefAttributes<HTMLSpanElement>>;

package/dist/Feedback/StatusBadge/index.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+export { StatusBadge, type StatusBadgeProps } from './StatusBadge';
+export declare const statusBadgeVariants: (props?: ({
+    status?: "paused" | "active" | "draft" | "completed" | "scheduled" | "deleted" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export declare const indicatorVariants: (props?: ({
+    status?: "paused" | "active" | "draft" | "completed" | "scheduled" | "deleted" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type StatusBadgeVariants = VariantProps<typeof statusBadgeVariants>;

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

@@ -0,0 +1,16 @@
+export interface TooltipProps {
+    /** Trigger element (maps Vue `#trigger` slot); rendered via Radix `asChild`. */
+    trigger?: React.ReactNode;
+    children?: React.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    delayDuration?: number;
+    skipDelayDuration?: number;
+    disableHoverableContent?: boolean;
+}
+/** Tooltip — maps reka-ui `TooltipProvider/Root/Trigger` to `@radix-ui/react-tooltip`. */
+export declare const Tooltip: {
+    ({ trigger, children, defaultOpen, open, onOpenChange, delayDuration, skipDelayDuration, disableHoverableContent, }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,6 @@
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+export interface TooltipContentProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {
+    showArrow?: boolean;
+}
+/** TooltipContent — portalled Radix tooltip content with optional arrow. */
+export declare const TooltipContent: import('react').ForwardRefExoticComponent<TooltipContentProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,2 @@
+export { Tooltip, type TooltipProps } from './Tooltip';
+export { TooltipContent, type TooltipContentProps } from './TooltipContent';

package/dist/Forms/Field/FieldGroup/FieldGroup.d.ts

@@ -0,0 +1,4 @@
+export interface FieldGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: 'default' | 'error' | 'success' | 'warning';
+}
+export declare const FieldGroup: import('react').ForwardRefExoticComponent<FieldGroupProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/Forms/Field/FieldLabel/FieldLabel.d.ts

@@ -0,0 +1,2 @@
+export type FieldLabelProps = React.LabelHTMLAttributes<HTMLLabelElement>;
+export declare const FieldLabel: import('react').ForwardRefExoticComponent<FieldLabelProps & import('react').RefAttributes<HTMLLabelElement>>;

package/dist/Forms/Field/FieldMessage/FieldMessage.d.ts

@@ -0,0 +1,5 @@
+export interface FieldMessageProps extends React.HTMLAttributes<HTMLDivElement> {
+    message?: string;
+    variant?: 'default' | 'error' | 'success' | 'warning';
+}
+export declare const FieldMessage: import('react').ForwardRefExoticComponent<FieldMessageProps & import('react').RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,3 @@
+export { FieldGroup, type FieldGroupProps } from './FieldGroup/FieldGroup';
+export { FieldLabel, type FieldLabelProps } from './FieldLabel/FieldLabel';
+export { FieldMessage, type FieldMessageProps, } from './FieldMessage/FieldMessage';

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

@@ -0,0 +1,27 @@
+export interface ComboboxProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Controlled selection (`string` single / `string[]` multiple). */
+    value?: string | string[];
+    /** Uncontrolled initial selection. */
+    defaultValue?: string | string[];
+    /** Emitted when the selection changes. */
+    onValueChange?: (value: string | string[]) => void;
+    /** Allow selecting multiple values (renders chips with `ComboboxChipsInput`). */
+    multiple?: boolean;
+    /** Disable the input and trigger. */
+    disabled?: boolean;
+    /** Controlled open state. */
+    open?: boolean;
+    /** Uncontrolled initial open state. */
+    defaultOpen?: boolean;
+    /** Emitted when the open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+/**
+ * Combobox root — replaces reka-ui `ComboboxRoot`.
+ *
+ * reka had no React equivalent, 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.
+ */
+export declare const Combobox: import('react').ForwardRefExoticComponent<ComboboxProps & import('react').RefAttributes<HTMLDivElement>>;