@kamod-ch/ui 0.2.1

package/dist/ComboboxValue-BGfXgtZt.d.ts

@@ -0,0 +1,135 @@
+import * as preact from 'preact';
+import { JSX, ComponentChildren } from 'preact';
+import { C as CommandProps, e as CommandInputProps, l as CommandItemProps, m as CommandListProps } from './CommandSeparator-wZRCsqsT.js';
+import { P as PopoverContentProps, a as PopoverTriggerProps } from './PopoverTrigger-CH_Kx2mn.js';
+import { Signal } from '@preact/signals';
+
+type ComboboxChipProps = Omit<JSX.HTMLAttributes<HTMLSpanElement>, "children"> & {
+    itemKey: string;
+    children?: ComponentChildren;
+};
+declare const ComboboxChip: ({ itemKey: chipKey, children, class: className, ...rest }: ComboboxChipProps) => JSX.Element;
+
+type ComboboxChipsProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+/** Multi-select trigger row: wrap chips + `ComboboxChipsInput` (with `liftedFilter`). */
+declare const ComboboxChips: ({ class: className, children, ...rest }: ComboboxChipsProps) => JSX.Element;
+
+type ComboboxChipsInputProps = JSX.InputHTMLAttributes<HTMLInputElement>;
+/** Filter field at the end of the chip row; requires `Combobox liftedFilter`. */
+declare const ComboboxChipsInput: ({ class: className, onKeyDown, onInput, onFocus, ...rest }: ComboboxChipsInputProps) => JSX.Element;
+
+type ComboboxClearProps = JSX.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ComboboxClear: ({ class: className, onClick, ...rest }: ComboboxClearProps) => JSX.Element | null;
+
+declare const ComboboxCommand: ({ autoHighlight: autoHighlightProp, class: className, children, ...rest }: CommandProps) => preact.JSX.Element;
+
+declare const ComboboxContent: ({ forceMount: forceMountProp, class: className, ...rest }: PopoverContentProps) => preact.JSX.Element;
+
+type ComboboxInlineInputProps = JSX.InputHTMLAttributes<HTMLInputElement>;
+/**
+ * Base UI–style trigger: the visible field is the filter input; the list opens in `ComboboxContent`.
+ * Requires `Combobox liftedFilter` (and usually `ComboboxTrigger asChild` wrapping a positioned container).
+ */
+declare const ComboboxInlineInput: ({ class: className, onKeyDown, onInput, onFocus, ...rest }: ComboboxInlineInputProps) => JSX.Element;
+
+declare const ComboboxInput: ({ class: className, ...rest }: CommandInputProps) => preact.JSX.Element;
+
+type ComboboxItemProps = Omit<CommandItemProps, "value" | "onSelect"> & {
+    item: unknown;
+};
+declare const ComboboxItem: ({ item, class: className, children, disabled, onClick, ...rest }: ComboboxItemProps) => preact.JSX.Element;
+
+type ComboboxListProps = Omit<CommandListProps, "children"> & {
+    items?: readonly unknown[];
+    children: ComponentChildren | ((item: unknown, index: number) => ComponentChildren);
+};
+declare const ComboboxList: ({ items: itemsProp, children, onMount, ...rest }: ComboboxListProps) => preact.JSX.Element;
+
+type ComboboxCommandNav = {
+    moveHighlight: (delta: number) => void;
+    activateHighlighted: () => void;
+};
+type ComboboxContextValue = {
+    items: readonly unknown[];
+    leafItems: unknown[];
+    itemToString: (item: unknown) => string;
+    itemKey: (item: unknown) => string;
+    selectedKeys: string[];
+    /** First selected key; empty string if none (single-select ergonomics). */
+    selectedKey: string;
+    multiple: boolean;
+    isSelected: (key: string) => boolean;
+    selectByItem: (item: unknown) => void;
+    toggleByItem: (item: unknown) => void;
+    removeKey: (key: string) => void;
+    clearSelection: () => void;
+    placeholder: string;
+    disabled: boolean;
+    liftedFilter: boolean;
+    filterQuery: Signal<string> | null;
+    hasVisibleItems: Signal<boolean> | null;
+    autoHighlight: boolean;
+    showClear: boolean;
+    closeOnSelect: boolean;
+    comboboxListRef: {
+        current: HTMLDivElement | null;
+    };
+    commandNavRef: {
+        current: ComboboxCommandNav | null;
+    };
+};
+declare const useCombobox: () => ComboboxContextValue;
+declare function comboboxSelectionLabel(ctx: ComboboxContextValue): string;
+type ComboboxProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "children"> & {
+    items?: readonly unknown[];
+    itemToStringValue?: (item: unknown) => string;
+    itemKey?: (item: unknown) => string;
+    value?: string | string[];
+    defaultValue?: string | string[];
+    /** Emits `string` when `multiple` is false, else `string[]`. */
+    onValueChange?: (value: string | string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    multiple?: boolean;
+    /** Share filter text between trigger input and `Command` (Base UI–style single input + list in popover). */
+    liftedFilter?: boolean;
+    /** Highlight first match and enable ArrowUp/Down + Enter in filter inputs (requires `ComboboxCommand autoHighlight` or preset). */
+    autoHighlight?: boolean;
+    showClear?: boolean;
+    /** When `multiple`, defaults to `false`; when single, defaults to `true`. */
+    closeOnSelect?: boolean;
+    children?: ComponentChildren;
+};
+declare const Combobox: ({ items, itemToStringValue, itemKey: itemKeyProp, value: valueProp, defaultValue, onValueChange, placeholder, disabled, open: openProp, defaultOpen, onOpenChange, multiple: multipleProp, liftedFilter, autoHighlight, showClear, closeOnSelect: closeOnSelectProp, class: className, children, ...rest }: ComboboxProps) => JSX.Element;
+
+type ComboboxOption = {
+    label: string;
+    value: string;
+};
+type ComboboxSelectProps = Omit<ComboboxProps, "items" | "children" | "itemKey" | "itemToStringValue"> & {
+    options: ComboboxOption[];
+    searchPlaceholder?: string;
+    emptyText?: string;
+    triggerClass?: string;
+};
+/** Preset around `{ label, value }[]`: button trigger, inline input trigger, multi chips, clear, and auto-highlight. */
+declare const ComboboxSelect: ({ options, searchPlaceholder, emptyText, triggerClass, showClear, autoHighlight, liftedFilter, multiple, class: className, placeholder, ...rest }: ComboboxSelectProps) => preact.JSX.Element;
+
+declare const ComboboxTrigger: ({ class: className, disabled, ...rest }: PopoverTriggerProps) => preact.JSX.Element;
+
+type ComboboxValueProps = Omit<JSX.HTMLAttributes<HTMLSpanElement>, "children"> & {
+    placeholder?: string;
+    children?: ((state: {
+        label: string;
+        empty: boolean;
+        keys: string[];
+    }) => ComponentChildren) | ComponentChildren;
+};
+declare const ComboboxValue: ({ placeholder: placeholderProp, children, class: className, ...rest }: ComboboxValueProps) => JSX.Element;
+
+export { type ComboboxContextValue as A, comboboxSelectionLabel as B, Combobox as C, ComboboxChip as a, type ComboboxChipProps as b, ComboboxChips as c, ComboboxChipsInput as d, type ComboboxChipsInputProps as e, type ComboboxChipsProps as f, ComboboxClear as g, type ComboboxClearProps as h, ComboboxCommand as i, type ComboboxCommandNav as j, ComboboxContent as k, ComboboxInlineInput as l, type ComboboxInlineInputProps as m, ComboboxInput as n, ComboboxItem as o, type ComboboxItemProps as p, ComboboxList as q, type ComboboxListProps as r, type ComboboxOption as s, type ComboboxProps as t, ComboboxSelect as u, type ComboboxSelectProps as v, ComboboxTrigger as w, ComboboxValue as x, type ComboboxValueProps as y, useCombobox as z };

package/dist/CommandSeparator-wZRCsqsT.d.ts

@@ -0,0 +1,47 @@
+import { Signal } from '@preact/signals';
+import { JSX, ComponentChildren } from 'preact';
+
+type CommandProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+    /** First visible item gets `data-highlighted`; enables ArrowUp/Down + Enter in `CommandInput`. */
+    autoHighlight?: boolean;
+    /** External filter signal (e.g. combobox inline input shares query with the list). */
+    query?: Signal<string>;
+    /** External visibility signal; updated by `CommandList` when provided. */
+    hasVisibleItems?: Signal<boolean>;
+};
+declare const Command: ({ class: className, children, autoHighlight, query: queryProp, hasVisibleItems: hasVisibleProp, ...rest }: CommandProps) => JSX.Element;
+
+type CommandEmptyProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const CommandEmpty: ({ children, class: className, ...rest }: CommandEmptyProps) => JSX.Element | null;
+
+type CommandGroupProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    heading?: string;
+    children?: ComponentChildren;
+};
+declare const CommandGroup: ({ heading, class: className, children, ...rest }: CommandGroupProps) => JSX.Element;
+
+type CommandInputProps = JSX.InputHTMLAttributes<HTMLInputElement>;
+declare const CommandInput: ({ class: className, onInput, onKeyDown, ...rest }: CommandInputProps) => JSX.Element;
+
+type CommandItemProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    /** Used for case-insensitive filtering against the query. */
+    value: string;
+    children?: ComponentChildren;
+    onSelect?: (value: string) => void;
+};
+declare const CommandItem: ({ class: className, value, children, disabled, onClick, onSelect, ...rest }: CommandItemProps) => JSX.Element;
+
+type CommandListProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+    /** Notified when the list root mounts (e.g. combobox inline input forwards keyboard to the list). */
+    onMount?: (el: HTMLDivElement | null) => void;
+};
+declare const CommandList: ({ class: className, children, onMount, ...rest }: CommandListProps) => JSX.Element;
+
+type CommandSeparatorProps = JSX.HTMLAttributes<HTMLHRElement>;
+declare const CommandSeparator: ({ class: className, ...rest }: CommandSeparatorProps) => JSX.Element;
+
+export { type CommandProps as C, CommandEmpty as a, type CommandEmptyProps as b, CommandGroup as c, type CommandGroupProps as d, type CommandInputProps as e, CommandSeparator as f, type CommandSeparatorProps as g, Command as h, CommandInput as i, CommandItem as j, CommandList as k, type CommandItemProps as l, type CommandListProps as m };

package/dist/DataTable-zNTTdYVU.d.ts

@@ -0,0 +1,13 @@
+import { JSX, ComponentChildren } from 'preact';
+
+type DataTableProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+    /**
+     * When true (default), wraps the table in `overflow-hidden rounded-md border` like shadcn data tables.
+     * Set false if you already provide an outer chrome or use a bare `<Table>`.
+     */
+    chrome?: boolean;
+};
+declare const DataTable: ({ chrome, class: className, children, ...rest }: DataTableProps) => JSX.Element;
+
+export { DataTable as D };

package/dist/DatePicker-AFAYh5Ca.d.ts

@@ -0,0 +1,20 @@
+import { JSX, ComponentChildren } from 'preact';
+
+/** Long date label (~`date-fns` `PPP`) without extra dependencies. */
+declare const formatDatePickerDisplay: (date: Date, locale?: string) => string;
+type DatePickerProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "onChange"> & {
+    value?: Date;
+    defaultValue?: Date;
+    onValueChange?: (next: Date | undefined) => void;
+    placeholder?: string;
+    /** Close popover after a day is picked (single mode). @default true */
+    closeOnSelect?: boolean;
+    align?: "start" | "center" | "end";
+    /** Trigger affordance aligned with shadcn demos. @default "chevron" */
+    triggerIcon?: "chevron" | "calendar" | "none";
+    format?: (date: Date) => string;
+    children?: ComponentChildren;
+};
+declare const DatePicker: ({ class: className, value, defaultValue, onValueChange, placeholder, closeOnSelect, align, triggerIcon, format, children, ...rest }: DatePickerProps) => JSX.Element;
+
+export { DatePicker as D, formatDatePickerDisplay as f };

package/dist/Dialog-BOIteLfe.d.ts

@@ -0,0 +1,28 @@
+import * as preact from 'preact';
+import { JSX, ComponentChildren } from 'preact';
+
+type DialogCloseProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    children?: ComponentChildren;
+    "data-slot"?: string;
+};
+declare const DialogClose: ({ asChild, children, onClick, ref: outerRef, "data-slot": dataSlot, ...rest }: DialogCloseProps) => JSX.Element | preact.VNode<{}> | null;
+
+type DialogTriggerProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    children?: ComponentChildren;
+    "data-slot"?: string;
+};
+declare const DialogTrigger: ({ asChild, children, onClick, onPointerDown, ref: outerRef, "data-slot": dataSlot, ...rest }: DialogTriggerProps) => JSX.Element | preact.VNode<{}> | null;
+
+type DialogProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** When true, locks document scroll while open (shadcn default). */
+    lockBodyScroll?: boolean;
+    children?: ComponentChildren;
+};
+declare const Dialog: ({ defaultOpen, open: openProp, onOpenChange, lockBodyScroll, children, ...rest }: DialogProps) => JSX.Element;
+
+export { Dialog as D, DialogClose as a, DialogTrigger as b, type DialogProps as c, type DialogTriggerProps as d, type DialogCloseProps as e };

package/dist/DialogContent-CK1t4m4e.d.ts

@@ -0,0 +1,24 @@
+import * as preact from 'preact';
+import { JSX, ComponentChildren } from 'preact';
+
+type DialogContentPresentation = "modal" | "slot";
+type DialogContentProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    forceMount?: boolean;
+    /**
+     * `modal` — built-in overlay + centered panel + optional corner close.
+     * `slot` — one portaled element only; use when **you** provide overlay + panel (legacy fullscreen `DialogContent` pattern with `fixed inset-0 …`).
+     */
+    presentation?: DialogContentPresentation;
+    showCloseButton?: boolean;
+    children?: ComponentChildren;
+    "data-slot"?: string;
+};
+/**
+ * Renders dialog body in a portal.
+ *
+ * - **modal (default):** Backdrop + centered panel; use `class` only for sizing (e.g. `sm:max-w-sm`).
+ * - **slot:** Single root node — **required** for legacy/custom layouts that already implement `fixed inset-0` overlay + inner card (otherwise you stack two modals).
+ */
+declare const DialogContent: ({ forceMount, presentation, showCloseButton, class: className, children, onKeyDown, "data-slot": dataSlot, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, ...rest }: DialogContentProps) => preact.VNode<any> | null;
+
+export { DialogContent as D, type DialogContentPresentation as a, type DialogContentProps as b };

package/dist/DialogHeader-CYT7iUDq.d.ts

@@ -0,0 +1,13 @@
+import { JSX, ComponentChildren } from 'preact';
+
+type DialogFooterProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const DialogFooter: ({ class: className, children, ...rest }: DialogFooterProps) => JSX.Element;
+
+type DialogHeaderProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const DialogHeader: ({ class: className, children, ...rest }: DialogHeaderProps) => JSX.Element;
+
+export { DialogFooter as D, DialogHeader as a, type DialogHeaderProps as b, type DialogFooterProps as c };

package/dist/DialogTitle-CerJD0oA.d.ts

@@ -0,0 +1,13 @@
+import { JSX, ComponentChildren } from 'preact';
+
+type DialogDescriptionProps = JSX.HTMLAttributes<HTMLParagraphElement> & {
+    children?: ComponentChildren;
+};
+declare const DialogDescription: ({ class: className, children, id: idProp, ...rest }: DialogDescriptionProps) => JSX.Element;
+
+type DialogTitleProps = JSX.HTMLAttributes<HTMLHeadingElement> & {
+    children?: ComponentChildren;
+};
+declare const DialogTitle: ({ class: className, children, id: idProp, ...rest }: DialogTitleProps) => JSX.Element;
+
+export { DialogDescription as D, DialogTitle as a, type DialogTitleProps as b, type DialogDescriptionProps as c };

package/dist/Direction-25ZOt0gW.d.ts

@@ -0,0 +1,24 @@
+import { JSX, ComponentChildren } from 'preact';
+
+type DirectionValue = "ltr" | "rtl";
+/** Returns the active text direction from the nearest `DirectionProvider` / `Direction` wrapper (default `ltr`). */
+declare const useDirection: () => DirectionValue;
+type DirectionProviderProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "dir"> & {
+    /** Text direction for the subtree — matches shadcn `DirectionProvider` (`direction` prop). */
+    direction?: DirectionValue;
+    children?: ComponentChildren;
+    "data-slot"?: string;
+};
+/**
+ * Sets both React context and the HTML `dir` attribute on a wrapping element so logical CSS (`ms-*`, `me-*`, etc.) resolves correctly.
+ * For full-document RTL, also set `dir` on `<html>` (see docs).
+ */
+declare const DirectionProvider: ({ direction, class: className, children, "data-slot": dataSlot, ...rest }: DirectionProviderProps) => JSX.Element;
+type DirectionProps = Omit<DirectionProviderProps, "direction"> & {
+    /** Kamod legacy prop — same as `direction` on `DirectionProvider`. */
+    dir?: DirectionValue;
+};
+/** Same as `DirectionProvider` but uses prop `dir` instead of `direction` (backwards compatible). */
+declare const Direction: ({ dir, ...rest }: DirectionProps) => JSX.Element;
+
+export { Direction as D, type DirectionProps as a, DirectionProvider as b, type DirectionProviderProps as c, type DirectionValue as d, useDirection as u };

package/dist/Drawer-B3pZMn5j.d.ts

@@ -0,0 +1,41 @@
+import * as preact from 'preact';
+import { ComponentChildren } from 'preact';
+import { e as DialogCloseProps, d as DialogTriggerProps } from './Dialog-BOIteLfe.js';
+import { c as DialogDescriptionProps, b as DialogTitleProps } from './DialogTitle-CerJD0oA.js';
+import { g as SheetFooterProps, f as SheetHeaderProps, e as SheetContentProps, d as SheetProps } from './Sheet-s0xRF22F.js';
+
+type DrawerCloseProps = DialogCloseProps;
+declare const DrawerClose: (props: DrawerCloseProps) => preact.JSX.Element;
+
+type DrawerDescriptionProps = DialogDescriptionProps;
+declare const DrawerDescription: (props: DrawerDescriptionProps) => preact.JSX.Element;
+
+type DrawerTitleProps = DialogTitleProps;
+declare const DrawerTitle: (props: DrawerTitleProps) => preact.JSX.Element;
+
+type DrawerFooterProps = SheetFooterProps;
+declare const DrawerFooter: (props: DrawerFooterProps) => preact.JSX.Element;
+
+type DrawerHeaderProps = SheetHeaderProps;
+declare const DrawerHeader: (props: DrawerHeaderProps) => preact.JSX.Element;
+
+type DrawerContentProps = Omit<SheetContentProps, "side"> & {
+    /** Drag affordance for top/bottom drawers. Default: `true` when `direction` is top or bottom. */
+    showHandle?: boolean;
+    children?: ComponentChildren;
+};
+declare const DrawerContent: ({ showHandle, showCloseButton, class: className, children, ...rest }: DrawerContentProps) => preact.JSX.Element;
+
+type DrawerTriggerProps = DialogTriggerProps;
+declare const DrawerTrigger: (props: DrawerTriggerProps) => preact.JSX.Element;
+
+type DrawerDirection = "top" | "right" | "bottom" | "left";
+
+type DrawerProps = SheetProps & {
+    /** Edge the drawer opens from (shadcn/Vaul `direction`). Default `bottom`. */
+    direction?: DrawerDirection;
+    children?: ComponentChildren;
+};
+declare const Drawer: ({ direction, children, ...rest }: DrawerProps) => preact.JSX.Element;
+
+export { Drawer as D, DrawerClose as a, DrawerContent as b, DrawerDescription as c, type DrawerDirection as d, DrawerFooter as e, DrawerHeader as f, DrawerTitle as g, DrawerTrigger as h, type DrawerProps as i, type DrawerTriggerProps as j, type DrawerContentProps as k, type DrawerHeaderProps as l, type DrawerFooterProps as m, type DrawerTitleProps as n, type DrawerDescriptionProps as o, type DrawerCloseProps as p };

package/dist/Dropdown-CVbWVKok.d.ts

@@ -0,0 +1,143 @@
+import * as preact from 'preact';
+import { JSX, ComponentChildren } from 'preact';
+import * as tailwind_variants from 'tailwind-variants';
+import { VariantProps } from 'tailwind-variants';
+
+type DropdownRadioItemProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: string;
+    children?: ComponentChildren;
+};
+declare const DropdownRadioItem: ({ value, class: className, children, onClick, ...rest }: DropdownRadioItemProps) => JSX.Element;
+
+type DropdownRadioGroupProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    children?: ComponentChildren;
+};
+declare const DropdownRadioGroup: ({ value, defaultValue, onValueChange, children, ...rest }: DropdownRadioGroupProps) => JSX.Element;
+
+type DropdownCheckboxItemProps = Omit<JSX.ButtonHTMLAttributes<HTMLButtonElement>, "children"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    children?: ComponentChildren;
+};
+declare const DropdownCheckboxItem: ({ checked: checkedProp, defaultChecked, onCheckedChange, class: className, children, onClick, ...rest }: DropdownCheckboxItemProps) => JSX.Element;
+
+/** No-op wrapper for API parity with shadcn; content stays in the tree (no portal). */
+type DropdownPortalProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const DropdownPortal: ({ children, ...rest }: DropdownPortalProps) => JSX.Element;
+
+type DropdownSubContentProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+    /** `inline-end` (default): opens toward inline end (right in LTR). `inline-start`: toward inline start (left in LTR) — use near the viewport edge to avoid horizontal page scroll. */
+    side?: "inline-end" | "inline-start";
+};
+declare const DropdownSubContent: ({ class: className, children, onPointerEnter, side, ...rest }: DropdownSubContentProps) => JSX.Element | null;
+
+type DropdownSubTriggerProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    children?: ComponentChildren;
+};
+declare const DropdownSubTrigger: ({ class: className, children, onClick, onPointerEnter, ...rest }: DropdownSubTriggerProps) => JSX.Element;
+
+type DropdownSubProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const DropdownSub: ({ class: className, children, ...rest }: DropdownSubProps) => JSX.Element;
+
+type DropdownShortcutProps = JSX.HTMLAttributes<HTMLSpanElement> & {
+    children?: ComponentChildren;
+};
+declare const DropdownShortcut: ({ class: className, children, ...rest }: DropdownShortcutProps) => JSX.Element;
+
+type DropdownGroupProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const DropdownGroup: ({ class: className, children, ...rest }: DropdownGroupProps) => JSX.Element;
+
+type DropdownSeparatorProps = JSX.HTMLAttributes<HTMLDivElement>;
+declare const DropdownSeparator: ({ class: className, ...rest }: DropdownSeparatorProps) => JSX.Element;
+
+type DropdownLabelProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    inset?: boolean;
+    children?: ComponentChildren;
+};
+declare const DropdownLabel: ({ inset, class: className, children, ...rest }: DropdownLabelProps) => JSX.Element;
+
+declare const dropdownItem: tailwind_variants.TVReturnType<{
+    variant: {
+        default: string;
+        destructive: string;
+    };
+    inset: {
+        true: string;
+    };
+}, undefined, string[], {
+    variant: {
+        default: string;
+        destructive: string;
+    };
+    inset: {
+        true: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    variant: {
+        default: string;
+        destructive: string;
+    };
+    inset: {
+        true: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type DropdownItemProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<typeof dropdownItem> & {
+    children?: ComponentChildren;
+};
+declare const DropdownItem: ({ inset, variant, class: className, children, onClick, ...rest }: DropdownItemProps) => JSX.Element;
+
+declare const dropdownContent: tailwind_variants.TVReturnType<{
+    side: {
+        bottom: string;
+        top: string;
+        right: string;
+        left: string;
+    };
+}, undefined, string[], {
+    side: {
+        bottom: string;
+        top: string;
+        right: string;
+        left: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    side: {
+        bottom: string;
+        top: string;
+        right: string;
+        left: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type DropdownContentProps = JSX.HTMLAttributes<HTMLDivElement> & VariantProps<typeof dropdownContent> & {
+    forceMount?: boolean;
+    side?: "top" | "bottom" | "left" | "right";
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+    children?: ComponentChildren;
+};
+declare const DropdownContent: ({ forceMount, side, align, sideOffset, class: className, style, children, onKeyDown, ...rest }: DropdownContentProps) => JSX.Element | null;
+
+type DropdownTriggerProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    children?: ComponentChildren;
+};
+declare const DropdownTrigger: ({ asChild, class: className, children, onClick, ref: outerRef, ...rest }: DropdownTriggerProps) => JSX.Element | preact.VNode<{}> | null;
+
+type DropdownProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    children?: ComponentChildren;
+};
+declare const Dropdown: ({ defaultOpen, class: className, children, ...rest }: DropdownProps) => JSX.Element;
+
+export { type DropdownCheckboxItemProps as A, type DropdownRadioGroupProps as B, type DropdownRadioItemProps as C, Dropdown as D, DropdownCheckboxItem as a, DropdownContent as b, DropdownGroup as c, DropdownItem as d, DropdownLabel as e, DropdownPortal as f, DropdownRadioGroup as g, DropdownRadioItem as h, DropdownSeparator as i, DropdownShortcut as j, DropdownSub as k, DropdownSubContent as l, DropdownSubTrigger as m, DropdownTrigger as n, type DropdownProps as o, type DropdownTriggerProps as p, type DropdownContentProps as q, type DropdownItemProps as r, type DropdownLabelProps as s, type DropdownSeparatorProps as t, type DropdownGroupProps as u, type DropdownShortcutProps as v, type DropdownSubProps as w, type DropdownSubTriggerProps as x, type DropdownSubContentProps as y, type DropdownPortalProps as z };

package/dist/FieldTitle-aSgThW-B.d.ts

@@ -0,0 +1,100 @@
+import { JSX, ComponentChildren } from 'preact';
+import * as tailwind_variants from 'tailwind-variants';
+import { VariantProps } from 'tailwind-variants';
+
+/** Root layout for composable Field (shadcn fieldVariants). */
+declare const fieldRoot: tailwind_variants.TVReturnType<{
+    orientation: {
+        vertical: string;
+        horizontal: string[];
+        responsive: string[];
+    };
+}, undefined, string[], {
+    orientation: {
+        vertical: string;
+        horizontal: string[];
+        responsive: string[];
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    orientation: {
+        vertical: string;
+        horizontal: string[];
+        responsive: string[];
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type FieldRootVariants = VariantProps<typeof fieldRoot>;
+
+type FieldProps = JSX.HTMLAttributes<HTMLDivElement> & FieldRootVariants & {
+    /** Legacy: label text/node (composition: use FieldLabel instead). */
+    label?: ComponentChildren;
+    /** Legacy: helper below control. */
+    description?: ComponentChildren;
+    /** Legacy: error below control. */
+    error?: ComponentChildren;
+    required?: boolean;
+    orientation?: "vertical" | "horizontal" | "responsive";
+    disabled?: boolean;
+    invalid?: boolean;
+    children?: ComponentChildren;
+};
+declare const Field: ({ class: className, label, description, error, required, orientation, disabled, invalid, children, ...rest }: FieldProps) => JSX.Element;
+
+type FieldContentProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const FieldContent: ({ class: className, children, ...rest }: FieldContentProps) => JSX.Element;
+
+type FieldDescriptionProps = JSX.HTMLAttributes<HTMLParagraphElement> & {
+    children?: ComponentChildren;
+};
+declare const FieldDescription: ({ class: className, children, ...rest }: FieldDescriptionProps) => JSX.Element;
+
+type FieldErrorProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    errors?: Array<{
+        message?: string;
+    } | undefined>;
+    children?: ComponentChildren;
+};
+declare const FieldError: ({ class: className, children, errors, ...rest }: FieldErrorProps) => JSX.Element | null;
+
+type FieldGroupProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const FieldGroup: ({ class: className, children, ...rest }: FieldGroupProps) => JSX.Element;
+
+type FieldLabelProps = JSX.LabelHTMLAttributes<HTMLLabelElement>;
+declare const FieldLabel: ({ class: className, ...rest }: FieldLabelProps) => JSX.Element;
+
+declare const fieldLegend: tailwind_variants.TVReturnType<{
+    variant: {
+        legend: string;
+        label: string;
+    };
+}, undefined, "", {
+    variant: {
+        legend: string;
+        label: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    variant: {
+        legend: string;
+        label: string;
+    };
+}, undefined, "", unknown, unknown, undefined>>;
+type FieldLegendProps = JSX.HTMLAttributes<HTMLLegendElement> & VariantProps<typeof fieldLegend>;
+declare const FieldLegend: ({ class: className, variant, ...rest }: FieldLegendProps) => JSX.Element;
+
+type FieldSeparatorProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const FieldSeparator: ({ class: className, children, ...rest }: FieldSeparatorProps) => JSX.Element;
+
+type FieldSetProps = JSX.FieldsetHTMLAttributes<HTMLFieldSetElement>;
+declare const FieldSet: ({ class: className, ...rest }: FieldSetProps) => JSX.Element;
+
+type FieldTitleProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const FieldTitle: ({ class: className, children, ...rest }: FieldTitleProps) => JSX.Element;
+
+export { Field as F, FieldContent as a, FieldDescription as b, FieldError as c, FieldGroup as d, FieldLabel as e, FieldLegend as f, type FieldRootVariants as g, FieldSeparator as h, FieldSet as i, FieldTitle as j, fieldRoot as k };

package/dist/HoverCard-aVEEtkyO.d.ts

@@ -0,0 +1,52 @@
+import * as tailwind_variants from 'tailwind-variants';
+import { VariantProps } from 'tailwind-variants';
+import * as preact from 'preact';
+import { JSX, ComponentChildren } from 'preact';
+
+declare const hoverCardContent: tailwind_variants.TVReturnType<{
+    side: {
+        bottom: string;
+        top: string;
+        right: string;
+        left: string;
+    };
+}, undefined, string[], {
+    side: {
+        bottom: string;
+        top: string;
+        right: string;
+        left: string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    side: {
+        bottom: string;
+        top: string;
+        right: string;
+        left: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type HoverCardContentProps = JSX.HTMLAttributes<HTMLDivElement> & VariantProps<typeof hoverCardContent> & {
+    side?: "top" | "bottom" | "left" | "right";
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+    children?: ComponentChildren;
+};
+declare const HoverCardContent: ({ side, align, sideOffset, class: className, style, children, onKeyDown, onMouseEnter, onMouseLeave, ...rest }: HoverCardContentProps) => JSX.Element | null;
+
+type HoverCardTriggerProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    children?: ComponentChildren;
+};
+declare const HoverCardTrigger: ({ asChild, class: className, children, onFocus, onBlur, onMouseEnter, onMouseLeave, ref: outerRef, ...rest }: HoverCardTriggerProps) => JSX.Element | preact.VNode<{}> | null;
+
+type HoverCardProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    /** Delay before opening (ms). Radix default 700. */
+    openDelay?: number;
+    /** Delay before closing (ms). Radix default 300. */
+    closeDelay?: number;
+    children?: ComponentChildren;
+};
+declare const HoverCard: ({ defaultOpen, openDelay, closeDelay, children, ...rest }: HoverCardProps) => JSX.Element;
+
+export { HoverCard as H, HoverCardContent as a, HoverCardTrigger as b, type HoverCardProps as c, type HoverCardTriggerProps as d, type HoverCardContentProps as e };