@kamod-ui/core 0.1.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 kamod.ch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/Accordion-D1PiNspd.d.ts

@@ -0,0 +1,39 @@
+import { JSX, ComponentChildren } from 'preact';
+
+type AccordionContentProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    forceMount?: boolean;
+    /** Grid transition duration, e.g. `400ms` */
+    duration?: string;
+    /** CSS timing function, e.g. `cubic-bezier(0.4, 0, 0.2, 1)` */
+    timingFunction?: string;
+    /** Use max-height animation for very tall content to reduce micro-jank. */
+    largeContentThreshold?: number;
+    children?: ComponentChildren;
+};
+declare const AccordionContent: ({ forceMount, duration, timingFunction, largeContentThreshold, children, class: className, style, ...rest }: AccordionContentProps) => JSX.Element | null;
+
+type AccordionTriggerProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    hideIndicator?: boolean;
+    indicator?: ComponentChildren;
+    children?: ComponentChildren;
+};
+declare const AccordionTrigger: ({ hideIndicator, indicator, children, class: className, onClick, ...rest }: AccordionTriggerProps) => JSX.Element;
+
+type AccordionItemProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+    disabled?: boolean;
+    children?: ComponentChildren;
+};
+declare const AccordionItem: ({ value, disabled, children, ...rest }: AccordionItemProps) => JSX.Element;
+
+type AccordionType = "single" | "multiple";
+type AccordionProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    type?: AccordionType;
+    /** When `type="single"`, `false` keeps one panel always open (clicking the open trigger does not close it). Default `true` matches common shadcn examples. */
+    collapsible?: boolean;
+    defaultValue?: string | string[];
+    children?: ComponentChildren;
+};
+declare const Accordion: ({ type, collapsible, defaultValue, children, ...rest }: AccordionProps) => JSX.Element;
+
+export { Accordion as A, AccordionContent as a, AccordionItem as b, AccordionTrigger as c, type AccordionProps as d, type AccordionItemProps as e, type AccordionTriggerProps as f, type AccordionContentProps as g };

package/dist/AlertDialog-CpnCfDdN.d.ts

@@ -0,0 +1,64 @@
+import * as preact from 'preact';
+import { ComponentChildren, JSX } from 'preact';
+import { VariantProps } from 'tailwind-variants';
+import { b as button } from './Button-tRKMr8-H.js';
+import { e as DialogCloseProps, d as DialogTriggerProps, c as DialogProps } from './Dialog-CqCI4s9U.js';
+import { b as DialogContentProps } from './DialogContent-9VJGDt5l.js';
+
+type AlertDialogActionProps = DialogCloseProps & {
+    variant?: VariantProps<typeof button>["variant"];
+    children?: ComponentChildren;
+};
+declare const AlertDialogAction: ({ variant, class: className, children, ...rest }: AlertDialogActionProps) => preact.JSX.Element;
+
+type AlertDialogCancelProps = DialogCloseProps & {
+    variant?: VariantProps<typeof button>["variant"];
+    children?: ComponentChildren;
+};
+declare const AlertDialogCancel: ({ variant, class: className, children, ...rest }: AlertDialogCancelProps) => preact.JSX.Element;
+
+type AlertDialogMediaProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+/** Optional icon or image slot above the title (shadcn AlertDialogMedia pattern). */
+declare const AlertDialogMedia: ({ class: className, children, ...rest }: AlertDialogMediaProps) => JSX.Element;
+
+type AlertDialogDescriptionProps = JSX.HTMLAttributes<HTMLParagraphElement> & {
+    children?: ComponentChildren;
+};
+declare const AlertDialogDescription: ({ class: className, children, ...rest }: AlertDialogDescriptionProps) => JSX.Element;
+
+type AlertDialogTitleProps = JSX.HTMLAttributes<HTMLHeadingElement> & {
+    children?: ComponentChildren;
+};
+declare const AlertDialogTitle: ({ class: className, children, ...rest }: AlertDialogTitleProps) => JSX.Element;
+
+type AlertDialogFooterProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const AlertDialogFooter: ({ class: className, children, ...rest }: AlertDialogFooterProps) => JSX.Element;
+
+type AlertDialogHeaderProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const AlertDialogHeader: ({ class: className, children, ...rest }: AlertDialogHeaderProps) => JSX.Element;
+
+type AlertDialogContentSize = "default" | "sm";
+type AlertDialogContentProps = DialogContentProps & {
+    /** `sm` — narrower panel (shadcn parity). */
+    size?: AlertDialogContentSize;
+    children?: ComponentChildren;
+};
+declare const AlertDialogContent: ({ size, class: className, children, ...rest }: AlertDialogContentProps) => preact.JSX.Element;
+
+type AlertDialogTriggerProps = DialogTriggerProps & {
+    children?: ComponentChildren;
+};
+declare const AlertDialogTrigger: ({ asChild, class: className, children, ...rest }: AlertDialogTriggerProps) => preact.JSX.Element;
+
+type AlertDialogProps = DialogProps & {
+    children?: ComponentChildren;
+};
+declare const AlertDialog: ({ children, ...rest }: AlertDialogProps) => preact.JSX.Element;
+
+export { AlertDialog as A, AlertDialogAction as a, AlertDialogCancel as b, AlertDialogContent as c, AlertDialogDescription as d, AlertDialogFooter as e, AlertDialogHeader as f, AlertDialogMedia as g, AlertDialogTitle as h, AlertDialogTrigger as i, type AlertDialogProps as j, type AlertDialogTriggerProps as k, type AlertDialogContentProps as l, type AlertDialogHeaderProps as m, type AlertDialogFooterProps as n, type AlertDialogTitleProps as o, type AlertDialogDescriptionProps as p, type AlertDialogMediaProps as q, type AlertDialogCancelProps as r, type AlertDialogActionProps as s };

package/dist/Button-tRKMr8-H.d.ts

@@ -0,0 +1,84 @@
+import * as preact from 'preact';
+import { ComponentChildren, JSX } from 'preact';
+import * as tailwind_variants from 'tailwind-variants';
+import { VariantProps } from 'tailwind-variants';
+
+declare const button: tailwind_variants.TVReturnType<{
+    variant: {
+        default: string;
+        secondary: string;
+        inverse: string;
+        outline: string;
+        ghost: string;
+        destructive: string;
+        link: string;
+    };
+    size: {
+        xxs: string;
+        xs: string;
+        sm: string;
+        default: string;
+        lg: string;
+        icon: string;
+        "icon-xs": string;
+        "icon-sm": string;
+        "icon-lg": string;
+    };
+}, undefined, string[], {
+    variant: {
+        default: string;
+        secondary: string;
+        inverse: string;
+        outline: string;
+        ghost: string;
+        destructive: string;
+        link: string;
+    };
+    size: {
+        xxs: string;
+        xs: string;
+        sm: string;
+        default: string;
+        lg: string;
+        icon: string;
+        "icon-xs": string;
+        "icon-sm": string;
+        "icon-lg": string;
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    variant: {
+        default: string;
+        secondary: string;
+        inverse: string;
+        outline: string;
+        ghost: string;
+        destructive: string;
+        link: string;
+    };
+    size: {
+        xxs: string;
+        xs: string;
+        sm: string;
+        default: string;
+        lg: string;
+        icon: string;
+        "icon-xs": string;
+        "icon-sm": string;
+        "icon-lg": string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+type CommonProps = VariantProps<typeof button> & {
+    class?: string;
+    asChild?: boolean;
+    children?: ComponentChildren;
+};
+type ButtonAsButton = CommonProps & JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    href?: undefined;
+};
+type ButtonAsAnchor = CommonProps & JSX.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+};
+type ButtonProps = ButtonAsButton | ButtonAsAnchor;
+declare const Button: ({ variant, size, asChild, class: className, children, ...rest }: ButtonProps) => preact.VNode<{}> | JSX.Element | null;
+
+export { Button as B, button as b };

package/dist/CalendarDateTimePanel-B3J8OlSc.d.ts

@@ -0,0 +1,79 @@
+import { JSX, ComponentChildren } from 'preact';
+
+type DateRange = {
+    from?: Date;
+    to?: Date;
+};
+type CalendarMode = "single" | "range";
+/** `sm`: denser padding, smaller day cells, lighter caption controls (dropdown + nav). */
+type CalendarSize = "default" | "sm";
+type CalendarDisabledProp = ((date: Date) => boolean) | Date[];
+type CalendarProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "onSelect"> & {
+    mode?: CalendarMode;
+    selected?: Date | DateRange;
+    onSelect?: (value: Date | DateRange | undefined) => void;
+    /** @deprecated Use `selected` in single mode. */
+    value?: Date;
+    /** @deprecated Use `onSelect` in single mode. */
+    onValueChange?: (next: Date) => void;
+    defaultMonth?: Date;
+    month?: Date;
+    onMonthChange?: (next: Date) => void;
+    numberOfMonths?: 1 | 2;
+    captionLayout?: "buttons" | "dropdown";
+    dir?: "ltr" | "rtl";
+    /** Show days from adjacent months. @default true */
+    showOutsideDays?: boolean;
+    /** Pad to six week rows. @default false */
+    fixedWeeks?: boolean;
+    disabled?: CalendarDisabledProp;
+    /** Extra week-index column (ISO week of row start). @default false */
+    showWeekNumber?: boolean;
+    /** Named date sets for styling via `modifiersClassNames`. */
+    modifiers?: Record<string, Date[]>;
+    /** Tailwind / arbitrary classes keyed like `modifiers` (e.g. booked). */
+    modifiersClassNames?: Record<string, string>;
+    /** BCP 47 locale for captions and weekday labels. */
+    locale?: string;
+    /** Passed to `Intl` where supported; selection still uses local `Date` (use noon-normalized dates to avoid TZ drift). */
+    timeZone?: string;
+    /** Extra label under the day number (e.g. prices). Omit or return `undefined` for outside days if desired. */
+    dayAddon?: (date: Date, outside: boolean) => ComponentChildren | undefined;
+    /** Extra classes for the visible month/year caption text (single-month buttons layout and dual-month titles). */
+    captionTitleClass?: string;
+    /** If set (length 7, Sunday-first), overrides locale-derived weekday headers. */
+    weekdayLabels?: string[];
+    /** Decorative left border on the first weekday column (e.g. Su). @default false */
+    showWeekdayLeadBorder?: boolean;
+    /** Visual density; `sm` fits popovers and tight layouts. @default "default" */
+    size?: CalendarSize;
+};
+declare const Calendar: ({ class: className, mode, selected, onSelect, value, onValueChange, defaultMonth, month: monthProp, onMonthChange, numberOfMonths, captionLayout, dir, showOutsideDays, fixedWeeks, disabled, showWeekNumber, modifiers, modifiersClassNames, locale, timeZone, dayAddon, captionTitleClass, weekdayLabels, showWeekdayLeadBorder, size, ...rest }: CalendarProps) => JSX.Element;
+
+type CalendarDateTimePanelProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "onSelect"> & Pick<CalendarProps, "defaultMonth" | "month" | "onMonthChange" | "locale" | "disabled" | "dir" | "showOutsideDays" | "captionLayout" | "size"> & {
+    /** Selected calendar day (controlled). */
+    selected?: Date;
+    /** Initial day when uncontrolled. */
+    defaultSelected?: Date;
+    onSelect?: (date: Date) => void;
+    /** `HH:mm` or `HH:mm:ss` for native `input[type=time]`. */
+    startTime?: string;
+    defaultStartTime?: string;
+    onStartTimeChange?: (value: string) => void;
+    endTime?: string;
+    defaultEndTime?: string;
+    onEndTimeChange?: (value: string) => void;
+    startTimeLabel?: string;
+    endTimeLabel?: string;
+    /** Use two-letter weekday headers (Su–Sa). @default true */
+    compactWeekdays?: boolean;
+    /** Decorative line left of the first weekday; off by default. */
+    showWeekdayLeadBorder?: boolean;
+};
+/**
+ * Single-month calendar with start/end time fields, styled for a compact “schedule” card (date + time range).
+ * Defaults to `size="sm"` on the inner {@link Calendar} for a dense layout; pass `size="default"` for roomier cells.
+ */
+declare const CalendarDateTimePanel: ({ class: className, selected, defaultSelected, onSelect, defaultMonth, month, onMonthChange, locale, disabled, dir, showOutsideDays, captionLayout, size, startTime: startTimeProp, defaultStartTime, onStartTimeChange, endTime: endTimeProp, defaultEndTime, onEndTimeChange, startTimeLabel, endTimeLabel, compactWeekdays, showWeekdayLeadBorder, ...rest }: CalendarDateTimePanelProps) => JSX.Element;
+
+export { Calendar as C, type DateRange as D, CalendarDateTimePanel as a, type CalendarDateTimePanelProps as b, type CalendarDisabledProp as c, type CalendarMode as d, type CalendarSize as e, type CalendarProps as f };

package/dist/Carousel-DvlcMPpB.d.ts

@@ -0,0 +1,41 @@
+import { JSX, ComponentChildren } from 'preact';
+import { EmblaOptionsType, EmblaCarouselType, EmblaPluginType } from 'embla-carousel';
+
+type CarouselNextProps = Omit<JSX.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
+    children?: ComponentChildren;
+};
+declare const CarouselNext: ({ children, class: className, onClick, disabled, ...rest }: CarouselNextProps) => JSX.Element;
+
+type CarouselPreviousProps = Omit<JSX.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
+    children?: ComponentChildren;
+};
+declare const CarouselPrevious: ({ children, class: className, onClick, disabled, ...rest }: CarouselPreviousProps) => JSX.Element;
+
+type CarouselItemProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const CarouselItem: ({ class: className, children, ...rest }: CarouselItemProps) => JSX.Element;
+
+type CarouselContentProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    children?: ComponentChildren;
+};
+declare const CarouselContent: ({ class: className, children, ...rest }: CarouselContentProps) => JSX.Element;
+
+type CarouselApi = EmblaCarouselType;
+type CarouselOrientation = "horizontal" | "vertical";
+type CarouselProps = Omit<JSX.HTMLAttributes<HTMLDivElement>, "dir"> & {
+    opts?: EmblaOptionsType;
+    orientation?: CarouselOrientation;
+    setApi?: (api: CarouselApi | null) => void;
+    plugins?: EmblaPluginType[];
+    /** When `plugins` is omitted, adds `embla-carousel-autoplay`. Ignored if `plugins` is set. */
+    autoplay?: boolean | {
+        delay?: number;
+        stopOnInteraction?: boolean;
+    };
+    dir?: "ltr" | "rtl";
+    children?: ComponentChildren;
+};
+declare const Carousel: ({ opts, orientation, setApi, plugins, autoplay, dir, class: className, children, ...rest }: CarouselProps) => JSX.Element;
+
+export { Carousel as C, type CarouselApi as a, CarouselContent as b, CarouselItem as c, CarouselNext as d, type CarouselOrientation as e, CarouselPrevious as f, type CarouselProps as g, type CarouselContentProps as h, type CarouselItemProps as i, type CarouselPreviousProps as j, type CarouselNextProps as k };

package/dist/Chart-Ax22S5_N.d.ts

@@ -0,0 +1,10 @@
+import { JSX, ComponentChildren } from 'preact';
+
+type ChartProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    title?: string;
+    description?: string;
+    children?: ComponentChildren;
+};
+declare const Chart: ({ class: className, title, description, children, ...rest }: ChartProps) => JSX.Element;
+
+export { Chart as C };

package/dist/Checkbox-DBbLYq6Q.d.ts

@@ -0,0 +1,12 @@
+import { JSX } from 'preact';
+
+type CheckboxCheckedState = boolean | "indeterminate";
+type CheckboxProps = Omit<JSX.InputHTMLAttributes<HTMLInputElement>, "type" | "checked" | "defaultChecked" | "onChange"> & {
+    checked?: CheckboxCheckedState;
+    defaultChecked?: CheckboxCheckedState;
+    onCheckedChange?: (checked: CheckboxCheckedState) => void;
+    onChange?: (event: JSX.TargetedEvent<HTMLInputElement>) => void;
+};
+declare const Checkbox: ({ checked: checkedProp, defaultChecked, onCheckedChange, onChange, class: className, disabled, ref: outerRef, id, ...rest }: CheckboxProps) => JSX.Element;
+
+export { Checkbox as C, type CheckboxCheckedState as a };

package/dist/Collapsible-DSZCp0tm.d.ts

@@ -0,0 +1,34 @@
+import * as preact from 'preact';
+import { JSX, ComponentChildren } from 'preact';
+
+type CollapsibleContentProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    forceMount?: boolean;
+    /** Grid transition duration, e.g. `400ms` */
+    duration?: string;
+    /** CSS timing function, e.g. `cubic-bezier(0.4, 0, 0.2, 1)` */
+    timingFunction?: string;
+    /** Use max-height animation for very tall content to reduce micro-jank. */
+    largeContentThreshold?: number;
+    children?: ComponentChildren;
+};
+declare const CollapsibleContent: ({ forceMount, duration, timingFunction, largeContentThreshold, children, class: className, style, ...rest }: CollapsibleContentProps) => JSX.Element | null;
+
+type CollapsibleTriggerProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    children?: ComponentChildren;
+    "data-slot"?: string;
+};
+declare const CollapsibleTrigger: ({ asChild, children, onClick, ref: outerRef, "data-slot": dataSlot, ...rest }: CollapsibleTriggerProps) => preact.VNode<{}> | JSX.Element | null;
+
+type CollapsibleProps = JSX.HTMLAttributes<HTMLDivElement> & {
+    /** Uncontrolled initial state */
+    defaultOpen?: boolean;
+    /** Controlled open state */
+    open?: boolean;
+    /** Called when open state changes (toggle or programmatic) */
+    onOpenChange?: (open: boolean) => void;
+    children?: ComponentChildren;
+};
+declare const Collapsible: ({ defaultOpen, open: openProp, onOpenChange, children, ...rest }: CollapsibleProps) => JSX.Element;
+
+export { Collapsible as C, CollapsibleContent as a, CollapsibleTrigger as b, type CollapsibleProps as c, type CollapsibleTriggerProps as d, type CollapsibleContentProps as e };

package/dist/ComboboxInlineInput-CB7CEXzy.d.ts

@@ -0,0 +1,135 @@
+import * as preact from 'preact';
+import { JSX, ComponentChildren } from 'preact';
+import { a as PopoverTriggerProps, P as PopoverContentProps } from './PopoverTrigger-B6kK73gh.js';
+import { C as CommandProps, e as CommandInputProps, l as CommandListProps, m as CommandItemProps } from './CommandSeparator-pJQnB9Lu.js';
+import { Signal } from '@preact/signals';
+
+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;
+
+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;
+
+declare const ComboboxContent: ({ forceMount: forceMountProp, class: className, ...rest }: PopoverContentProps) => preact.JSX.Element;
+
+declare const ComboboxCommand: ({ autoHighlight: autoHighlightProp, class: className, children, ...rest }: CommandProps) => preact.JSX.Element;
+
+declare const ComboboxInput: ({ class: className, ...rest }: CommandInputProps) => 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 ComboboxItemProps = Omit<CommandItemProps, "value" | "onSelect"> & {
+    item: unknown;
+};
+declare const ComboboxItem: ({ item, class: className, children, disabled, onClick, ...rest }: ComboboxItemProps) => preact.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;
+
+type ComboboxClearProps = JSX.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ComboboxClear: ({ class: className, onClick, ...rest }: ComboboxClearProps) => JSX.Element | null;
+
+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 ComboboxChipProps = Omit<JSX.HTMLAttributes<HTMLSpanElement>, "children"> & {
+    itemKey: string;
+    children?: ComponentChildren;
+};
+declare const ComboboxChip: ({ itemKey: chipKey, children, class: className, ...rest }: ComboboxChipProps) => 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 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;
+
+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-pJQnB9Lu.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 CommandListProps as l, type CommandItemProps 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-CqCI4s9U.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) => preact.VNode<{}> | JSX.Element | 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) => preact.VNode<{}> | JSX.Element | 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-9VJGDt5l.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, ...rest }: DialogContentProps) => preact.VNode<any> | null;
+
+export { DialogContent as D, type DialogContentPresentation as a, type DialogContentProps as b };